@cleocode/adapters 2026.5.111 → 2026.5.113

package/dist/index.js

@@ -830,6 +830,63 @@ var init_cli_category = __esm({
   }
 });
 
+// packages/contracts/src/config/manifest.ts
+import { z as z4 } from "zod";
+var PROJECT_INFO_MANIFEST, PROJECT_CONTEXT_MANIFEST, CLEO_CONFIG_MANIFEST, GLOBAL_CLEO_CONFIG_MANIFEST, CONFIG_MANIFEST_ENTRIES, configManifestEntrySchema;
+var init_manifest = __esm({
+  "packages/contracts/src/config/manifest.ts"() {
+    "use strict";
+    PROJECT_INFO_MANIFEST = {
+      id: "project-info",
+      scope: "metadata",
+      path: ".cleo/project-info.json",
+      mergePrecedence: 0,
+      driftDetection: "schema-validate"
+    };
+    PROJECT_CONTEXT_MANIFEST = {
+      id: "project-context",
+      scope: "metadata",
+      path: ".cleo/project-context.json",
+      mergePrecedence: 0,
+      driftDetection: "staleness-gate"
+    };
+    CLEO_CONFIG_MANIFEST = {
+      id: "cleo-config-project",
+      scope: "project",
+      path: ".cleo/config.json",
+      mergePrecedence: 20,
+      driftDetection: "schema-validate"
+    };
+    GLOBAL_CLEO_CONFIG_MANIFEST = {
+      id: "cleo-config-global",
+      scope: "global",
+      path: "~/.cleo/config.json",
+      mergePrecedence: 10,
+      driftDetection: "schema-validate"
+    };
+    CONFIG_MANIFEST_ENTRIES = Object.freeze([
+      PROJECT_INFO_MANIFEST,
+      PROJECT_CONTEXT_MANIFEST,
+      GLOBAL_CLEO_CONFIG_MANIFEST,
+      CLEO_CONFIG_MANIFEST
+    ]);
+    configManifestEntrySchema = z4.object({
+      id: z4.string().min(1),
+      scope: z4.union([z4.literal("global"), z4.literal("project"), z4.literal("metadata")]),
+      path: z4.string().min(1),
+      schema: z4.unknown().optional(),
+      mergePrecedence: z4.number().int().nonnegative(),
+      driftDetection: z4.union([
+        z4.literal("schema-validate"),
+        z4.literal("staleness-gate"),
+        z4.literal("value-diff"),
+        z4.literal("none")
+      ]),
+      defaults: z4.record(z4.string(), z4.unknown()).optional()
+    });
+  }
+});
+
 // packages/contracts/src/credentials.ts
 function parseClaudeCodeCredentials(buf) {
   try {
@@ -1058,6 +1115,100 @@ var init_operations_registry = __esm({
   }
 });
 
+// packages/contracts/src/docs/provenance.ts
+import { z as z5 } from "zod";
+var PROVENANCE_NODE_KINDS, PROVENANCE_EDGE_RELATIONS, DOC_LIFECYCLE_STATUSES, provenanceNodeKindSchema, provenanceEdgeRelationSchema, docLifecycleStatusSchema, provenanceNodeBaseFields, provenanceDocNodeSchema, provenanceTaskNodeSchema, provenanceDecisionNodeSchema, provenanceSessionNodeSchema, provenanceMemoryNodeSchema, provenanceNodeSchema, provenanceEdgeSchema, docProvenanceResponseSchema;
+var init_provenance = __esm({
+  "packages/contracts/src/docs/provenance.ts"() {
+    "use strict";
+    PROVENANCE_NODE_KINDS = [
+      "doc",
+      "task",
+      "decision",
+      "session",
+      "memory"
+    ];
+    PROVENANCE_EDGE_RELATIONS = [
+      "attached-to",
+      "supersedes",
+      "superseded-by",
+      "related-task",
+      "linked-decision",
+      "derived-from"
+    ];
+    DOC_LIFECYCLE_STATUSES = [
+      "active",
+      "superseded",
+      "archived",
+      "draft"
+    ];
+    provenanceNodeKindSchema = z5.enum(PROVENANCE_NODE_KINDS);
+    provenanceEdgeRelationSchema = z5.enum(PROVENANCE_EDGE_RELATIONS);
+    docLifecycleStatusSchema = z5.enum(DOC_LIFECYCLE_STATUSES);
+    provenanceNodeBaseFields = {
+      id: z5.string().min(1),
+      title: z5.string().min(1),
+      metadata: z5.record(z5.string(), z5.unknown()).optional()
+    };
+    provenanceDocNodeSchema = z5.object({
+      ...provenanceNodeBaseFields,
+      kind: z5.literal("doc"),
+      slug: z5.string().min(1),
+      docKind: z5.string().min(1),
+      lifecycleStatus: docLifecycleStatusSchema,
+      publishedAt: z5.string().min(1),
+      supersededAt: z5.string().min(1).optional(),
+      summary: z5.string().optional()
+    });
+    provenanceTaskNodeSchema = z5.object({
+      ...provenanceNodeBaseFields,
+      kind: z5.literal("task"),
+      taskType: z5.enum(["saga", "epic", "task", "subtask"]),
+      status: z5.enum(["pending", "in_progress", "done", "blocked", "cancelled", "archived"])
+    });
+    provenanceDecisionNodeSchema = z5.object({
+      ...provenanceNodeBaseFields,
+      kind: z5.literal("decision"),
+      outcome: z5.enum(["proposed", "accepted", "rejected", "superseded"]),
+      decidedAt: z5.string().min(1)
+    });
+    provenanceSessionNodeSchema = z5.object({
+      ...provenanceNodeBaseFields,
+      kind: z5.literal("session"),
+      startedAt: z5.string().min(1),
+      endedAt: z5.string().min(1).optional()
+    });
+    provenanceMemoryNodeSchema = z5.object({
+      ...provenanceNodeBaseFields,
+      kind: z5.literal("memory"),
+      memoryType: z5.enum(["observation", "pattern", "decision", "diary"]),
+      recordedAt: z5.string().min(1)
+    });
+    provenanceNodeSchema = z5.discriminatedUnion("kind", [
+      provenanceDocNodeSchema,
+      provenanceTaskNodeSchema,
+      provenanceDecisionNodeSchema,
+      provenanceSessionNodeSchema,
+      provenanceMemoryNodeSchema
+    ]);
+    provenanceEdgeSchema = z5.object({
+      relation: provenanceEdgeRelationSchema,
+      from: z5.string().min(1),
+      fromKind: provenanceNodeKindSchema,
+      to: z5.string().min(1),
+      toKind: provenanceNodeKindSchema,
+      addedAt: z5.string().min(1),
+      summary: z5.string().optional()
+    });
+    docProvenanceResponseSchema = z5.object({
+      nodes: z5.array(provenanceNodeSchema).readonly(),
+      edges: z5.array(provenanceEdgeSchema).readonly(),
+      totalNodes: z5.number().int().nonnegative(),
+      totalEdges: z5.number().int().nonnegative()
+    });
+  }
+});
+
 // packages/contracts/src/docs-taxonomy.ts
 var BUILTIN_DOC_KINDS, BUILTIN_DOC_KIND_VALUES;
 var init_docs_taxonomy = __esm({
@@ -1071,7 +1222,8 @@ var init_docs_taxonomy = __esm({
         defaultOwnerKind: "task",
         publishDir: "docs/adr",
         requiresEntityId: true,
-        entityIdPattern: /^adr-\d{3,4}-[a-z0-9-]+$/
+        entityIdPattern: /^adr-\d{3,4}-[a-z0-9-]+$/,
+        requiredSections: ["Status", "Date", "Context", "Decision", "Consequences"]
       },
       {
         kind: "spec",
@@ -1079,7 +1231,8 @@ var init_docs_taxonomy = __esm({
         description: "Technical specification",
         defaultOwnerKind: "task",
         publishDir: "docs/spec",
-        requiresEntityId: false
+        requiresEntityId: false,
+        requiredSections: ["Goal", "Non-Goals", "Requirements", "Out-of-Scope"]
       },
       {
         kind: "research",
@@ -1087,7 +1240,8 @@ var init_docs_taxonomy = __esm({
         description: "Investigation / research note",
         defaultOwnerKind: "task",
         publishDir: "docs/research",
-        requiresEntityId: false
+        requiresEntityId: false,
+        requiredSections: ["Question", "Findings", "Sources"]
       },
       {
         kind: "handoff",
@@ -1095,7 +1249,8 @@ var init_docs_taxonomy = __esm({
         description: "Session / agent handoff",
         defaultOwnerKind: "session",
         publishDir: "docs/handoff",
-        requiresEntityId: false
+        requiresEntityId: false,
+        requiredSections: ["Context", "State", "Next-Steps"]
       },
       {
         kind: "note",
@@ -1103,7 +1258,8 @@ var init_docs_taxonomy = __esm({
         description: "Agent observation / informal note",
         defaultOwnerKind: "observation",
         publishDir: "docs/note",
-        requiresEntityId: false
+        requiresEntityId: false,
+        requiredSections: []
       },
       {
         kind: "llm-readme",
@@ -1111,7 +1267,8 @@ var init_docs_taxonomy = __esm({
         description: "Machine-readable README (llms.txt)",
         defaultOwnerKind: "project",
         publishDir: ".",
-        requiresEntityId: false
+        requiresEntityId: false,
+        requiredSections: []
       },
       {
         kind: "changeset",
@@ -1120,7 +1277,8 @@ var init_docs_taxonomy = __esm({
         defaultOwnerKind: "task",
         publishDir: ".changeset",
         requiresEntityId: true,
-        entityIdPattern: /^t\d+-[a-z0-9-]+$/
+        entityIdPattern: /^t\d+-[a-z0-9-]+$/,
+        requiredSections: []
       },
       {
         kind: "release-note",
@@ -1129,7 +1287,8 @@ var init_docs_taxonomy = __esm({
         defaultOwnerKind: "project",
         publishDir: "docs/release",
         requiresEntityId: true,
-        entityIdPattern: /^v\d{4}\.\d+\.\d+(-[a-z0-9-]+)?$/
+        entityIdPattern: /^v\d{4}\.\d+\.\d+(-[a-z0-9-]+)?$/,
+        requiredSections: ["Changes", "Migration"]
       },
       {
         kind: "plan",
@@ -1137,7 +1296,8 @@ var init_docs_taxonomy = __esm({
         description: "Epic / saga decomposition plan",
         defaultOwnerKind: "task",
         publishDir: "docs/plan",
-        requiresEntityId: false
+        requiresEntityId: false,
+        requiredSections: ["Goal", "Steps", "Owners"]
       },
       {
         kind: "rcasd",
@@ -1146,7 +1306,8 @@ var init_docs_taxonomy = __esm({
         defaultOwnerKind: "task",
         publishDir: ".cleo/rcasd",
         requiresEntityId: true,
-        entityIdPattern: /^t\d+(-.+)?$/
+        entityIdPattern: /^t\d+(-.+)?$/,
+        requiredSections: ["Root-Cause", "Action", "Schedule", "Detection"]
       }
     ];
     BUILTIN_DOC_KIND_VALUES = Object.freeze(
@@ -1196,59 +1357,139 @@ var init_errors = __esm({
   }
 });
 
+// packages/contracts/src/evidence-atom-schema.ts
+import { z as z6 } from "zod";
+var commitAtomSchema, filesAtomSchema, testRunAtomSchema, toolAtomSchema, urlAtomSchema, noteAtomSchema, decisionAtomSchema, prAtomSchema, locDropAtomSchema, callsiteCoverageAtomSchema, EvidenceAtomSchema, GATE_EVIDENCE_REQUIREMENTS;
+var init_evidence_atom_schema = __esm({
+  "packages/contracts/src/evidence-atom-schema.ts"() {
+    "use strict";
+    commitAtomSchema = z6.object({
+      kind: z6.literal("commit"),
+      sha: z6.string().regex(/^[0-9a-f]{7,40}$/i, "commit sha must be 7-40 hex characters")
+    });
+    filesAtomSchema = z6.object({
+      kind: z6.literal("files"),
+      paths: z6.array(z6.string().min(1)).min(1, "files atom requires at least one path")
+    });
+    testRunAtomSchema = z6.object({
+      kind: z6.literal("test-run"),
+      path: z6.string().min(1, "test-run atom requires a non-empty path")
+    });
+    toolAtomSchema = z6.object({
+      kind: z6.literal("tool"),
+      tool: z6.string().min(1, "tool atom requires a non-empty tool name")
+    });
+    urlAtomSchema = z6.object({
+      kind: z6.literal("url"),
+      url: z6.string().min(1).regex(/^https?:\/\//, "url atom must start with http:// or https://")
+    });
+    noteAtomSchema = z6.object({
+      kind: z6.literal("note"),
+      note: z6.string().min(1, "note atom must be non-empty").max(512, "note atom is too long (max 512 chars)")
+    });
+    decisionAtomSchema = z6.object({
+      kind: z6.literal("decision"),
+      decisionId: z6.string().min(1, "decision atom requires a non-empty decision ID")
+    });
+    prAtomSchema = z6.object({
+      kind: z6.literal("pr"),
+      prNumber: z6.number().int().positive("pr atom requires a positive integer PR number")
+    });
+    locDropAtomSchema = z6.object({
+      kind: z6.literal("loc-drop"),
+      fromLines: z6.number().int().nonnegative("loc-drop fromLines must be \u2265 0"),
+      toLines: z6.number().int().nonnegative("loc-drop toLines must be \u2265 0")
+    });
+    callsiteCoverageAtomSchema = z6.object({
+      kind: z6.literal("callsite-coverage"),
+      symbolName: z6.string().min(1, "callsite-coverage atom requires a non-empty symbolName"),
+      relativeSourcePath: z6.string().min(1, "callsite-coverage atom requires a non-empty relativeSourcePath")
+    });
+    EvidenceAtomSchema = z6.discriminatedUnion("kind", [
+      commitAtomSchema,
+      filesAtomSchema,
+      testRunAtomSchema,
+      toolAtomSchema,
+      urlAtomSchema,
+      noteAtomSchema,
+      decisionAtomSchema,
+      prAtomSchema,
+      locDropAtomSchema,
+      callsiteCoverageAtomSchema
+    ]);
+    GATE_EVIDENCE_REQUIREMENTS = Object.freeze({
+      implemented: {
+        oneOf: [
+          ["commit", "files"],
+          ["commit", "note"],
+          ["decision", "files"],
+          ["decision", "note"],
+          ["pr"]
+        ]
+      },
+      testsPassed: { oneOf: [["test-run"], ["tool"], ["pr"]] },
+      qaPassed: { oneOf: [["tool"], ["pr"]] },
+      documented: { oneOf: [["files"], ["url"]] },
+      securityPassed: { oneOf: [["tool"], ["note"]] },
+      cleanupDone: { oneOf: [["note"]] },
+      nexusImpact: { oneOf: [["tool"], ["note"]] }
+    });
+  }
+});
+
 // packages/contracts/src/evidence-record-schema.ts
-import { z as z4 } from "zod";
+import { z as z7 } from "zod";
 var evidenceBaseSchema, implDiffRecordSchema, validateSpecCheckRecordSchema, testOutputRecordSchema, lintReportRecordSchema, commandOutputRecordSchema, evidenceRecordSchema;
 var init_evidence_record_schema = __esm({
   "packages/contracts/src/evidence-record-schema.ts"() {
     "use strict";
-    evidenceBaseSchema = z4.object({
+    evidenceBaseSchema = z7.object({
       /** Identity string of the agent that produced this record. */
-      agentIdentity: z4.string().min(1),
+      agentIdentity: z7.string().min(1),
       /** SHA-256 hex digest (64 chars) of the attached artifact. */
-      attachmentSha256: z4.string().length(64),
+      attachmentSha256: z7.string().length(64),
       /** ISO 8601 timestamp at which the action ran. */
-      ranAt: z4.string().datetime(),
+      ranAt: z7.string().datetime(),
       /** Wall-clock duration of the action in milliseconds. */
-      durationMs: z4.number().nonnegative()
+      durationMs: z7.number().nonnegative()
     });
     implDiffRecordSchema = evidenceBaseSchema.extend({
-      kind: z4.literal("impl-diff"),
-      phase: z4.literal("implement"),
-      filesChanged: z4.array(z4.string().min(1)).min(1),
-      linesAdded: z4.number().int().nonnegative(),
-      linesRemoved: z4.number().int().nonnegative()
+      kind: z7.literal("impl-diff"),
+      phase: z7.literal("implement"),
+      filesChanged: z7.array(z7.string().min(1)).min(1),
+      linesAdded: z7.number().int().nonnegative(),
+      linesRemoved: z7.number().int().nonnegative()
     });
     validateSpecCheckRecordSchema = evidenceBaseSchema.extend({
-      kind: z4.literal("validate-spec-check"),
-      phase: z4.literal("validate"),
-      reqIdsChecked: z4.array(z4.string().min(1)).min(1),
-      passed: z4.boolean(),
-      details: z4.string().min(1)
+      kind: z7.literal("validate-spec-check"),
+      phase: z7.literal("validate"),
+      reqIdsChecked: z7.array(z7.string().min(1)).min(1),
+      passed: z7.boolean(),
+      details: z7.string().min(1)
     });
     testOutputRecordSchema = evidenceBaseSchema.extend({
-      kind: z4.literal("test-output"),
-      phase: z4.literal("test"),
-      command: z4.string().min(1),
-      exitCode: z4.number().int(),
-      testsPassed: z4.number().int().nonnegative(),
-      testsFailed: z4.number().int().nonnegative()
+      kind: z7.literal("test-output"),
+      phase: z7.literal("test"),
+      command: z7.string().min(1),
+      exitCode: z7.number().int(),
+      testsPassed: z7.number().int().nonnegative(),
+      testsFailed: z7.number().int().nonnegative()
     });
     lintReportRecordSchema = evidenceBaseSchema.extend({
-      kind: z4.literal("lint-report"),
-      phase: z4.enum(["implement", "test"]),
-      tool: z4.string().min(1),
-      passed: z4.boolean(),
-      warnings: z4.number().int().nonnegative(),
-      errors: z4.number().int().nonnegative()
+      kind: z7.literal("lint-report"),
+      phase: z7.enum(["implement", "test"]),
+      tool: z7.string().min(1),
+      passed: z7.boolean(),
+      warnings: z7.number().int().nonnegative(),
+      errors: z7.number().int().nonnegative()
     });
     commandOutputRecordSchema = evidenceBaseSchema.extend({
-      kind: z4.literal("command-output"),
-      phase: z4.enum(["implement", "validate", "test"]),
-      cmd: z4.string().min(1),
-      exitCode: z4.number().int()
+      kind: z7.literal("command-output"),
+      phase: z7.enum(["implement", "validate", "test"]),
+      cmd: z7.string().min(1),
+      exitCode: z7.number().int()
     });
-    evidenceRecordSchema = z4.discriminatedUnion("kind", [
+    evidenceRecordSchema = z7.discriminatedUnion("kind", [
       implDiffRecordSchema,
       validateSpecCheckRecordSchema,
       testOutputRecordSchema,
@@ -1272,6 +1513,458 @@ var init_graph = __esm({
   }
 });
 
+// packages/contracts/src/invariants/adr-056-release.ts
+var ARCHIVE_REASON_MODULE, RELEASE_INVARIANTS_REGISTRY_MODULE, RELEASE_COMMIT_MSG_HOOK, ADR_056_INVARIANTS;
+var init_adr_056_release = __esm({
+  "packages/contracts/src/invariants/adr-056-release.ts"() {
+    "use strict";
+    ARCHIVE_REASON_MODULE = "packages/contracts/src/tasks/archive.ts";
+    RELEASE_INVARIANTS_REGISTRY_MODULE = "packages/core/src/release/invariants/registry.ts";
+    RELEASE_COMMIT_MSG_HOOK = "scripts/hooks/commit-msg-release-lint.mjs";
+    ADR_056_INVARIANTS = Object.freeze([
+      {
+        adr: "ADR-056",
+        code: "D1",
+        name: "Database topology: keep per-domain split",
+        description: "CLEO retains the six per-domain SQLite databases (tasks, brain, conduit, nexus, signaldock, telemetry) documented in DATABASE-ERDS.md. Consolidation is rejected to preserve per-DB WAL throughput, per-DB rollback granularity, and avoid single-writer contention during multi-agent waves.",
+        severity: "info",
+        // D1 is a topology decision; the absence of consolidation is its only
+        // enforcement surface. No runtime guard, no lint script.
+        runtimeGate: null,
+        lintRule: null,
+        doctorAudit: null,
+        tests: []
+      },
+      {
+        adr: "ADR-056",
+        code: "D2",
+        name: "Store-layer naming convention",
+        description: "New always-on store-layer domains MUST use the kebab-case pair `packages/core/src/store/<domain>-schema.ts` (Drizzle defs) + `packages/core/src/store/<domain>-sqlite.ts` (open/init/CRUD). Opt-in / isolated domains MAY use the folder variant `packages/core/src/<domain>/{schema,sqlite}.ts` (currently telemetry only).",
+        severity: "info",
+        // D2 is a naming-convention decision; enforced by code review and the
+        // ADR-073/ADR-056 doctor audit. No runtime guard.
+        runtimeGate: null,
+        lintRule: null,
+        doctorAudit: null,
+        tests: []
+      },
+      {
+        adr: "ADR-056",
+        code: "D3",
+        name: "Migration runner SSoT under migration-manager.ts",
+        description: "All six SQLite databases MUST be initialized via `packages/core/src/migration/migration-manager.ts` (`migrateWithRetry()` + `reconcileJournal()`). Per-DB bespoke runners are prohibited for new domains. Rust Diesel migrations for cloud signaldock-storage MUST NOT touch the local SQLite signaldock.db at runtime.",
+        severity: "info",
+        // D3 is enforced by the absence of bespoke runners — every domain's
+        // `<domain>-sqlite.ts` open path delegates to migration-manager. No
+        // single runtime guard; per-DB chokepoints are the enforcement surface.
+        runtimeGate: null,
+        lintRule: null,
+        doctorAudit: null,
+        tests: []
+      },
+      {
+        adr: "ADR-056",
+        code: "D4",
+        name: "archiveReason 6-value enum with tombstone semantics",
+        description: "The tasks.archive_reason column is constrained to exactly six values (verified, reconciled, superseded, shadowed, cancelled, completed-unverified) via SQLite CHECK constraint AND Zod z.enum validation. Writing 'completed-unverified' from non-migration code MUST throw E_ARCHIVE_REASON_TOMBSTONE \u2014 the tombstone is reserved for the T1408 backfill migration only.",
+        severity: "error",
+        runtimeGate: {
+          module: ARCHIVE_REASON_MODULE,
+          functionName: "assertArchiveReason"
+        },
+        lintRule: null,
+        doctorAudit: null,
+        tests: ["packages/contracts/src/tasks/__tests__/archive.test.ts"]
+      },
+      {
+        adr: "ADR-056",
+        code: "D5",
+        name: "Post-release reconciliation: registry-driven cleo verify --release",
+        description: "Post-release reconciliation flows through the executable invariants registry at packages/core/src/release/invariants/registry.ts. Customers register via registerInvariant() and the CLI runs every entry on `cleo verify --release <tag>`. First customer: archive-reason-invariant.ts (stamps verified tasks done; creates follow-up tasks for unverified references).",
+        severity: "warning",
+        runtimeGate: {
+          module: RELEASE_INVARIANTS_REGISTRY_MODULE,
+          functionName: "runInvariants"
+        },
+        lintRule: null,
+        doctorAudit: null,
+        tests: ["packages/core/src/release/invariants/__tests__/archive-reason-invariant.test.ts"]
+      },
+      {
+        adr: "ADR-056",
+        code: "D6",
+        name: "Commit-message lint for release commits",
+        description: "Every commit whose subject matches `^(chore|feat)\\(release\\):` MUST contain at least one `T\\d+` task reference in the commit body. Enforced by scripts/hooks/commit-msg-release-lint.mjs (T1410). Bypass via CLEO_OWNER_OVERRIDE=1 with audited justification.",
+        severity: "info",
+        // D6 is a CI-hook concern. The hook itself is the enforcement surface
+        // — represented here via lintRule for cross-reference rendering.
+        runtimeGate: null,
+        lintRule: {
+          lintScript: RELEASE_COMMIT_MSG_HOOK
+        },
+        doctorAudit: null,
+        tests: []
+      }
+    ]);
+  }
+});
+
+// packages/contracts/src/invariants/adr-070-orchestration.ts
+var THIN_AGENT_MODULE, SESSIONS_MODULE, WORKTREE_CREATE_MODULE, CT_ORCHESTRATOR_SKILL, VALIDATE_SPAWN_MODULE, SKILL_VALIDATOR_TESTS, ADR_070_INVARIANTS, ADR_070_INVARIANT_COUNT;
+var init_adr_070_orchestration = __esm({
+  "packages/contracts/src/invariants/adr-070-orchestration.ts"() {
+    "use strict";
+    THIN_AGENT_MODULE = "packages/core/src/orchestration/thin-agent.ts";
+    SESSIONS_MODULE = "packages/core/src/sessions/index.ts";
+    WORKTREE_CREATE_MODULE = "packages/worktree/src/worktree-create.ts";
+    CT_ORCHESTRATOR_SKILL = "packages/skills/skills/ct-orchestrator/SKILL.md";
+    VALIDATE_SPAWN_MODULE = "packages/core/src/orchestration/validate-spawn.ts";
+    SKILL_VALIDATOR_TESTS = "packages/core/src/skills/orchestrator/__tests__/validator.test.ts";
+    ADR_070_INVARIANTS = Object.freeze([
+      {
+        adr: "ADR-070",
+        code: "ORC-001",
+        name: "Orchestrator is the HITL interface",
+        description: "The Orchestrator (Cleo) is the single subagent that talks to the human operator. It plans, decomposes, and delegates \u2014 it never produces line-level implementation. Source-of-truth lives in ct-orchestrator/SKILL.md row ORC-001 and is injected into the Orchestrator prompt at spawn time. UNENFORCED at the dispatch layer: this is a prompt-time invariant with no runtime guard today.",
+        severity: "warning",
+        runtimeGate: null,
+        lintRule: null,
+        doctorAudit: null,
+        tests: [CT_ORCHESTRATOR_SKILL]
+      },
+      {
+        adr: "ADR-070",
+        code: "ORC-002",
+        name: "Orchestrator MUST NOT write or edit code",
+        description: "Every line of code is written by a spawned subagent. The Orchestrator delegates implementation work via cleo orchestrate spawn / delegate_task. UNENFORCED at the dispatch layer: this is a prompt-time invariant \u2014 there is no runtime gate that blocks the Orchestrator from calling Edit/Write, so the contract is held by the ct-orchestrator skill text.",
+        severity: "warning",
+        runtimeGate: null,
+        lintRule: null,
+        doctorAudit: null,
+        tests: [CT_ORCHESTRATOR_SKILL]
+      },
+      {
+        adr: "ADR-070",
+        code: "ORC-003",
+        name: "Orchestrator MUST NOT read full source files",
+        description: "Orchestrator reads only pipeline manifests, task envelopes, and rolled-up phase summaries returned by Phase Leads. Workers read code; the Orchestrator reads summaries. UNENFORCED at the dispatch layer \u2014 held by the ct-orchestrator skill text and reinforced by ORC-005 budget pressure.",
+        severity: "warning",
+        runtimeGate: null,
+        lintRule: null,
+        doctorAudit: null,
+        tests: [CT_ORCHESTRATOR_SKILL]
+      },
+      {
+        adr: "ADR-070",
+        code: "ORC-004",
+        name: "Dependency-ordered spawning",
+        description: "Spawns within a wave are ordered by task.depends \u2014 a Worker MUST NOT be dispatched until its declared dependencies are status=done. Surfaced by validateSpawnReadiness via V_MISSING_DEP / V_UNMET_DEP codes; surfaced by the skill-orchestrator validator via the ORC-004_DEPENDENCY_ORDER warning emitted from packages/core/src/skills/orchestrator/validator.ts. Tier: warning because the validator surfaces ordering issues but does not throw \u2014 workers can still proceed if the operator overrides.",
+        severity: "warning",
+        runtimeGate: {
+          module: VALIDATE_SPAWN_MODULE,
+          functionName: "validateSpawnReadiness"
+        },
+        lintRule: null,
+        doctorAudit: null,
+        tests: [
+          "packages/core/src/orchestration/__tests__/validate-spawn.test.ts",
+          SKILL_VALIDATOR_TESTS
+        ]
+      },
+      {
+        adr: "ADR-070",
+        code: "ORC-005",
+        name: "Orchestrator context budget \u2248 10 K tokens",
+        description: "The Orchestrator MUST keep its working context under ~10 K tokens; delegate at 80 %. Surfaced by cleo orchestrate context (estimateContext) and by the skill-orchestrator validator (ORC-005_NO_MANIFEST / ORC-005_EMPTY_MANIFEST). UNENFORCED as a hard gate \u2014 the budget is advisory, surfaced to the Orchestrator as a warning so the human operator can intervene.",
+        severity: "warning",
+        runtimeGate: {
+          module: "packages/core/src/orchestration/context.ts",
+          functionName: "estimateContext"
+        },
+        lintRule: null,
+        doctorAudit: null,
+        tests: ["packages/core/src/orchestration/__tests__/"]
+      },
+      {
+        adr: "ADR-070",
+        code: "ORC-006",
+        name: "Worker scope \u2264 3 files per spawn",
+        description: "Cross-file reasoning quality degrades beyond ~3 files for a single Worker. Enforced at spawn-time by validateSpawnReadiness \u2014 V_ATOMIC_SCOPE_MISSING when task.files is empty, V_ATOMIC_SCOPE_TOO_LARGE when files.length > MAX_WORKER_FILES (currently 3). Spawn-prompt builder injects a Worker Budget Constraints section so the Worker sees the budget inline. Tier: error because the gate refuses to spawn an over-scoped Worker.",
+        severity: "error",
+        runtimeGate: {
+          module: VALIDATE_SPAWN_MODULE,
+          functionName: "validateSpawnReadiness"
+        },
+        lintRule: null,
+        doctorAudit: null,
+        tests: [
+          "packages/core/src/orchestration/__tests__/validate-spawn.test.ts",
+          "packages/core/src/orchestration/__tests__/spawn-prompt.test.ts"
+        ]
+      },
+      {
+        adr: "ADR-070",
+        code: "ORC-007",
+        name: "All work traced to an Epic",
+        description: "Every Task and Subtask MUST attach to a parent Epic (directly or transitively). No orphan work \u2014 orphans are filed against the ADR-066 acceptance-criteria gate and surface via cleo find. UNENFORCED at the dispatch layer; the parent-id requirement is materialised through cleo add validation rather than a single ORC-named guard. R6 doctor audit should walk the task graph to surface orphans.",
+        severity: "warning",
+        runtimeGate: null,
+        lintRule: null,
+        doctorAudit: null,
+        tests: [CT_ORCHESTRATOR_SKILL]
+      },
+      {
+        adr: "ADR-070",
+        code: "ORC-008",
+        name: "Zero architectural decisions during execution",
+        description: "Architectural choices MUST be pre-decided via RCASD consensus or HITL \u2014 never inside a worker session. UNENFORCED at the dispatch layer: this is a behavioural invariant held by the ct-orchestrator skill text plus the ADR-066 acceptance criterion that every task must declare its architecture-relevant decisions before spawn.",
+        severity: "warning",
+        runtimeGate: null,
+        lintRule: null,
+        doctorAudit: null,
+        tests: [CT_ORCHESTRATOR_SKILL]
+      },
+      {
+        adr: "ADR-070",
+        code: "ORC-009",
+        name: "Manifest-mediated handoffs",
+        description: "Orchestrator reads only the key_findings field of pipeline_manifest rows when reconciling worker output. Subagents read the full task description and supporting files. UNENFORCED at the dispatch layer: the contract is held by the ct-orchestrator skill text and reinforced by ORC-003 + ORC-005 budget pressure.",
+        severity: "warning",
+        runtimeGate: null,
+        lintRule: null,
+        doctorAudit: null,
+        tests: [CT_ORCHESTRATOR_SKILL]
+      },
+      {
+        adr: "ADR-070",
+        code: "ORC-010",
+        name: "Lead-interposition required for Epic-child Workers",
+        description: "A Worker spawn against a Task whose parent is type=epic MUST be preceded by a Lead spawn for the same Task (ADR-083 \xA72.4 / \xA76). The intended runtime gate (composeSpawnPayload throwing E_LEAD_REQUIRED_FOR_EPIC_CHILD) is FILED but UNSHIPPED \u2014 tracked under T10278. Registered here as a warning + runtimeGate:null so the gap is visible in the R6 doctor audit.",
+        severity: "warning",
+        runtimeGate: null,
+        lintRule: null,
+        doctorAudit: null,
+        tests: []
+      },
+      {
+        adr: "ADR-070",
+        code: "ORC-011",
+        name: "Orchestrator-depth cap at 3",
+        description: "Recursive Orchestrator spawns (Cleo \u2192 sub-Orchestrator \u2192 sub-Orchestrator \u2192 \u2026) MUST stop at depth 3 (ADR-083 \xA72.2 + \xA72.4). The intended runtime gate (composeSpawnPayload throwing E_ORCHESTRATOR_DEPTH_EXCEEDED) is FILED but UNSHIPPED \u2014 tracked under T10279. Registered here as a warning + runtimeGate:null so the gap is visible in the R6 doctor audit.",
+        severity: "warning",
+        runtimeGate: null,
+        lintRule: null,
+        doctorAudit: null,
+        tests: []
+      },
+      {
+        adr: "ADR-070",
+        code: "ORC-012",
+        name: "Thin-agent inversion-of-control",
+        description: "Workers MUST NOT spawn other subagents. The spawn-capable tools (Agent / Task / TaskCreate) are stripped from the Worker tool list at .cant compile time, and any survivor at spawn time triggers ThinAgentViolationError \u2192 E_THIN_AGENT_VIOLATION (exit 68). The only ORC rule with a hard-enforced dispatch-time gate today.",
+        severity: "error",
+        runtimeGate: {
+          module: THIN_AGENT_MODULE,
+          functionName: "enforceThinAgent"
+        },
+        lintRule: null,
+        doctorAudit: null,
+        tests: [
+          "packages/core/src/orchestration/__tests__/thin-agent.test.ts",
+          "packages/cant/src/__tests__/hierarchy.test.ts"
+        ]
+      },
+      {
+        adr: "ADR-070",
+        code: "ORC-013",
+        name: "Worktree provisioning at canonical XDG location",
+        description: "Every agent worktree MUST be created under <cleoHome>/worktrees/<projectHash>/<taskId>/ (ADR-055 + Council D009). createWorktree throws E_WT_LOCATION_FORBIDDEN before any git worktree add call when the computed path falls outside the canonical root. CI gate lint-worktree-location.mjs enforces the same invariant on every PR. The single-most-load-bearing orchestration guard after ORC-012.",
+        severity: "error",
+        runtimeGate: {
+          module: WORKTREE_CREATE_MODULE,
+          functionName: "assertCanonicalWorktreeLocation"
+        },
+        lintRule: {
+          lintScript: "scripts/lint-worktree-location.mjs"
+        },
+        doctorAudit: null,
+        tests: ["packages/worktree/src/__tests__/"]
+      },
+      {
+        adr: "ADR-070",
+        code: "ORC-014",
+        name: "Lead-bypass detection at session end",
+        description: "A Lead session (CLEO_AGENT_ROLE=lead) that ends with tasks_completed > 0 AND delegate_task_count = 0 is rejected with LeadBypassDetectedError \u2192 E_LEAD_BYPASS_DETECTED (exit 107). Leads MUST fan out work to Workers; a Lead that did the work itself defeats the three-tier topology. Override via CLEO_OWNER_OVERRIDE=1 (audited to force-bypass.jsonl).",
+        severity: "error",
+        runtimeGate: {
+          module: SESSIONS_MODULE,
+          functionName: "endSession"
+        },
+        lintRule: null,
+        doctorAudit: null,
+        tests: ["packages/core/src/sessions/__tests__/"]
+      }
+    ]);
+    ADR_070_INVARIANT_COUNT = ADR_070_INVARIANTS.length;
+  }
+});
+
+// packages/contracts/src/invariants/adr-073-saga.ts
+var SAGA_ENFORCEMENT_MODULE, SAGA_ENFORCEMENT_TESTS, ADR_073_INVARIANTS;
+var init_adr_073_saga = __esm({
+  "packages/contracts/src/invariants/adr-073-saga.ts"() {
+    "use strict";
+    SAGA_ENFORCEMENT_MODULE = "packages/core/src/sagas/enforcement.ts";
+    SAGA_ENFORCEMENT_TESTS = "packages/core/src/sagas/__tests__/enforcement.test.ts";
+    ADR_073_INVARIANTS = Object.freeze([
+      {
+        adr: "ADR-073",
+        code: "I1",
+        name: "Storage uniformity",
+        description: 'All task IDs are stored as T#### and the type column is the canonical tier discriminator. There is no separate ID space for Sagas, Epics, Tasks, or Subtasks; label="saga" elevates a type="epic" row to Saga semantics.',
+        severity: "info",
+        // I1 is enforced by the DB CHECK constraints introduced in W1.B (T10329)
+        // and by TASK_ID_PATTERN in packages/core/src/tasks/id-generator.ts —
+        // not by a single runtime function.
+        runtimeGate: null,
+        lintRule: null,
+        doctorAudit: null,
+        tests: ["packages/core/src/tasks/__tests__/id-generator.test.ts"]
+      },
+      {
+        adr: "ADR-073",
+        code: "I2",
+        name: "Conceptual prefixes are display + import only",
+        description: "SG-, E-, T- (and Subtask's implicit absence) are documentation, CLI display, and import-mapping conventions only. They MUST NOT be used as DB primary keys \u2014 display-only with no runtime enforcement.",
+        severity: "info",
+        // I2 is a display convention; the SG- prefix preservation snapshot
+        // (T10333) protects the display contract but there is no runtime guard.
+        runtimeGate: null,
+        lintRule: null,
+        doctorAudit: null,
+        tests: []
+      },
+      {
+        adr: "ADR-073",
+        code: "I3",
+        name: "Tier promotion mandatory when scope outgrows the tier",
+        description: "A Subtask whose change exceeds 2 files or crosses a module boundary MUST be split or promoted to a sibling Task. A Task that requires more than one PR or wave MUST be split. An Epic that spans more than one release MUST be regrouped under a Saga.",
+        severity: "error",
+        runtimeGate: {
+          module: SAGA_ENFORCEMENT_MODULE,
+          functionName: "assertSagaInvariantI3"
+        },
+        lintRule: null,
+        doctorAudit: null,
+        tests: [SAGA_ENFORCEMENT_TESTS]
+      },
+      {
+        adr: "ADR-073",
+        code: "I4",
+        name: "Ownership non-overlapping",
+        description: "A single tier maps to a single orchestration role (per ADR-070). Workers MUST NOT spawn other Workers. Phase Leads MUST NOT own multiple Epics simultaneously. The Orchestrator MUST NOT spawn Workers directly when fan-out exceeds the ADR-070 migration threshold.",
+        severity: "warning",
+        // I4 is partially covered by ADR-070 spawn guards but the unification
+        // with the registry happens in R2 (T10336 — ORC codes). For now this
+        // entry stays warning + runtimeGate:null to mark the gap explicitly.
+        runtimeGate: null,
+        lintRule: null,
+        doctorAudit: null,
+        tests: []
+      },
+      {
+        adr: "ADR-073",
+        code: "I5",
+        name: "Sagas link via groups, not parent",
+        description: `task_relations.type="groups" is the ONLY relation type that links a Saga to its member Epics. The Saga row's parent_id MUST be NULL. Enforced at runtime by assertSagaInvariantI5 AND by the DB CHECK constraint from W1.B (T10329) on label="saga" rows.`,
+        severity: "error",
+        runtimeGate: {
+          module: SAGA_ENFORCEMENT_MODULE,
+          functionName: "assertSagaInvariantI5"
+        },
+        lintRule: null,
+        doctorAudit: null,
+        tests: [SAGA_ENFORCEMENT_TESTS]
+      },
+      {
+        adr: "ADR-073",
+        code: "I6",
+        name: "Acceptance criteria required at every tier",
+        description: 'Per ADR-066 \xA7"Ownership Matrix" invariant #5, all tasks regardless of type or kind MUST have --acceptance set at creation time. No tier exemption exists. Delegated to the ADR-066 --acceptance requirement on cleo add/add-batch.',
+        severity: "warning",
+        // I6 is enforced by ADR-066's CLI requirement, not by a saga runtime
+        // function. UNENFORCED in the saga module — left as a warning so R6
+        // doctor audit reminds operators of the upstream guard's location.
+        runtimeGate: null,
+        lintRule: null,
+        doctorAudit: null,
+        tests: []
+      },
+      {
+        adr: "ADR-073",
+        code: "I7",
+        name: "Maximum parent depth is 3",
+        description: "The parent ladder Subtask \u2192 Task \u2192 Epic is fixed at depth 3 (hierarchy.maxDepth=3). Sagas do NOT consume depth \u2014 they attach via groups relations, not parent edges. Enforced at runtime by assertSagaInvariantI7.",
+        severity: "error",
+        runtimeGate: {
+          module: SAGA_ENFORCEMENT_MODULE,
+          functionName: "assertSagaInvariantI7"
+        },
+        lintRule: null,
+        doctorAudit: null,
+        tests: [SAGA_ENFORCEMENT_TESTS]
+      },
+      {
+        adr: "ADR-073",
+        code: "I8",
+        name: "Subtask-to-PR aggregation rule",
+        description: "A Task ships as exactly one PR. The PR's commit history is the union of the Task's Subtask commits. A Subtask never produces its own PR; if a unit of work warrants its own PR, it is a Task, not a Subtask. UNENFORCED at runtime today \u2014 load-bearing convention enforced via code review and the lifecycle decision table.",
+        severity: "warning",
+        // I8 is explicitly "UNENFORCED, load-bearing" — there is no automated
+        // gate. R6 doctor audit surfaces this entry so it stays visible.
+        runtimeGate: null,
+        lintRule: null,
+        doctorAudit: null,
+        tests: []
+      }
+    ]);
+  }
+});
+
+// packages/contracts/src/invariants/index.ts
+function buildKey(invariant) {
+  return `${invariant.adr}.${invariant.code}`;
+}
+function buildRegistry() {
+  const entries = [
+    ...ADR_073_INVARIANTS,
+    ...ADR_056_INVARIANTS,
+    ...ADR_070_INVARIANTS
+  ];
+  const record2 = {};
+  for (const entry of entries) {
+    const key = buildKey(entry);
+    if (record2[key] !== void 0) {
+      throw new Error(`Duplicate invariant key registered: ${key}`);
+    }
+    record2[key] = entry;
+  }
+  return Object.freeze(record2);
+}
+var INVARIANTS_REGISTRY;
+var init_invariants = __esm({
+  "packages/contracts/src/invariants/index.ts"() {
+    "use strict";
+    init_adr_056_release();
+    init_adr_070_orchestration();
+    init_adr_073_saga();
+    init_adr_056_release();
+    init_adr_070_orchestration();
+    init_adr_073_saga();
+    INVARIANTS_REGISTRY = buildRegistry();
+  }
+});
+
 // packages/contracts/src/lafs.ts
 var init_lafs = __esm({
   "packages/contracts/src/lafs.ts"() {
@@ -1540,31 +2233,31 @@ var init_peer = __esm({
 });
 
 // packages/contracts/src/release/evidence-atoms.ts
-import { z as z5 } from "zod";
+import { z as z8 } from "zod";
 var parsedPrEvidenceAtomSchema, prEvidenceStateModifierSchema, ghPrViewSchema, PR_REQUIRED_WORKFLOWS;
 var init_evidence_atoms = __esm({
   "packages/contracts/src/release/evidence-atoms.ts"() {
     "use strict";
-    parsedPrEvidenceAtomSchema = z5.object({
-      kind: z5.literal("pr"),
-      prNumber: z5.number().int().positive()
-    });
-    prEvidenceStateModifierSchema = z5.object({
-      kind: z5.literal("state"),
-      value: z5.literal("MERGED")
-    });
-    ghPrViewSchema = z5.object({
-      state: z5.enum(["OPEN", "CLOSED", "MERGED"]),
-      mergedAt: z5.string().nullable(),
-      headRefOid: z5.string().optional(),
-      mergeable: z5.string().optional(),
-      statusCheckRollup: z5.array(
-        z5.object({
-          __typename: z5.string().optional(),
-          name: z5.string().optional(),
-          workflowName: z5.string().optional(),
-          conclusion: z5.string().nullable().optional(),
-          status: z5.string().optional()
+    parsedPrEvidenceAtomSchema = z8.object({
+      kind: z8.literal("pr"),
+      prNumber: z8.number().int().positive()
+    });
+    prEvidenceStateModifierSchema = z8.object({
+      kind: z8.literal("state"),
+      value: z8.literal("MERGED")
+    });
+    ghPrViewSchema = z8.object({
+      state: z8.enum(["OPEN", "CLOSED", "MERGED"]),
+      mergedAt: z8.string().nullable(),
+      headRefOid: z8.string().optional(),
+      mergeable: z8.string().optional(),
+      statusCheckRollup: z8.array(
+        z8.object({
+          __typename: z8.string().optional(),
+          name: z8.string().optional(),
+          workflowName: z8.string().optional(),
+          conclusion: z8.string().nullable().optional(),
+          status: z8.string().optional()
         }).passthrough()
       ).optional().default([])
     }).passthrough();
@@ -1577,7 +2270,7 @@ var init_evidence_atoms = __esm({
 });
 
 // packages/contracts/src/release/plan.ts
-import { z as z6 } from "zod";
+import { z as z9 } from "zod";
 var RELEASE_CHANNEL, RELEASE_SCHEME, RELEASE_KIND, RELEASE_STATUS, GATE_STATUS, GATE_NAME, PLATFORM_TUPLE, PUBLISHER, TASK_KIND, IMPACT, RESOLVED_SOURCE, ReleaseChannelSchema, ReleaseSchemeSchema, ReleaseKindSchema, ReleaseStatusSchema, GateStatusSchema, GateNameSchema, PlatformTupleSchema, PublisherSchema, TaskKindSchema, ImpactSchema, ResolvedSourceSchema, Iso8601, NonEmptyString, ReleasePlanTaskSchema, ReleaseGateSchema, ReleasePlatformMatrixEntrySchema, ReleasePreflightSummarySchema, ReleasePlanChangelogSchema, ReleasePlanMetaSchema, ReleasePlanSchema;
 var init_plan = __esm({
   "packages/contracts/src/release/plan.ts"() {
@@ -1620,20 +2313,20 @@ var init_plan = __esm({
     ];
     IMPACT = ["major", "minor", "patch"];
     RESOLVED_SOURCE = ["project-context", "language-default", "legacy-alias"];
-    ReleaseChannelSchema = z6.enum(RELEASE_CHANNEL);
-    ReleaseSchemeSchema = z6.enum(RELEASE_SCHEME);
-    ReleaseKindSchema = z6.enum(RELEASE_KIND);
-    ReleaseStatusSchema = z6.enum(RELEASE_STATUS);
-    GateStatusSchema = z6.enum(GATE_STATUS);
-    GateNameSchema = z6.enum(GATE_NAME);
-    PlatformTupleSchema = z6.enum(PLATFORM_TUPLE);
-    PublisherSchema = z6.enum(PUBLISHER);
-    TaskKindSchema = z6.enum(TASK_KIND);
-    ImpactSchema = z6.enum(IMPACT);
-    ResolvedSourceSchema = z6.enum(RESOLVED_SOURCE);
-    Iso8601 = z6.iso.datetime({ offset: true });
-    NonEmptyString = z6.string().min(1);
-    ReleasePlanTaskSchema = z6.object({
+    ReleaseChannelSchema = z9.enum(RELEASE_CHANNEL);
+    ReleaseSchemeSchema = z9.enum(RELEASE_SCHEME);
+    ReleaseKindSchema = z9.enum(RELEASE_KIND);
+    ReleaseStatusSchema = z9.enum(RELEASE_STATUS);
+    GateStatusSchema = z9.enum(GATE_STATUS);
+    GateNameSchema = z9.enum(GATE_NAME);
+    PlatformTupleSchema = z9.enum(PLATFORM_TUPLE);
+    PublisherSchema = z9.enum(PUBLISHER);
+    TaskKindSchema = z9.enum(TASK_KIND);
+    ImpactSchema = z9.enum(IMPACT);
+    ResolvedSourceSchema = z9.enum(RESOLVED_SOURCE);
+    Iso8601 = z9.iso.datetime({ offset: true });
+    NonEmptyString = z9.string().min(1);
+    ReleasePlanTaskSchema = z9.object({
       /** Task ID (e.g. "T10001"). Format intentionally loose so historical IDs validate. */
       id: NonEmptyString,
       /** Conventional-commit-aligned task classification. */
@@ -1641,20 +2334,20 @@ var init_plan = __esm({
       /** SemVer impact classification. */
       impact: ImpactSchema,
       /** Human-readable changelog line for this task. */
-      userFacingSummary: z6.string(),
+      userFacingSummary: z9.string(),
       /**
        * ADR-051 evidence atoms attesting the task's gate results. Format is
        * `kind:value` (e.g. `commit:abc123`, `test-run:vitest.json`). The contract
        * accepts empty arrays so legacy plans validate; `cleo release plan`
        * enforces non-empty via R-301.
        */
-      evidenceAtoms: z6.array(NonEmptyString),
+      evidenceAtoms: z9.array(NonEmptyString),
       /** IVTR phase at plan time — informational only per R-316. */
-      ivtrPhaseAtPlan: z6.string().optional(),
+      ivtrPhaseAtPlan: z9.string().optional(),
       /** Epic this task rolls up to, locked at plan time per R-303. */
       epicAncestor: NonEmptyString
     });
-    ReleaseGateSchema = z6.object({
+    ReleaseGateSchema = z9.object({
       /** Canonical gate name. */
       name: GateNameSchema,
       /** ADR-051 atom string identifying the resolved tool (e.g. `tool:test`). */
@@ -1664,11 +2357,11 @@ var init_plan = __esm({
       /** ISO-8601 timestamp the gate was last verified. */
       lastVerifiedAt: Iso8601,
       /** Resolved shell command (e.g. `pnpm run test`). Optional for unresolved gates. */
-      resolvedCommand: z6.string().optional(),
+      resolvedCommand: z9.string().optional(),
       /** Provenance of the resolved command. Optional for unresolved gates. */
       resolvedSource: ResolvedSourceSchema.optional()
     });
-    ReleasePlatformMatrixEntrySchema = z6.object({
+    ReleasePlatformMatrixEntrySchema = z9.object({
       /** Target platform tuple. */
       platform: PlatformTupleSchema,
       /** Distribution backend. */
@@ -1676,47 +2369,47 @@ var init_plan = __esm({
       /** Package identifier on the target backend (e.g. `@cleocode/cleo`). */
       package: NonEmptyString,
       /** Whether to run the GHA smoke job for this matrix entry. */
-      smoke: z6.boolean().default(true).optional()
+      smoke: z9.boolean().default(true).optional()
     });
-    ReleasePreflightSummarySchema = z6.object({
+    ReleasePreflightSummarySchema = z9.object({
       /** True if esbuild externals are out of sync with package.json. */
-      esbuildExternalsDrift: z6.boolean(),
+      esbuildExternalsDrift: z9.boolean(),
       /** True if `pnpm-lock.yaml` diverges from the workspace manifest. */
-      lockfileDrift: z6.boolean(),
+      lockfileDrift: z9.boolean(),
       /** True if all epic children are in terminal lifecycle states. */
-      epicCompletenessClean: z6.boolean(),
+      epicCompletenessClean: z9.boolean(),
       /** True if no task appears in multiple in-flight release plans. */
-      doubleListingClean: z6.boolean(),
+      doubleListingClean: z9.boolean(),
       /** Non-fatal preflight warnings (e.g. unresolved tools per R-024). */
-      preflightWarnings: z6.array(z6.string()).default([]).optional()
+      preflightWarnings: z9.array(z9.string()).default([]).optional()
     });
-    ReleasePlanChangelogSchema = z6.object({
+    ReleasePlanChangelogSchema = z9.object({
       /** `kind=feat` tasks. */
-      features: z6.array(NonEmptyString).default([]),
+      features: z9.array(NonEmptyString).default([]),
       /** `kind=fix` or `kind=hotfix` tasks. */
-      fixes: z6.array(NonEmptyString).default([]),
+      fixes: z9.array(NonEmptyString).default([]),
       /** `kind=chore`, `docs`, `refactor`, `test`, `perf` tasks. */
-      chores: z6.array(NonEmptyString).default([]),
+      chores: z9.array(NonEmptyString).default([]),
       /** `kind=breaking` or `kind=revert` tasks. */
-      breaking: z6.array(NonEmptyString).default([])
+      breaking: z9.array(NonEmptyString).default([])
     });
-    ReleasePlanMetaSchema = z6.object({
+    ReleasePlanMetaSchema = z9.object({
       /** True if this is the project's first ever release. */
-      firstEverRelease: z6.boolean().optional(),
+      firstEverRelease: z9.boolean().optional(),
       /** Canonical tool names that could not be resolved at plan time. */
-      unresolvedTools: z6.array(z6.string()).optional(),
+      unresolvedTools: z9.array(z9.string()).optional(),
       /** Project archetype detected at plan time. */
-      archetype: z6.string().optional()
-    }).catchall(z6.unknown());
-    ReleasePlanSchema = z6.object({
+      archetype: z9.string().optional()
+    }).catchall(z9.unknown());
+    ReleasePlanSchema = z9.object({
       /** Schema URL for this plan version. */
-      $schema: z6.string().optional(),
+      $schema: z9.string().optional(),
       /** Requested version string (e.g. "v2026.6.0"). Includes the leading `v`. */
       version: NonEmptyString,
       /** Resolved version string after suffix application (e.g. "v2026.6.0.2"). */
       resolvedVersion: NonEmptyString,
       /** True if a `calver-suffix` was applied to disambiguate a same-day hotfix. */
-      suffixApplied: z6.boolean(),
+      suffixApplied: z9.boolean(),
       /** Versioning scheme governing `version` / `resolvedVersion`. */
       scheme: ReleaseSchemeSchema,
       /** npm dist-tag channel for this release. */
@@ -1733,27 +2426,27 @@ var init_plan = __esm({
        * Version of the previous release on the same channel. MUST be `null` only
        * for first-ever releases (R-300, enforced at the verb layer).
        */
-      previousVersion: z6.string().nullable(),
+      previousVersion: z9.string().nullable(),
       /** Git tag of the previous release (typically `previousVersion` prefixed). */
-      previousTag: z6.string().nullable(),
+      previousTag: z9.string().nullable(),
       /** ISO-8601 timestamp the previous release was published. */
       previousShippedAt: Iso8601.nullable(),
       /** Tasks rolled into this release. */
-      tasks: z6.array(ReleasePlanTaskSchema),
+      tasks: z9.array(ReleasePlanTaskSchema),
       /** Bucketed changelog. */
       changelog: ReleasePlanChangelogSchema,
       /** Per-gate verification status. */
-      gates: z6.array(ReleaseGateSchema),
+      gates: z9.array(ReleaseGateSchema),
       /** Platform / publisher matrix. */
-      platformMatrix: z6.array(ReleasePlatformMatrixEntrySchema),
+      platformMatrix: z9.array(ReleasePlatformMatrixEntrySchema),
       /** Preflight summary from `cleo release plan`. */
       preflightSummary: ReleasePreflightSummarySchema,
       /** URL of the GHA workflow run (populated by `release-prepare.yml`). */
-      workflowRunUrl: z6.string().nullable(),
+      workflowRunUrl: z9.string().nullable(),
       /** URL of the bump PR (populated by `cleo release open`). */
-      prUrl: z6.string().nullable(),
+      prUrl: z9.string().nullable(),
       /** Merge commit SHA on `main` (populated by `release-publish.yml`). */
-      mergeCommitSha: z6.string().nullable(),
+      mergeCommitSha: z9.string().nullable(),
       /** Current FSM state per R-302. */
       status: ReleaseStatusSchema,
       /** Informational / forward-compat metadata. */
@@ -1809,52 +2502,52 @@ var init_session2 = __esm({
 });
 
 // packages/contracts/src/session-journal.ts
-import { z as z7 } from "zod";
+import { z as z10 } from "zod";
 var SESSION_JOURNAL_SCHEMA_VERSION, sessionJournalDoctorSummarySchema, sessionJournalDebriefSummarySchema, sessionJournalEntrySchema;
 var init_session_journal = __esm({
   "packages/contracts/src/session-journal.ts"() {
     "use strict";
     SESSION_JOURNAL_SCHEMA_VERSION = "1.0";
-    sessionJournalDoctorSummarySchema = z7.object({
+    sessionJournalDoctorSummarySchema = z10.object({
       /** `true` when zero noise patterns were detected. */
-      isClean: z7.boolean(),
+      isClean: z10.boolean(),
       /** Total number of noise findings across all patterns. */
-      findingsCount: z7.number().int().nonnegative(),
+      findingsCount: z10.number().int().nonnegative(),
       /** Pattern names that were detected (empty when isClean). */
-      patterns: z7.array(z7.string()),
+      patterns: z10.array(z10.string()),
       /** Total brain entries scanned. `0` = empty or unavailable. */
-      totalScanned: z7.number().int().nonnegative()
+      totalScanned: z10.number().int().nonnegative()
     });
-    sessionJournalDebriefSummarySchema = z7.object({
+    sessionJournalDebriefSummarySchema = z10.object({
       /** First 200 characters of the session end note (if provided). */
-      noteExcerpt: z7.string().max(200).optional(),
+      noteExcerpt: z10.string().max(200).optional(),
       /** Number of tasks completed during the session. */
-      tasksCompletedCount: z7.number().int().nonnegative(),
+      tasksCompletedCount: z10.number().int().nonnegative(),
       /** Up to 5 task IDs (not titles) that were the focus of the session. */
-      tasksFocused: z7.array(z7.string()).max(5).optional()
+      tasksFocused: z10.array(z10.string()).max(5).optional()
     });
-    sessionJournalEntrySchema = z7.object({
+    sessionJournalEntrySchema = z10.object({
       // Identity
       /** Schema version for forward-compatibility. Always `'1.0'` in this release. */
-      schemaVersion: z7.literal(SESSION_JOURNAL_SCHEMA_VERSION),
+      schemaVersion: z10.literal(SESSION_JOURNAL_SCHEMA_VERSION),
       /** ISO 8601 timestamp when the entry was written. */
-      timestamp: z7.string(),
+      timestamp: z10.string(),
       /** CLEO session ID (e.g. `ses_20260424055456_ede571`). */
-      sessionId: z7.string(),
+      sessionId: z10.string(),
       /** Event type that triggered this journal entry. */
-      eventType: z7.enum(["session_start", "session_end", "observation", "decision", "error"]),
+      eventType: z10.enum(["session_start", "session_end", "observation", "decision", "error"]),
       // Session metadata (set on session_start / session_end)
       /** Agent identifier (e.g. `cleo-prime`, `claude-code`). */
-      agentIdentifier: z7.string().optional(),
+      agentIdentifier: z10.string().optional(),
       /** Provider adapter ID active for this session. */
-      providerId: z7.string().optional(),
+      providerId: z10.string().optional(),
       /** Session scope string (e.g. `'global'` or `'epic:T1263'`). */
-      scope: z7.string().optional(),
+      scope: z10.string().optional(),
       // Session-end fields
       /** Duration of the session in seconds (session_end only). */
-      duration: z7.number().int().nonnegative().optional(),
+      duration: z10.number().int().nonnegative().optional(),
       /** Task IDs (not titles) completed during the session. */
-      tasksCompleted: z7.array(z7.string()).optional(),
+      tasksCompleted: z10.array(z10.string()).optional(),
       // Doctor summary (T1262 absorbed)
       /** Compact result of `scanBrainNoise` run at session-end. */
       doctorSummary: sessionJournalDoctorSummarySchema.optional(),
@@ -1863,7 +2556,7 @@ var init_session_journal = __esm({
       debriefSummary: sessionJournalDebriefSummarySchema.optional(),
       // Optional hash chain
       /** SHA-256 hex of the previous entry's raw JSON string (for integrity chain). */
-      prevEntryHash: z7.string().optional()
+      prevEntryHash: z10.string().optional()
     });
   }
 });
@@ -1883,52 +2576,52 @@ var init_task = __esm({
 });
 
 // packages/contracts/src/task-evidence.ts
-import { z as z8 } from "zod";
+import { z as z11 } from "zod";
 var fileEvidenceSchema, logEvidenceSchema, screenshotEvidenceSchema, testOutputEvidenceSchema, commandOutputEvidenceSchema, taskEvidenceSchema;
 var init_task_evidence = __esm({
   "packages/contracts/src/task-evidence.ts"() {
     "use strict";
-    fileEvidenceSchema = z8.object({
-      kind: z8.literal("file"),
-      sha256: z8.string().length(64),
-      timestamp: z8.string().datetime(),
-      path: z8.string().min(1),
-      mime: z8.string().optional(),
-      description: z8.string().optional()
-    });
-    logEvidenceSchema = z8.object({
-      kind: z8.literal("log"),
-      sha256: z8.string().length(64),
-      timestamp: z8.string().datetime(),
-      source: z8.string().min(1),
-      description: z8.string().optional()
-    });
-    screenshotEvidenceSchema = z8.object({
-      kind: z8.literal("screenshot"),
-      sha256: z8.string().length(64),
-      timestamp: z8.string().datetime(),
-      mime: z8.enum(["image/png", "image/jpeg", "image/webp"]).optional(),
-      description: z8.string().optional()
-    });
-    testOutputEvidenceSchema = z8.object({
-      kind: z8.literal("test-output"),
-      sha256: z8.string().length(64),
-      timestamp: z8.string().datetime(),
-      passed: z8.number().int().nonnegative(),
-      failed: z8.number().int().nonnegative(),
-      skipped: z8.number().int().nonnegative(),
-      exitCode: z8.number().int(),
-      description: z8.string().optional()
-    });
-    commandOutputEvidenceSchema = z8.object({
-      kind: z8.literal("command-output"),
-      sha256: z8.string().length(64),
-      timestamp: z8.string().datetime(),
-      cmd: z8.string().min(1),
-      exitCode: z8.number().int(),
-      description: z8.string().optional()
-    });
-    taskEvidenceSchema = z8.discriminatedUnion("kind", [
+    fileEvidenceSchema = z11.object({
+      kind: z11.literal("file"),
+      sha256: z11.string().length(64),
+      timestamp: z11.string().datetime(),
+      path: z11.string().min(1),
+      mime: z11.string().optional(),
+      description: z11.string().optional()
+    });
+    logEvidenceSchema = z11.object({
+      kind: z11.literal("log"),
+      sha256: z11.string().length(64),
+      timestamp: z11.string().datetime(),
+      source: z11.string().min(1),
+      description: z11.string().optional()
+    });
+    screenshotEvidenceSchema = z11.object({
+      kind: z11.literal("screenshot"),
+      sha256: z11.string().length(64),
+      timestamp: z11.string().datetime(),
+      mime: z11.enum(["image/png", "image/jpeg", "image/webp"]).optional(),
+      description: z11.string().optional()
+    });
+    testOutputEvidenceSchema = z11.object({
+      kind: z11.literal("test-output"),
+      sha256: z11.string().length(64),
+      timestamp: z11.string().datetime(),
+      passed: z11.number().int().nonnegative(),
+      failed: z11.number().int().nonnegative(),
+      skipped: z11.number().int().nonnegative(),
+      exitCode: z11.number().int(),
+      description: z11.string().optional()
+    });
+    commandOutputEvidenceSchema = z11.object({
+      kind: z11.literal("command-output"),
+      sha256: z11.string().length(64),
+      timestamp: z11.string().datetime(),
+      cmd: z11.string().min(1),
+      exitCode: z11.number().int(),
+      description: z11.string().optional()
+    });
+    taskEvidenceSchema = z11.discriminatedUnion("kind", [
       fileEvidenceSchema,
       logEvidenceSchema,
       screenshotEvidenceSchema,
@@ -1939,12 +2632,12 @@ var init_task_evidence = __esm({
 });
 
 // packages/contracts/src/tasks/archive.ts
-import { z as z9 } from "zod";
+import { z as z12 } from "zod";
 var ArchiveReason, ARCHIVE_REASON_VALUES;
 var init_archive = __esm({
   "packages/contracts/src/tasks/archive.ts"() {
     "use strict";
-    ArchiveReason = z9.enum([
+    ArchiveReason = z12.enum([
       "verified",
       "reconciled",
       "superseded",
@@ -1956,6 +2649,67 @@ var init_archive = __esm({
   }
 });
 
+// packages/contracts/src/templates/manifest.ts
+import { z as z13 } from "zod";
+var TEMPLATE_KINDS, TEMPLATE_SUBSTITUTIONS, TEMPLATE_UPDATE_STRATEGIES, PLACEHOLDER_SOURCES, PlaceholderSpecSchema, TemplateManifestEntrySchema;
+var init_manifest2 = __esm({
+  "packages/contracts/src/templates/manifest.ts"() {
+    "use strict";
+    TEMPLATE_KINDS = ["workflow", "config", "agent", "skill", "provider", "doc"];
+    TEMPLATE_SUBSTITUTIONS = ["regex-tmpl", "static", "json-merge"];
+    TEMPLATE_UPDATE_STRATEGIES = [
+      "overwrite-on-bump",
+      "diff-prompt",
+      "immutable",
+      "manifest-merge"
+    ];
+    PLACEHOLDER_SOURCES = [
+      "project-context",
+      "project-info",
+      ".cleo/config",
+      "~/.cleo/config",
+      "tool-resolver",
+      "literal"
+    ];
+    PlaceholderSpecSchema = z13.object({
+      /**
+       * Placeholder identifier as it appears in the template body
+       * (e.g. `NODE_VERSION` matches `{{NODE_VERSION}}`).
+       */
+      name: z13.string().min(1, "placeholder name must be non-empty"),
+      /** Resolver source the installer consults for this placeholder. */
+      source: z13.enum(PLACEHOLDER_SOURCES),
+      /**
+       * Path expression evaluated against `source` (e.g. `engines.node` against
+       * `project-context`, `defaults.branchModel` against `.cleo/config`).
+       * For `literal` source, this MAY be the literal value's identifier.
+       */
+      sourcePath: z13.string().min(1, "placeholder sourcePath must be non-empty"),
+      /**
+       * Fallback value used when `source[sourcePath]` resolves to `undefined`.
+       * `null` is permitted to explicitly mark "no default — failure required".
+       */
+      defaultValue: z13.union([z13.string(), z13.number(), z13.boolean(), z13.null()]).optional()
+    });
+    TemplateManifestEntrySchema = z13.object({
+      /** Stable identifier for this template entry. */
+      id: z13.string().min(1, "id must be non-empty"),
+      /** Category of file this template represents. */
+      kind: z13.enum(TEMPLATE_KINDS),
+      /** Repo-relative path of the template source file. */
+      sourcePath: z13.string().min(1, "sourcePath must be non-empty"),
+      /** Project-relative path where the rendered template installs. */
+      installPath: z13.string().min(1, "installPath must be non-empty"),
+      /** Substitution strategy the installer applies to `sourcePath`. */
+      substitution: z13.enum(TEMPLATE_SUBSTITUTIONS),
+      /** Declared placeholders this template requires. May be empty. */
+      placeholders: z13.array(PlaceholderSpecSchema),
+      /** Reconciliation policy on upgrade. */
+      updateStrategy: z13.enum(TEMPLATE_UPDATE_STRATEGIES)
+    });
+  }
+});
+
 // packages/contracts/src/index.ts
 var init_src = __esm({
   "packages/contracts/src/index.ts"() {
@@ -1965,18 +2719,22 @@ var init_src = __esm({
     init_branch_lock();
     init_changesets();
     init_cli_category();
+    init_manifest();
     init_credentials();
     init_db_inventory2();
     init_identity();
     init_operations_registry();
+    init_provenance();
     init_docs_taxonomy();
     init_engine_result();
     init_enums();
     init_errors();
+    init_evidence_atom_schema();
     init_evidence_record_schema();
     init_exit_codes();
     init_facade();
     init_graph();
+    init_invariants();
     init_lafs();
     init_plugin_llm();
     init_observe();
@@ -1993,6 +2751,7 @@ var init_src = __esm({
     init_task();
     init_task_evidence();
     init_archive();
+    init_manifest2();
   }
 });
 
@@ -16012,7 +16771,7 @@ function resolveRef(ref, ctx) {
 function convertBaseSchema(schema, ctx) {
   if (schema.not !== void 0) {
     if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) {
-      return z10.never();
+      return z14.never();
     }
     throw new Error("not is not supported in Zod (except { not: {} } for never)");
   }
@@ -16034,7 +16793,7 @@ function convertBaseSchema(schema, ctx) {
       return ctx.refs.get(refPath);
     }
     if (ctx.processing.has(refPath)) {
-      return z10.lazy(() => {
+      return z14.lazy(() => {
         if (!ctx.refs.has(refPath)) {
           throw new Error(`Circular reference not resolved: ${refPath}`);
         }
@@ -16051,25 +16810,25 @@ function convertBaseSchema(schema, ctx) {
   if (schema.enum !== void 0) {
     const enumValues = schema.enum;
     if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
-      return z10.null();
+      return z14.null();
     }
     if (enumValues.length === 0) {
-      return z10.never();
+      return z14.never();
     }
     if (enumValues.length === 1) {
-      return z10.literal(enumValues[0]);
+      return z14.literal(enumValues[0]);
     }
     if (enumValues.every((v) => typeof v === "string")) {
-      return z10.enum(enumValues);
+      return z14.enum(enumValues);
     }
-    const literalSchemas = enumValues.map((v) => z10.literal(v));
+    const literalSchemas = enumValues.map((v) => z14.literal(v));
     if (literalSchemas.length < 2) {
       return literalSchemas[0];
     }
-    return z10.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
+    return z14.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
   }
   if (schema.const !== void 0) {
-    return z10.literal(schema.const);
+    return z14.literal(schema.const);
   }
   const type = schema.type;
   if (Array.isArray(type)) {
@@ -16078,68 +16837,68 @@ function convertBaseSchema(schema, ctx) {
       return convertBaseSchema(typeSchema, ctx);
     });
     if (typeSchemas.length === 0) {
-      return z10.never();
+      return z14.never();
     }
     if (typeSchemas.length === 1) {
       return typeSchemas[0];
     }
-    return z10.union(typeSchemas);
+    return z14.union(typeSchemas);
   }
   if (!type) {
-    return z10.any();
+    return z14.any();
   }
   let zodSchema2;
   switch (type) {
     case "string": {
-      let stringSchema = z10.string();
+      let stringSchema = z14.string();
       if (schema.format) {
         const format = schema.format;
         if (format === "email") {
-          stringSchema = stringSchema.check(z10.email());
+          stringSchema = stringSchema.check(z14.email());
         } else if (format === "uri" || format === "uri-reference") {
-          stringSchema = stringSchema.check(z10.url());
+          stringSchema = stringSchema.check(z14.url());
         } else if (format === "uuid" || format === "guid") {
-          stringSchema = stringSchema.check(z10.uuid());
+          stringSchema = stringSchema.check(z14.uuid());
         } else if (format === "date-time") {
-          stringSchema = stringSchema.check(z10.iso.datetime());
+          stringSchema = stringSchema.check(z14.iso.datetime());
         } else if (format === "date") {
-          stringSchema = stringSchema.check(z10.iso.date());
+          stringSchema = stringSchema.check(z14.iso.date());
         } else if (format === "time") {
-          stringSchema = stringSchema.check(z10.iso.time());
+          stringSchema = stringSchema.check(z14.iso.time());
         } else if (format === "duration") {
-          stringSchema = stringSchema.check(z10.iso.duration());
+          stringSchema = stringSchema.check(z14.iso.duration());
         } else if (format === "ipv4") {
-          stringSchema = stringSchema.check(z10.ipv4());
+          stringSchema = stringSchema.check(z14.ipv4());
         } else if (format === "ipv6") {
-          stringSchema = stringSchema.check(z10.ipv6());
+          stringSchema = stringSchema.check(z14.ipv6());
         } else if (format === "mac") {
-          stringSchema = stringSchema.check(z10.mac());
+          stringSchema = stringSchema.check(z14.mac());
         } else if (format === "cidr") {
-          stringSchema = stringSchema.check(z10.cidrv4());
+          stringSchema = stringSchema.check(z14.cidrv4());
         } else if (format === "cidr-v6") {
-          stringSchema = stringSchema.check(z10.cidrv6());
+          stringSchema = stringSchema.check(z14.cidrv6());
         } else if (format === "base64") {
-          stringSchema = stringSchema.check(z10.base64());
+          stringSchema = stringSchema.check(z14.base64());
         } else if (format === "base64url") {
-          stringSchema = stringSchema.check(z10.base64url());
+          stringSchema = stringSchema.check(z14.base64url());
         } else if (format === "e164") {
-          stringSchema = stringSchema.check(z10.e164());
+          stringSchema = stringSchema.check(z14.e164());
         } else if (format === "jwt") {
-          stringSchema = stringSchema.check(z10.jwt());
+          stringSchema = stringSchema.check(z14.jwt());
         } else if (format === "emoji") {
-          stringSchema = stringSchema.check(z10.emoji());
+          stringSchema = stringSchema.check(z14.emoji());
         } else if (format === "nanoid") {
-          stringSchema = stringSchema.check(z10.nanoid());
+          stringSchema = stringSchema.check(z14.nanoid());
         } else if (format === "cuid") {
-          stringSchema = stringSchema.check(z10.cuid());
+          stringSchema = stringSchema.check(z14.cuid());
         } else if (format === "cuid2") {
-          stringSchema = stringSchema.check(z10.cuid2());
+          stringSchema = stringSchema.check(z14.cuid2());
         } else if (format === "ulid") {
-          stringSchema = stringSchema.check(z10.ulid());
+          stringSchema = stringSchema.check(z14.ulid());
         } else if (format === "xid") {
-          stringSchema = stringSchema.check(z10.xid());
+          stringSchema = stringSchema.check(z14.xid());
         } else if (format === "ksuid") {
-          stringSchema = stringSchema.check(z10.ksuid());
+          stringSchema = stringSchema.check(z14.ksuid());
         }
       }
       if (typeof schema.minLength === "number") {
@@ -16156,7 +16915,7 @@ function convertBaseSchema(schema, ctx) {
     }
     case "number":
     case "integer": {
-      let numberSchema = type === "integer" ? z10.number().int() : z10.number();
+      let numberSchema = type === "integer" ? z14.number().int() : z14.number();
       if (typeof schema.minimum === "number") {
         numberSchema = numberSchema.min(schema.minimum);
       }
@@ -16180,11 +16939,11 @@ function convertBaseSchema(schema, ctx) {
       break;
     }
     case "boolean": {
-      zodSchema2 = z10.boolean();
+      zodSchema2 = z14.boolean();
       break;
     }
     case "null": {
-      zodSchema2 = z10.null();
+      zodSchema2 = z14.null();
       break;
     }
     case "object": {
@@ -16197,14 +16956,14 @@ function convertBaseSchema(schema, ctx) {
       }
       if (schema.propertyNames) {
         const keySchema = convertSchema(schema.propertyNames, ctx);
-        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z10.any();
+        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z14.any();
         if (Object.keys(shape).length === 0) {
-          zodSchema2 = z10.record(keySchema, valueSchema);
+          zodSchema2 = z14.record(keySchema, valueSchema);
           break;
         }
-        const objectSchema2 = z10.object(shape).passthrough();
-        const recordSchema = z10.looseRecord(keySchema, valueSchema);
-        zodSchema2 = z10.intersection(objectSchema2, recordSchema);
+        const objectSchema2 = z14.object(shape).passthrough();
+        const recordSchema = z14.looseRecord(keySchema, valueSchema);
+        zodSchema2 = z14.intersection(objectSchema2, recordSchema);
         break;
       }
       if (schema.patternProperties) {
@@ -16213,28 +16972,28 @@ function convertBaseSchema(schema, ctx) {
         const looseRecords = [];
         for (const pattern of patternKeys) {
           const patternValue = convertSchema(patternProps[pattern], ctx);
-          const keySchema = z10.string().regex(new RegExp(pattern));
-          looseRecords.push(z10.looseRecord(keySchema, patternValue));
+          const keySchema = z14.string().regex(new RegExp(pattern));
+          looseRecords.push(z14.looseRecord(keySchema, patternValue));
         }
         const schemasToIntersect = [];
         if (Object.keys(shape).length > 0) {
-          schemasToIntersect.push(z10.object(shape).passthrough());
+          schemasToIntersect.push(z14.object(shape).passthrough());
         }
         schemasToIntersect.push(...looseRecords);
         if (schemasToIntersect.length === 0) {
-          zodSchema2 = z10.object({}).passthrough();
+          zodSchema2 = z14.object({}).passthrough();
         } else if (schemasToIntersect.length === 1) {
           zodSchema2 = schemasToIntersect[0];
         } else {
-          let result = z10.intersection(schemasToIntersect[0], schemasToIntersect[1]);
+          let result = z14.intersection(schemasToIntersect[0], schemasToIntersect[1]);
           for (let i = 2; i < schemasToIntersect.length; i++) {
-            result = z10.intersection(result, schemasToIntersect[i]);
+            result = z14.intersection(result, schemasToIntersect[i]);
           }
           zodSchema2 = result;
         }
         break;
       }
-      const objectSchema = z10.object(shape);
+      const objectSchema = z14.object(shape);
       if (schema.additionalProperties === false) {
         zodSchema2 = objectSchema.strict();
       } else if (typeof schema.additionalProperties === "object") {
@@ -16251,33 +17010,33 @@ function convertBaseSchema(schema, ctx) {
         const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
         const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : void 0;
         if (rest) {
-          zodSchema2 = z10.tuple(tupleItems).rest(rest);
+          zodSchema2 = z14.tuple(tupleItems).rest(rest);
         } else {
-          zodSchema2 = z10.tuple(tupleItems);
+          zodSchema2 = z14.tuple(tupleItems);
         }
         if (typeof schema.minItems === "number") {
-          zodSchema2 = zodSchema2.check(z10.minLength(schema.minItems));
+          zodSchema2 = zodSchema2.check(z14.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema2 = zodSchema2.check(z10.maxLength(schema.maxItems));
+          zodSchema2 = zodSchema2.check(z14.maxLength(schema.maxItems));
         }
       } else if (Array.isArray(items)) {
         const tupleItems = items.map((item) => convertSchema(item, ctx));
         const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx) : void 0;
         if (rest) {
-          zodSchema2 = z10.tuple(tupleItems).rest(rest);
+          zodSchema2 = z14.tuple(tupleItems).rest(rest);
         } else {
-          zodSchema2 = z10.tuple(tupleItems);
+          zodSchema2 = z14.tuple(tupleItems);
         }
         if (typeof schema.minItems === "number") {
-          zodSchema2 = zodSchema2.check(z10.minLength(schema.minItems));
+          zodSchema2 = zodSchema2.check(z14.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema2 = zodSchema2.check(z10.maxLength(schema.maxItems));
+          zodSchema2 = zodSchema2.check(z14.maxLength(schema.maxItems));
         }
       } else if (items !== void 0) {
         const element = convertSchema(items, ctx);
-        let arraySchema = z10.array(element);
+        let arraySchema = z14.array(element);
         if (typeof schema.minItems === "number") {
           arraySchema = arraySchema.min(schema.minItems);
         }
@@ -16286,7 +17045,7 @@ function convertBaseSchema(schema, ctx) {
         }
         zodSchema2 = arraySchema;
       } else {
-        zodSchema2 = z10.array(z10.any());
+        zodSchema2 = z14.array(z14.any());
       }
       break;
     }
@@ -16303,37 +17062,37 @@ function convertBaseSchema(schema, ctx) {
 }
 function convertSchema(schema, ctx) {
   if (typeof schema === "boolean") {
-    return schema ? z10.any() : z10.never();
+    return schema ? z14.any() : z14.never();
   }
   let baseSchema = convertBaseSchema(schema, ctx);
   const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
   if (schema.anyOf && Array.isArray(schema.anyOf)) {
     const options = schema.anyOf.map((s) => convertSchema(s, ctx));
-    const anyOfUnion = z10.union(options);
-    baseSchema = hasExplicitType ? z10.intersection(baseSchema, anyOfUnion) : anyOfUnion;
+    const anyOfUnion = z14.union(options);
+    baseSchema = hasExplicitType ? z14.intersection(baseSchema, anyOfUnion) : anyOfUnion;
   }
   if (schema.oneOf && Array.isArray(schema.oneOf)) {
     const options = schema.oneOf.map((s) => convertSchema(s, ctx));
-    const oneOfUnion = z10.xor(options);
-    baseSchema = hasExplicitType ? z10.intersection(baseSchema, oneOfUnion) : oneOfUnion;
+    const oneOfUnion = z14.xor(options);
+    baseSchema = hasExplicitType ? z14.intersection(baseSchema, oneOfUnion) : oneOfUnion;
   }
   if (schema.allOf && Array.isArray(schema.allOf)) {
     if (schema.allOf.length === 0) {
-      baseSchema = hasExplicitType ? baseSchema : z10.any();
+      baseSchema = hasExplicitType ? baseSchema : z14.any();
     } else {
       let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
       const startIdx = hasExplicitType ? 0 : 1;
       for (let i = startIdx; i < schema.allOf.length; i++) {
-        result = z10.intersection(result, convertSchema(schema.allOf[i], ctx));
+        result = z14.intersection(result, convertSchema(schema.allOf[i], ctx));
       }
       baseSchema = result;
     }
   }
   if (schema.nullable === true && ctx.version === "openapi-3.0") {
-    baseSchema = z10.nullable(baseSchema);
+    baseSchema = z14.nullable(baseSchema);
   }
   if (schema.readOnly === true) {
-    baseSchema = z10.readonly(baseSchema);
+    baseSchema = z14.readonly(baseSchema);
   }
   const extraMeta = {};
   const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
@@ -16360,7 +17119,7 @@ function convertSchema(schema, ctx) {
 }
 function fromJSONSchema(schema, params) {
   if (typeof schema === "boolean") {
-    return schema ? z10.any() : z10.never();
+    return schema ? z14.any() : z14.never();
   }
   const version2 = detectVersion(schema, params?.defaultTarget);
   const defs = schema.$defs || schema.definitions || {};
@@ -16374,14 +17133,14 @@ function fromJSONSchema(schema, params) {
   };
   return convertSchema(schema, ctx);
 }
-var z10, RECOGNIZED_KEYS;
+var z14, RECOGNIZED_KEYS;
 var init_from_json_schema = __esm({
   "node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/from-json-schema.js"() {
     init_registries();
     init_checks2();
     init_iso();
     init_schemas2();
-    z10 = {
+    z14 = {
       ...schemas_exports2,
       ...checks_exports2,
       iso: iso_exports