///|
pub(all) enum PackOwner {
  MoonGate
  MoonClaw
  MoonBook
  Moondesk
  PriceAction
} derive(Debug, Eq, ToJson, FromJson)

///|
pub(all) enum ToolCapability {
  ComposeWorkspace
  ComposeProductStatus
  EvaluateAcceptance
  EvaluateParity
  EvaluateCutoverComparison
  EvaluateReadiness
  PrepareSettings
  PrepareCutover
  PrepareOperatorHandoff
  PrepareDecommission
  ExecuteRoutine
  PlanRoutine
  ManageJob
  PlanRetry
  ReadMarketData
  ComputeFeatures
  ValidateContract
  RouteStrategy
  PersistEvidence
  RenderOperatorView
  AssemblePrompt
  PlanContext
  RouteModelCall
  PrepareFollowUp
  PrepareReplay
  PrepareExport
  EvaluateSafety
} derive(Debug, Eq, ToJson, FromJson)

///|
pub(all) struct BookPath {
  owner : PackOwner
  path : String
  purpose : String
} derive(Debug, Eq, ToJson, FromJson)

///|
pub(all) struct SchemaContract {
  id : String
  path : String
  owner : PackOwner
  purpose : String
} derive(Debug, Eq, ToJson, FromJson)

///|
pub(all) struct ToolContract {
  name : String
  capability : ToolCapability
  owner : PackOwner
  input_schema_id : String
  output_schema_id : String
  phases : Array[@routine.RoutinePhase]
} derive(Debug, Eq, ToJson, FromJson)

///|
pub(all) struct PackManifest {
  id : String
  display_name : String
  book_paths : Array[BookPath]
  schemas : Array[SchemaContract]
  tools : Array[ToolContract]
} derive(Debug, Eq, ToJson, FromJson)

///|
pub fn book_path(
  owner : PackOwner,
  path : String,
  purpose : String,
) -> BookPath {
  { owner, path, purpose }
}

///|
pub fn schema_contract(
  id : String,
  path : String,
  owner : PackOwner,
  purpose : String,
) -> SchemaContract {
  { id, path, owner, purpose }
}

///|
pub fn tool_contract(
  name : String,
  capability : ToolCapability,
  input_schema_id : String,
  output_schema_id : String,
  phases : Array[@routine.RoutinePhase],
  owner? : PackOwner = PriceAction,
) -> ToolContract {
  { name, capability, owner, input_schema_id, output_schema_id, phases }
}

///|
pub fn price_action_book_paths() -> Array[BookPath] {
  [
    book_path(MoonBook, "raw/market-data", "immutable fetched kline snapshots"),
    book_path(MoonBook, "raw/prompts", "assembled prompt packet evidence"),
    book_path(
      MoonBook,
      "raw/model-replies",
      "raw model request and reply evidence",
    ),
    book_path(MoonBook, "raw/run-events", "routine event stream evidence"),
    book_path(MoonBook, "wiki/concepts", "price-action vocabulary and concepts"),
    book_path(
      MoonBook,
      "wiki/strategy-notes",
      "operator-readable strategy notes",
    ),
    book_path(MoonBook, "skills/market-diagnosis", "Stage 1 diagnosis prompts"),
    book_path(MoonBook, "skills/strategy-routing", "pattern tag routing skills"),
    book_path(MoonBook, "skills/trade-decision", "Stage 2 decision prompts"),
    book_path(
      MoonBook,
      "records/skill-migrations",
      "source-to-MoonBook migration plans for PA prompt assets",
    ),
    book_path(MoonBook, "records/analyses", "normalized analysis records"),
    book_path(MoonBook, "records/projections", "full execution projections"),
    book_path(
      MoonBook,
      "records/structure-levels",
      "deterministic support, resistance, and midline records",
    ),
    book_path(
      MoonBook,
      "records/settings",
      "redacted provider and suite settings migration snapshots",
    ),
    book_path(
      MoonBook,
      "records/policies",
      "decision policy reports for advisory safety and PA hard bans",
    ),
    book_path(
      MoonBook,
      "records/context-budgets",
      "model context budget reports for MoonClaw prompt execution",
    ),
    book_path(
      MoonBook,
      "records/book-commits",
      "idempotent MoonBook commit reports for completed run artifacts",
    ),
    book_path(MoonBook, "records/reviews", "human review queue records"),
    book_path(
      MoonBook,
      "records/followups",
      "follow-up chat contexts and turns attached to analysis records",
    ),
    book_path(
      MoonBook,
      "records/jobs",
      "durable MoonClaw job state records for started, failed, cancelled, and completed runs",
    ),
    book_path(
      MoonBook,
      "records/orchestrations",
      "typed MoonClaw two-stage routine controller results",
    ),
    book_path(
      MoonBook,
      "records/parity",
      "golden fixture parity reports and known-difference records",
    ),
    book_path(
      MoonBook,
      "records/evaluations",
      "cutover readiness and parity evaluation reports",
    ),
    book_path(
      MoonBook,
      "records/cutovers",
      "cutover checklists, rollback plans, and decommission notes",
    ),
    book_path(
      MoonBook,
      "records/handoffs",
      "operator activation reports and handoff runbooks",
    ),
    book_path(
      MoonBook,
      "records/decommission",
      "PA Agent read-only decommission archives and final status reports",
    ),
    book_path(
      MoonBook,
      "records/product-status",
      "assembled Moonfish product status and release evidence",
    ),
    book_path(
      MoonBook,
      "records/rehearsals",
      "product launch rehearsal reports for daily operator cutover",
    ),
    book_path(
      MoonBook,
      "records/releases",
      "release certificates for standalone primary workflow cutover",
    ),
    book_path(
      MoonBook,
      "records/rollback-windows",
      "rollback-window reports for read-only PA Agent fallback periods",
    ),
    book_path(
      MoonBook,
      "records/operations",
      "day-2 operations readiness reports for standalone Moonfish workflows",
    ),
    book_path(
      Moondesk,
      "apps/moondesk-price-action/product-status",
      "product launch surface with cutover, handoff, and decommission evidence",
    ),
    book_path(
      MoonBook,
      "records/comparisons",
      "golden fixture and live snapshot comparison evidence for cutover",
    ),
    book_path(
      MoonBook,
      "records/imports",
      "idempotent import manifests for legacy PA Agent sources",
    ),
    book_path(
      MoonBook,
      "records/imported/analyses",
      "imported legacy PA Agent analysis records",
    ),
    book_path(
      MoonBook,
      "records/imported/pending",
      "imported legacy pending analysis records",
    ),
    book_path(
      MoonBook,
      "records/imported/trade-logs",
      "imported read-only legacy trade log entries",
    ),
    book_path(
      MoonBook,
      "wiki/imported-experience",
      "imported legacy experience memory entries",
    ),
    book_path(
      MoonBook,
      "records/memory-selections",
      "experience memory selected for Stage 2 prompt evidence",
    ),
    book_path(
      MoonBook,
      "records/replays",
      "replay plans and replay comparison records",
    ),
    book_path(
      MoonBook,
      "records/exports",
      "export manifests for audit and public summary bundles",
    ),
    book_path(
      MoonBook,
      "records/safety",
      "safety reports for replay, export, and suite-boundary checks",
    ),
    book_path(
      MoonBook,
      "records/redaction-audits",
      "secret and sensitive-evidence redaction audit reports",
    ),
    book_path(
      MoonBook,
      "records/cancellations",
      "operator cancellation reports proving partial-record boundaries",
    ),
    book_path(
      MoonBook,
      "records/provider-failures",
      "provider and network failure normalization reports",
    ),
    book_path(
      MoonBook,
      "records/integrity",
      "record integrity reports for MoonBook round-trip and replay anchors",
    ),
    book_path(
      MoonBook,
      "records/app-smoke",
      "Moondesk app-tool smoke reports over removable operator workflows",
    ),
    book_path(
      Moondesk,
      "apps/moondesk-price-action/chart-frames",
      "operator chart frame projections",
    ),
    book_path(
      Moondesk,
      "apps/moondesk-price-action/run-views",
      "operator run view projections for the app-tool surface",
    ),
    book_path(
      Moondesk,
      "apps/moondesk-price-action/run-history",
      "operator run history index projections",
    ),
  ]
}

///|
pub fn price_action_schemas() -> Array[SchemaContract] {
  [
    schema_contract(
      "analysis-workspace-input",
      "schemas/analysis-workspace-input.schema.json",
      MoonClaw,
      "operator intent and seeded domain outputs used to compose one workspace",
    ),
    schema_contract(
      "analysis-workspace",
      "schemas/analysis-workspace.schema.json",
      MoonClaw,
      "product-level run workspace composed from suite pack projections",
    ),
    schema_contract(
      "acceptance-fixture-set",
      "schemas/acceptance-fixture-set.schema.json",
      MoonBook,
      "canonical offline acceptance fixture set for product-level migration gates",
    ),
    schema_contract(
      "acceptance-report",
      "schemas/acceptance-report.schema.json",
      MoonBook,
      "fixture-driven acceptance report over workspace, retry, cancellation, app-tool, import, parity, and safety gates",
    ),
    schema_contract(
      "two-stage-routine-input",
      "schemas/two-stage-routine-input.schema.json",
      MoonClaw,
      "MoonClaw two-stage controller input with seeded stage outputs and retry policy",
    ),
    schema_contract(
      "two-stage-routine-result",
      "schemas/two-stage-routine-result.schema.json",
      MoonClaw,
      "MoonClaw two-stage controller outcome, validation gates, partial records, and events",
    ),
    schema_contract(
      "legacy-settings-ref",
      "schemas/legacy-settings-ref.schema.json",
      MoonGate,
      "legacy PA Agent settings fields submitted for suite migration planning",
    ),
    schema_contract(
      "suite-settings-plan",
      "schemas/suite-settings-plan.schema.json",
      MoonGate,
      "suite settings migration plan with redacted provider and retry mappings",
    ),
    schema_contract(
      "pack-manifest",
      "schemas/pack-manifest.schema.json",
      MoonBook,
      "suite pack manifest snapshot used by readiness evaluation",
    ),
    schema_contract(
      "product-status-input",
      "schemas/product-status-input.schema.json",
      MoonBook,
      "prepared workspace, settings, import, comparison, and manifest evidence for product assembly",
    ),
    schema_contract(
      "product-status",
      "schemas/product-status.schema.json",
      MoonBook,
      "assembled Moonfish workspace, migration, parity, cutover, handoff, and decommission status",
    ),
    schema_contract(
      "product-launch-manifest",
      "schemas/product-launch-manifest.schema.json",
      Moondesk,
      "Moondesk product launch surface over cutover, handoff, and decommission evidence",
    ),
    schema_contract(
      "product-rehearsal-finding",
      "schemas/product-rehearsal-finding.schema.json",
      MoonBook,
      "one product launch rehearsal finding",
    ),
    schema_contract(
      "product-rehearsal-report",
      "schemas/product-rehearsal-report.schema.json",
      MoonBook,
      "daily operator cutover rehearsal over launch, workflow, replay/export, comparison, legacy read-only, and archive evidence",
    ),
    schema_contract(
      "release-certificate-input",
      "schemas/release-certificate-input.schema.json",
      MoonBook,
      "product status and rehearsal evidence submitted for release certification",
    ),
    schema_contract(
      "release-finding",
      "schemas/release-finding.schema.json",
      MoonBook,
      "one release certificate finding",
    ),
    schema_contract(
      "release-certificate",
      "schemas/release-certificate.schema.json",
      MoonBook,
      "standalone primary workflow release certificate for Moonfish cutover",
    ),
    schema_contract(
      "rollback-window-input",
      "schemas/rollback-window-input.schema.json",
      MoonBook,
      "product status and release certificate evidence submitted for rollback-window reporting",
    ),
    schema_contract(
      "rollback-window-finding",
      "schemas/rollback-window-finding.schema.json",
      MoonBook,
      "one rollback-window report finding",
    ),
    schema_contract(
      "rollback-window-report",
      "schemas/rollback-window-report.schema.json",
      MoonBook,
      "read-only PA Agent rollback-window report with Moonfish primary, replay/export, escalation, and archive evidence",
    ),
    schema_contract(
      "operations-report-input",
      "schemas/operations-report-input.schema.json",
      MoonBook,
      "product status, release certificate, and rollback window evidence submitted for day-2 operations reporting",
    ),
    schema_contract(
      "operations-finding",
      "schemas/operations-finding.schema.json",
      MoonBook,
      "one day-2 operations readiness finding",
    ),
    schema_contract(
      "operations-readiness-report",
      "schemas/operations-readiness-report.schema.json",
      MoonBook,
      "day-2 operations report over suite health, primary workflow, rollback monitoring, replay/export, resilience, and observability",
    ),
    schema_contract(
      "cutover-evaluation-input",
      "schemas/cutover-evaluation-input.schema.json",
      MoonBook,
      "workspace, import plan, and manifest submitted for readiness evaluation",
    ),
    schema_contract(
      "cutover-readiness-report",
      "schemas/cutover-readiness-report.schema.json",
      MoonBook,
      "parity and cutover readiness report for operator migration",
    ),
    schema_contract(
      "parity-report-input",
      "schemas/parity-report-input.schema.json",
      MoonBook,
      "workspace, import plan, and source fixture root used for parity evaluation",
    ),
    schema_contract(
      "parity-report",
      "schemas/parity-report.schema.json",
      MoonBook,
      "golden fixture parity and known-difference report",
    ),
    schema_contract(
      "cutover-comparison-input",
      "schemas/cutover-comparison-input.schema.json",
      MoonBook,
      "parity report, completed workspace, and live snapshot rehearsal submitted for cutover comparison",
    ),
    schema_contract(
      "cutover-comparison-report",
      "schemas/cutover-comparison-report.schema.json",
      MoonBook,
      "golden fixture, live snapshot, and rollback-window comparison evidence",
    ),
    schema_contract(
      "cutover-plan-input",
      "schemas/cutover-plan-input.schema.json",
      MoonBook,
      "readiness report, import plan, and rollback window used for cutover planning",
    ),
    schema_contract(
      "cutover-plan",
      "schemas/cutover-plan.schema.json",
      MoonBook,
      "operator cutover checklist, rollback plan, and decommission note",
    ),
    schema_contract(
      "operator-handoff-input",
      "schemas/operator-handoff-input.schema.json",
      MoonBook,
      "acceptance, readiness, comparison, cutover, and app-tool evidence submitted for operator handoff",
    ),
    schema_contract(
      "operator-handoff-report",
      "schemas/operator-handoff-report.schema.json",
      MoonBook,
      "operator activation gates, launch path, and runbook for Moondesk cutover",
    ),
    schema_contract(
      "decommission-input",
      "schemas/decommission-input.schema.json",
      MoonBook,
      "cutover, handoff, import, parity, and comparison evidence submitted for legacy decommission",
    ),
    schema_contract(
      "decommission-report",
      "schemas/decommission-report.schema.json",
      MoonBook,
      "PA Agent read-only decommission gates, archive manifest, and final note",
    ),
    schema_contract(
      "analysis-plan-input",
      "schemas/analysis-plan-input.schema.json",
      MoonClaw,
      "operator intent, market target, and suite status used to prepare a run",
    ),
    schema_contract(
      "analysis-plan",
      "schemas/analysis-plan.schema.json",
      MoonClaw,
      "pre-execution run plan with market/model choices and readiness issues",
    ),
    schema_contract(
      "retry-policy",
      "schemas/retry-policy.schema.json",
      MoonClaw,
      "bounded validation/model retry settings for a MoonClaw job",
    ),
    schema_contract(
      "retry-decision-input",
      "schemas/retry-decision-input.schema.json",
      MoonClaw,
      "stage validation report, attempt count, and policy used for retry planning",
    ),
    schema_contract(
      "retry-decision",
      "schemas/retry-decision.schema.json",
      MoonClaw,
      "bounded retry decision with feedback targets and immutable-field guards",
    ),
    schema_contract(
      "analysis-job-input",
      "schemas/analysis-job-input.schema.json",
      MoonClaw,
      "analysis plan plus optional bundle, cancellation, failure, and retry inputs",
    ),
    schema_contract(
      "analysis-job-state",
      "schemas/analysis-job-state.schema.json",
      MoonClaw,
      "durable MoonClaw job outcome and partial-record state",
    ),
    schema_contract(
      "market-source-request",
      "schemas/market-source-request.schema.json",
      PriceAction,
      "data-source, symbol, and timeframe request",
    ),
    schema_contract(
      "market-source-plan",
      "schemas/market-source-plan.schema.json",
      PriceAction,
      "planned market adapter and raw evidence path",
    ),
    schema_contract(
      "market-refresh-input",
      "schemas/market-refresh-input.schema.json",
      PriceAction,
      "market request, forming-bar state, and operator refresh interval submitted for refresh planning",
    ),
    schema_contract(
      "market-refresh-plan",
      "schemas/market-refresh-plan.schema.json",
      PriceAction,
      "closed-bar refresh readiness, wait time, cache TTL, and adapter request safety",
    ),
    schema_contract(
      "market-fetch-result",
      "schemas/market-fetch-result.schema.json",
      PriceAction,
      "market fetch result with fixture snapshot or planned external adapter",
    ),
    schema_contract(
      "market-data-issue",
      "schemas/market-data-issue.schema.json",
      PriceAction,
      "one rejected market snapshot issue surfaced for operator review",
    ),
    schema_contract(
      "market-ingest-input",
      "schemas/market-ingest-input.schema.json",
      PriceAction,
      "external adapter or operator submitted closed-bar snapshot for a planned request",
    ),
    schema_contract(
      "analysis-run-request",
      "schemas/analysis-run-request.schema.json",
      MoonClaw,
      "product-level request for one Moonfish analysis run",
    ),
    schema_contract(
      "analysis-run-bundle",
      "schemas/analysis-run-bundle.schema.json",
      MoonClaw,
      "composed run bundle with market fetch, projection, chart, and write plan",
    ),
    schema_contract(
      "legacy-source-ref",
      "schemas/legacy-source-ref.schema.json",
      MoonBook,
      "source file reference for an idempotent legacy PA Agent import",
    ),
    schema_contract(
      "legacy-import-batch-input",
      "schemas/legacy-import-batch-input.schema.json",
      MoonBook,
      "batch of legacy PA Agent source refs to import into MoonBook",
    ),
    schema_contract(
      "legacy-import-plan",
      "schemas/legacy-import-plan.schema.json",
      MoonBook,
      "MoonBook import plan with target paths, dispositions, and write plan",
    ),
    schema_contract(
      "legacy-import-projection",
      "schemas/legacy-import-projection.schema.json",
      MoonBook,
      "inspectable imported MoonBook records with source traceability and replay anchors",
    ),
    schema_contract(
      "legacy-experience-entry",
      "schemas/legacy-experience-entry.schema.json",
      MoonBook,
      "read-only imported PA Agent experience entry",
    ),
    schema_contract(
      "legacy-trade-log",
      "schemas/legacy-trade-log.schema.json",
      MoonBook,
      "read-only imported PA Agent trade log entry",
    ),
    schema_contract(
      "review-item",
      "schemas/review-item.schema.json",
      MoonBook,
      "actionable operator review item derived from run evidence",
    ),
    schema_contract(
      "review-queue",
      "schemas/review-queue.schema.json",
      MoonBook,
      "MoonBook review queue for one analysis run",
    ),
    schema_contract(
      "followup-anchor",
      "schemas/followup-anchor.schema.json",
      MoonBook,
      "durable evidence anchor available to follow-up chat",
    ),
    schema_contract(
      "followup-context",
      "schemas/followup-context.schema.json",
      MoonClaw,
      "analysis-attached context for post-run follow-up chat",
    ),
    schema_contract(
      "followup-turn",
      "schemas/followup-turn.schema.json",
      MoonBook,
      "one follow-up chat turn attached to analysis evidence",
    ),
    schema_contract(
      "followup-session-plan",
      "schemas/followup-session-plan.schema.json",
      MoonClaw,
      "bounded MoonClaw follow-up session plan over durable MoonBook evidence",
    ),
    schema_contract(
      "followup-response-input",
      "schemas/followup-response-input.schema.json",
      MoonClaw,
      "operator follow-up question plus durable analysis context",
    ),
    schema_contract(
      "followup-response",
      "schemas/followup-response.schema.json",
      MoonBook,
      "cited follow-up response attached to analysis evidence",
    ),
    schema_contract(
      "replay-step",
      "schemas/replay-step.schema.json",
      MoonBook,
      "one deterministic replay step over persisted evidence",
    ),
    schema_contract(
      "replay-plan",
      "schemas/replay-plan.schema.json",
      MoonClaw,
      "MoonClaw replay plan for one analysis bundle",
    ),
    schema_contract(
      "export-item",
      "schemas/export-item.schema.json",
      MoonBook,
      "one artifact included in an export manifest",
    ),
    schema_contract(
      "export-manifest",
      "schemas/export-manifest.schema.json",
      MoonBook,
      "export profile and artifact manifest for one run",
    ),
    schema_contract(
      "safety-finding",
      "schemas/safety-finding.schema.json",
      MoonBook,
      "one explicit safety check result for a run",
    ),
    schema_contract(
      "safety-report",
      "schemas/safety-report.schema.json",
      MoonBook,
      "safety report covering broker path, replay, export, and ownership checks",
    ),
    schema_contract(
      "redaction-audit-finding",
      "schemas/redaction-audit-finding.schema.json",
      MoonBook,
      "one secret or sensitive-evidence redaction audit finding",
    ),
    schema_contract(
      "redaction-audit-report",
      "schemas/redaction-audit-report.schema.json",
      MoonBook,
      "cross-surface redaction audit over model gateway, Book commit evidence, app bindings, and public exports",
    ),
    schema_contract(
      "cancellation-finding",
      "schemas/cancellation-finding.schema.json",
      MoonBook,
      "one operator cancellation and partial-record boundary finding",
    ),
    schema_contract(
      "cancellation-report",
      "schemas/cancellation-report.schema.json",
      MoonBook,
      "routine cancellation proof over outcome, events, partial record paths, and stage boundary",
    ),
    schema_contract(
      "provider-failure-input",
      "schemas/provider-failure-input.schema.json",
      MoonClaw,
      "provider error plus routine result evidence for failure normalization",
    ),
    schema_contract(
      "provider-failure-finding",
      "schemas/provider-failure-finding.schema.json",
      MoonBook,
      "one provider failure normalization and durability finding",
    ),
    schema_contract(
      "provider-failure-report",
      "schemas/provider-failure-report.schema.json",
      MoonBook,
      "provider failure report over normalized errors, retry disposition, and partial records",
    ),
    schema_contract(
      "record-integrity-finding",
      "schemas/record-integrity-finding.schema.json",
      MoonBook,
      "one MoonBook record integrity finding",
    ),
    schema_contract(
      "record-integrity-report",
      "schemas/record-integrity-report.schema.json",
      MoonBook,
      "record integrity report over analysis record, write plan, commit, replay, and export anchors",
    ),
    schema_contract(
      "moondesk-app-smoke-finding",
      "schemas/moondesk-app-smoke-finding.schema.json",
      Moondesk,
      "one Moondesk app-tool smoke finding",
    ),
    schema_contract(
      "moondesk-app-smoke-input",
      "schemas/moondesk-app-smoke-input.schema.json",
      Moondesk,
      "completed and awaiting workspace pair used for app-tool smoke proof",
    ),
    schema_contract(
      "moondesk-app-smoke-report",
      "schemas/moondesk-app-smoke-report.schema.json",
      Moondesk,
      "smoke report proving removable completed, external ingest, redacted debug, and MoonBook-backed operator paths",
    ),
    schema_contract(
      "kline-snapshot",
      "schemas/kline-snapshot.schema.json",
      PriceAction,
      "closed-bar market snapshot evidence",
    ),
    schema_contract(
      "market-feature-frame",
      "schemas/market-feature-frame.schema.json",
      PriceAction,
      "deterministic indicator and structure features",
    ),
    schema_contract(
      "structure-level-frame",
      "schemas/structure-level-frame.schema.json",
      PriceAction,
      "deterministic support, resistance, and midline levels for chart inspection",
    ),
    schema_contract(
      "stage1-feature-hints",
      "schemas/stage1-feature-hints.schema.json",
      PriceAction,
      "bounded deterministic hints supplied to Stage 1",
    ),
    schema_contract(
      "stage1-diagnosis",
      "schemas/stage1-diagnosis.schema.json",
      PriceAction,
      "market diagnosis produced by Stage 1",
    ),
    schema_contract(
      "stage2-decision",
      "schemas/stage2-decision.schema.json",
      PriceAction,
      "trade decision produced by Stage 2",
    ),
    schema_contract(
      "stage-output",
      "schemas/stage-output.schema.json",
      PriceAction,
      "raw model stage output envelope",
    ),
    schema_contract(
      "prompt-section",
      "schemas/prompt-section.schema.json",
      PriceAction,
      "named prompt packet section",
    ),
    schema_contract(
      "prompt-assembly-input",
      "schemas/prompt-assembly-input.schema.json",
      PriceAction,
      "bounded evidence used to assemble a model prompt",
    ),
    schema_contract(
      "prompt-packet",
      "schemas/prompt-packet.schema.json",
      PriceAction,
      "deterministic model prompt envelope",
    ),
    schema_contract(
      "skill-asset",
      "schemas/skill-asset.schema.json",
      MoonBook,
      "inspectable prompt skill or strategy-note asset",
    ),
    schema_contract(
      "skill-catalog",
      "schemas/skill-catalog.schema.json",
      MoonBook,
      "suite-owned catalog of prompt skills and strategy notes",
    ),
    schema_contract(
      "skill-migration-input",
      "schemas/skill-migration-input.schema.json",
      MoonBook,
      "source root used to map PA prompt files into MoonBook skills and wiki notes",
    ),
    schema_contract(
      "skill-source-ref",
      "schemas/skill-source-ref.schema.json",
      MoonBook,
      "one PA prompt source mapped to a MoonBook skill or wiki target",
    ),
    schema_contract(
      "skill-migration-plan",
      "schemas/skill-migration-plan.schema.json",
      MoonBook,
      "inspectable migration plan for PA prompt files, strategy notes, and reference docs",
    ),
    schema_contract(
      "experience-memory-entry",
      "schemas/experience-memory-entry.schema.json",
      MoonBook,
      "one imported or curated experience memory entry available to Stage 2",
    ),
    schema_contract(
      "experience-memory-selection",
      "schemas/experience-memory-selection.schema.json",
      MoonBook,
      "deterministic Stage 2 experience memory selection with source paths",
    ),
    schema_contract(
      "suite-status-ref",
      "schemas/suite-status-ref.schema.json",
      MoonGate,
      "MoonGate suite status projection used by Moonfish",
    ),
    schema_contract(
      "model-gateway",
      "schemas/model-gateway.schema.json",
      MoonGate,
      "model gateway and catalog selected for a routine",
    ),
    schema_contract(
      "provider-error",
      "schemas/provider-error.schema.json",
      MoonGate,
      "normalized provider error with retry disposition",
    ),
    schema_contract(
      "context-budget-input",
      "schemas/context-budget-input.schema.json",
      MoonClaw,
      "prompt packet, model gateway, and reserved completion budget submitted before a model call",
    ),
    schema_contract(
      "context-budget-plan",
      "schemas/context-budget-plan.schema.json",
      MoonClaw,
      "estimated prompt footprint, selected context window, and pruning status for one model stage",
    ),
    schema_contract(
      "context-budget-report",
      "schemas/context-budget-report.schema.json",
      MoonClaw,
      "Stage 1 and Stage 2 context budget report persisted with routine evidence",
    ),
    schema_contract(
      "model-call-request",
      "schemas/model-call-request.schema.json",
      MoonClaw,
      "model request produced from a prompt packet",
    ),
    schema_contract(
      "model-call-response",
      "schemas/model-call-response.schema.json",
      MoonClaw,
      "model response captured as stage output",
    ),
    schema_contract(
      "routine-request",
      "schemas/routine-request.schema.json",
      PriceAction,
      "operator request and market snapshot submitted to the routine",
    ),
    schema_contract(
      "routine-plan",
      "schemas/routine-plan.schema.json",
      MoonClaw,
      "ordered MoonClaw routine phases for an analysis run",
    ),
    schema_contract(
      "routine-event",
      "schemas/routine-event.schema.json",
      PriceAction,
      "durable event emitted by a routine phase",
    ),
    schema_contract(
      "routine-event-log",
      "schemas/routine-event-log.schema.json",
      MoonClaw,
      "ordered event stream emitted by a routine run",
    ),
    schema_contract(
      "routine-response",
      "schemas/routine-response.schema.json",
      PriceAction,
      "routine request, plan, events, and final analysis record",
    ),
    schema_contract(
      "dry-execution-projection",
      "schemas/dry-execution-projection.schema.json",
      PriceAction,
      "offline projection joining features, prompts, model calls, events, and record",
    ),
    schema_contract(
      "book-artifact-ref",
      "schemas/book-artifact-ref.schema.json",
      MoonBook,
      "durable MoonBook artifact reference",
    ),
    schema_contract(
      "book-write-plan",
      "schemas/book-write-plan.schema.json",
      MoonBook,
      "MoonBook persistence plan for a routine projection",
    ),
    schema_contract(
      "book-artifact-commit",
      "schemas/book-artifact-commit.schema.json",
      MoonBook,
      "one artifact entry classified for idempotent MoonBook commit",
    ),
    schema_contract(
      "book-commit-report",
      "schemas/book-commit-report.schema.json",
      MoonBook,
      "idempotent commit report over all artifacts in a run write plan",
    ),
    schema_contract(
      "analysis-record",
      "schemas/analysis-record.schema.json",
      PriceAction,
      "durable MoonBook analysis record",
    ),
    schema_contract(
      "validation-report",
      "schemas/validation-report.schema.json",
      PriceAction,
      "schema and semantic validation result",
    ),
    schema_contract(
      "decision-policy-input",
      "schemas/decision-policy-input.schema.json",
      PriceAction,
      "Stage 1 diagnosis and Stage 2 decision submitted for advisory policy evaluation",
    ),
    schema_contract(
      "decision-policy-report",
      "schemas/decision-policy-report.schema.json",
      PriceAction,
      "advisory decision policy report for no-market-order, reversal-risk, confidence, and risk-note hard bans",
    ),
    schema_contract(
      "strategy-file-list",
      "schemas/strategy-file-list.schema.json",
      PriceAction,
      "ordered strategy file selection",
    ),
    schema_contract(
      "chart-frame",
      "schemas/chart-frame.schema.json",
      PriceAction,
      "operator-facing rendered chart artifact",
    ),
    schema_contract(
      "operator-run-view",
      "schemas/operator-run-view.schema.json",
      Moondesk,
      "Moondesk app-tool view for one analysis run",
    ),
    schema_contract(
      "moondesk-app-tool-manifest",
      "schemas/moondesk-app-tool-manifest.schema.json",
      Moondesk,
      "removable Moondesk price-action app-tool manifest with controls, bindings, and surfaces",
    ),
    schema_contract(
      "run-history-input",
      "schemas/run-history-input.schema.json",
      Moondesk,
      "input bundle list for rendering operator run history",
    ),
    schema_contract(
      "run-history-entry",
      "schemas/run-history-entry.schema.json",
      Moondesk,
      "one row in the operator run history index",
    ),
    schema_contract(
      "run-history-index",
      "schemas/run-history-index.schema.json",
      Moondesk,
      "operator run history index for Moondesk",
    ),
  ]
}

///|
pub fn price_action_tools() -> Array[ToolContract] {
  [
    tool_contract(
      "prepare_analysis_workspace",
      ComposeWorkspace,
      "analysis-workspace-input",
      "analysis-workspace",
      [CreateRunContext, FollowUpReady],
      owner=MoonClaw,
    ),
    tool_contract(
      "prepare_moonfish_product_status",
      ComposeProductStatus,
      "product-status-input",
      "product-status",
      [CreateRunContext, FollowUpReady],
      owner=MoonBook,
    ),
    tool_contract(
      "prepare_product_launch_manifest",
      RenderOperatorView,
      "product-status",
      "product-launch-manifest",
      [FollowUpReady],
      owner=Moondesk,
    ),
    tool_contract(
      "prepare_product_rehearsal_report",
      EvaluateAcceptance,
      "product-status",
      "product-rehearsal-report",
      [FollowUpReady],
      owner=MoonBook,
    ),
    tool_contract(
      "prepare_release_certificate",
      EvaluateReadiness,
      "release-certificate-input",
      "release-certificate",
      [FollowUpReady],
      owner=MoonBook,
    ),
    tool_contract(
      "prepare_rollback_window_report",
      PrepareCutover,
      "rollback-window-input",
      "rollback-window-report",
      [FollowUpReady],
      owner=MoonBook,
    ),
    tool_contract(
      "prepare_operations_readiness_report",
      EvaluateReadiness,
      "operations-report-input",
      "operations-readiness-report",
      [FollowUpReady],
      owner=MoonBook,
    ),
    tool_contract(
      "prepare_suite_settings_plan",
      PrepareSettings,
      "legacy-settings-ref",
      "suite-settings-plan",
      [CreateRunContext],
      owner=MoonGate,
    ),
    tool_contract(
      "prepare_acceptance_report",
      EvaluateAcceptance,
      "acceptance-fixture-set",
      "acceptance-report",
      [CreateRunContext, Stage1Validation, PersistAnalysis, FollowUpReady],
      owner=MoonBook,
    ),
    tool_contract(
      "run_two_stage_routine",
      ExecuteRoutine,
      "two-stage-routine-input",
      "two-stage-routine-result",
      [
        CreateRunContext,
        SnapshotMarketData,
        Stage1Diagnosis,
        Stage1Validation,
        StrategyRouting,
        Stage2Decision,
        Stage2Validation,
        PersistAnalysis,
        FollowUpReady,
      ],
      owner=MoonClaw,
    ),
    tool_contract(
      "prepare_parity_report",
      EvaluateParity,
      "parity-report-input",
      "parity-report",
      [FollowUpReady],
      owner=MoonBook,
    ),
    tool_contract(
      "prepare_cutover_comparison_report",
      EvaluateCutoverComparison,
      "cutover-comparison-input",
      "cutover-comparison-report",
      [FollowUpReady],
      owner=MoonBook,
    ),
    tool_contract(
      "prepare_cutover_readiness_report",
      EvaluateReadiness,
      "cutover-evaluation-input",
      "cutover-readiness-report",
      [FollowUpReady],
      owner=MoonBook,
    ),
    tool_contract(
      "prepare_cutover_plan",
      PrepareCutover,
      "cutover-plan-input",
      "cutover-plan",
      [FollowUpReady],
      owner=MoonBook,
    ),
    tool_contract(
      "prepare_operator_handoff_report",
      PrepareOperatorHandoff,
      "operator-handoff-input",
      "operator-handoff-report",
      [FollowUpReady],
      owner=MoonBook,
    ),
    tool_contract(
      "prepare_decommission_report",
      PrepareDecommission,
      "decommission-input",
      "decommission-report",
      [FollowUpReady],
      owner=MoonBook,
    ),
    tool_contract(
      "prepare_analysis_plan",
      PlanRoutine,
      "analysis-plan-input",
      "analysis-plan",
      [CreateRunContext],
      owner=MoonClaw,
    ),
    tool_contract(
      "prepare_analysis_job",
      ManageJob,
      "analysis-job-input",
      "analysis-job-state",
      [CreateRunContext, SnapshotMarketData, PersistAnalysis, FollowUpReady],
      owner=MoonClaw,
    ),
    tool_contract(
      "prepare_retry_decision",
      PlanRetry,
      "retry-decision-input",
      "retry-decision",
      [Stage1Validation, Stage2Validation],
      owner=MoonClaw,
    ),
    tool_contract(
      "prepare_legacy_import_plan",
      PersistEvidence,
      "legacy-import-batch-input",
      "legacy-import-plan",
      [PersistAnalysis, FollowUpReady],
      owner=MoonBook,
    ),
    tool_contract(
      "materialize_legacy_import_projection",
      PersistEvidence,
      "legacy-import-plan",
      "legacy-import-projection",
      [PersistAnalysis, FollowUpReady],
      owner=MoonBook,
    ),
    tool_contract(
      "fetch_kline_snapshot",
      ReadMarketData,
      "market-source-request",
      "market-fetch-result",
      [SnapshotMarketData],
    ),
    tool_contract(
      "prepare_market_refresh_plan",
      ReadMarketData,
      "market-refresh-input",
      "market-refresh-plan",
      [CreateRunContext, SnapshotMarketData],
    ),
    tool_contract(
      "ingest_market_snapshot",
      ReadMarketData,
      "market-ingest-input",
      "market-fetch-result",
      [SnapshotMarketData],
    ),
    tool_contract(
      "compute_indicators",
      ComputeFeatures,
      "kline-snapshot",
      "market-feature-frame",
      [SnapshotMarketData],
    ),
    tool_contract(
      "compute_structure_levels",
      ComputeFeatures,
      "kline-snapshot",
      "structure-level-frame",
      [SnapshotMarketData, Stage1Diagnosis, FollowUpReady],
    ),
    tool_contract(
      "classify_market_structure",
      ComputeFeatures,
      "market-feature-frame",
      "stage1-feature-hints",
      [SnapshotMarketData, Stage1Diagnosis],
    ),
    tool_contract(
      "route_strategy_files",
      RouteStrategy,
      "stage1-diagnosis",
      "strategy-file-list",
      [StrategyRouting],
    ),
    tool_contract(
      "select_experience_memories",
      AssemblePrompt,
      "stage1-diagnosis",
      "experience-memory-selection",
      [Stage2Decision],
      owner=MoonBook,
    ),
    tool_contract(
      "prepare_skill_migration_plan",
      AssemblePrompt,
      "skill-migration-input",
      "skill-migration-plan",
      [CreateRunContext, Stage1Diagnosis, StrategyRouting, Stage2Decision],
      owner=MoonBook,
    ),
    tool_contract(
      "validate_stage_json",
      ValidateContract,
      "stage-output",
      "validation-report",
      [Stage1Validation, Stage2Validation],
    ),
    tool_contract(
      "evaluate_decision_policy",
      ValidateContract,
      "decision-policy-input",
      "decision-policy-report",
      [Stage2Validation],
    ),
    tool_contract(
      "assemble_stage_prompt",
      AssemblePrompt,
      "prompt-assembly-input",
      "prompt-packet",
      [Stage1Diagnosis, Stage2Decision],
    ),
    tool_contract(
      "route_model_call",
      RouteModelCall,
      "prompt-packet",
      "model-call-request",
      [Stage1Diagnosis, Stage2Decision],
      owner=MoonClaw,
    ),
    tool_contract(
      "prepare_context_budget_plan",
      PlanContext,
      "context-budget-input",
      "context-budget-plan",
      [Stage1Diagnosis, Stage2Decision],
      owner=MoonClaw,
    ),
    tool_contract(
      "write_analysis_record",
      PersistEvidence,
      "dry-execution-projection",
      "book-write-plan",
      [PersistAnalysis],
      owner=MoonBook,
    ),
    tool_contract(
      "prepare_book_commit_report",
      PersistEvidence,
      "book-write-plan",
      "book-commit-report",
      [PersistAnalysis, FollowUpReady],
      owner=MoonBook,
    ),
    tool_contract(
      "render_chart_frame",
      RenderOperatorView,
      "kline-snapshot",
      "chart-frame",
      [FollowUpReady],
      owner=Moondesk,
    ),
    tool_contract(
      "queue_analysis_review",
      PersistEvidence,
      "analysis-run-bundle",
      "review-queue",
      [PersistAnalysis, FollowUpReady],
      owner=MoonBook,
    ),
    tool_contract(
      "prepare_followup_context",
      PrepareFollowUp,
      "analysis-run-bundle",
      "followup-context",
      [FollowUpReady],
      owner=MoonClaw,
    ),
    tool_contract(
      "prepare_followup_session_plan",
      PrepareFollowUp,
      "followup-context",
      "followup-session-plan",
      [FollowUpReady],
      owner=MoonClaw,
    ),
    tool_contract(
      "prepare_followup_response",
      PrepareFollowUp,
      "followup-response-input",
      "followup-response",
      [FollowUpReady],
      owner=MoonClaw,
    ),
    tool_contract(
      "prepare_replay_plan",
      PrepareReplay,
      "analysis-run-bundle",
      "replay-plan",
      [FollowUpReady],
      owner=MoonClaw,
    ),
    tool_contract(
      "prepare_export_manifest",
      PrepareExport,
      "analysis-run-bundle",
      "export-manifest",
      [FollowUpReady],
      owner=MoonBook,
    ),
    tool_contract(
      "prepare_safety_report",
      EvaluateSafety,
      "analysis-run-bundle",
      "safety-report",
      [FollowUpReady],
      owner=MoonBook,
    ),
    tool_contract(
      "prepare_redaction_audit",
      EvaluateSafety,
      "analysis-run-bundle",
      "redaction-audit-report",
      [PersistAnalysis, FollowUpReady],
      owner=MoonBook,
    ),
    tool_contract(
      "prepare_cancellation_report",
      ManageJob,
      "two-stage-routine-result",
      "cancellation-report",
      [Stage1Validation, Stage2Validation, PersistAnalysis],
      owner=MoonClaw,
    ),
    tool_contract(
      "prepare_provider_failure_report",
      RouteModelCall,
      "provider-failure-input",
      "provider-failure-report",
      [Stage1Diagnosis, Stage2Decision, PersistAnalysis],
      owner=MoonClaw,
    ),
    tool_contract(
      "prepare_record_integrity_report",
      PersistEvidence,
      "analysis-run-bundle",
      "record-integrity-report",
      [PersistAnalysis, FollowUpReady],
      owner=MoonBook,
    ),
    tool_contract(
      "prepare_moondesk_app_smoke_report",
      EvaluateAcceptance,
      "moondesk-app-smoke-input",
      "moondesk-app-smoke-report",
      [CreateRunContext, FollowUpReady],
      owner=Moondesk,
    ),
    tool_contract(
      "render_operator_run_view",
      RenderOperatorView,
      "analysis-run-bundle",
      "operator-run-view",
      [FollowUpReady],
      owner=Moondesk,
    ),
    tool_contract(
      "render_moondesk_app_tool_manifest",
      RenderOperatorView,
      "operator-run-view",
      "moondesk-app-tool-manifest",
      [CreateRunContext, FollowUpReady],
      owner=Moondesk,
    ),
    tool_contract(
      "render_run_history",
      RenderOperatorView,
      "run-history-input",
      "run-history-index",
      [FollowUpReady],
      owner=Moondesk,
    ),
  ]
}

///|
pub fn price_action_manifest() -> PackManifest {
  {
    id: "price-action",
    display_name: "Moonfish Price Action",
    book_paths: price_action_book_paths(),
    schemas: price_action_schemas(),
    tools: price_action_tools(),
  }
}

///|
pub fn schema_declared(manifest : PackManifest, id : String) -> Bool {
  manifest.schemas.any(fn(schema) { schema.id == id })
}

///|
fn push_unique(items : Array[String], item : String) -> Unit {
  if !items.contains(item) {
    items.push(item)
  }
}

///|
pub fn missing_tool_schema_refs(manifest : PackManifest) -> Array[String] {
  let missing : Array[String] = []
  for tool in manifest.tools {
    if !schema_declared(manifest, tool.input_schema_id) {
      push_unique(missing, tool.input_schema_id)
    }
    if !schema_declared(manifest, tool.output_schema_id) {
      push_unique(missing, tool.output_schema_id)
    }
  }
  missing
}