@cleocode/adapters 2026.6.6 → 2026.6.8

package/dist/index.js

@@ -8396,7 +8396,7 @@ var init_operations_registry = __esm({
         gateway: "mutate",
         domain: "docs",
         operation: "add",
-        description: "docs.add (mutate) \u2014 attach a local file or URL to a CLEO owner entity (task, session, observation)",
+        description: "docs.add (mutate) \u2014 attach a local file, URL, or inline content to a CLEO owner entity (task, session, observation)",
         tier: 1,
         idempotent: false,
         sessionRequired: false,
@@ -8420,6 +8420,12 @@ var init_operations_registry = __esm({
             required: false,
             description: "Remote URL to attach"
           },
+          {
+            name: "content",
+            type: "string",
+            required: false,
+            description: "Inline document body (T10965); mutually exclusive with file/url"
+          },
           {
             name: "desc",
             type: "string",
@@ -10126,7 +10132,8 @@ var init_provenance = __esm({
       "superseded-by",
       "related-task",
       "linked-decision",
-      "derived-from"
+      "derived-from",
+      "shares-topic"
     ];
     DOC_LIFECYCLE_STATUSES = [
       "active",
@@ -10201,6 +10208,41 @@ var init_provenance = __esm({
   }
 });
 
+// packages/contracts/src/docs/read.ts
+import { z as z8 } from "zod";
+var docFrontmatterSchema, docBodySchema, docReadResponseSchema;
+var init_read = __esm({
+  "packages/contracts/src/docs/read.ts"() {
+    "use strict";
+    docFrontmatterSchema = z8.object({
+      slug: z8.string(),
+      kind: z8.string().nullable(),
+      title: z8.string().nullable(),
+      summary: z8.string().nullable(),
+      lifecycleStatus: z8.string(),
+      docVersion: z8.number().int(),
+      ownerVersion: z8.string().nullable(),
+      supersedes: z8.string().nullable(),
+      supersededBy: z8.string().nullable(),
+      topics: z8.array(z8.string()).readonly(),
+      relatedTasks: z8.array(z8.string()).readonly(),
+      sha256: z8.string(),
+      createdAt: z8.string()
+    });
+    docBodySchema = z8.object({
+      encoding: z8.enum(["utf-8", "base64"]),
+      text: z8.string().optional(),
+      base64: z8.string().optional(),
+      sizeBytes: z8.number().int().nonnegative(),
+      mimeType: z8.string().nullable()
+    });
+    docReadResponseSchema = z8.object({
+      frontmatter: docFrontmatterSchema,
+      body: docBodySchema
+    });
+  }
+});
+
 // packages/contracts/src/engine-result.ts
 var init_engine_result = __esm({
   "packages/contracts/src/engine-result.ts"() {
@@ -10254,72 +10296,72 @@ var init_errors = __esm({
 });
 
 // packages/contracts/src/evidence-atom-schema.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var commitAtomSchema, filesAtomSchema, testRunAtomSchema, toolAtomSchema, urlAtomSchema, noteAtomSchema, decisionAtomSchema, prAtomSchema, locDropAtomSchema, callsiteCoverageAtomSchema, AC_UUID_REGEX, AC_ALIAS_REGEX, SATISFIES_TASK_ID_REGEX, SATISFIES_VERSION_PIN_REGEX, satisfiesAtomSchema, EvidenceAtomSchema, GATE_EVIDENCE_REQUIREMENTS, ATOM_EXAMPLES;
 var init_evidence_atom_schema = __esm({
   "packages/contracts/src/evidence-atom-schema.ts"() {
     "use strict";
-    commitAtomSchema = z8.object({
-      kind: z8.literal("commit"),
-      sha: z8.string().regex(/^[0-9a-f]{7,40}$/i, "commit sha must be 7-40 hex characters")
+    commitAtomSchema = z9.object({
+      kind: z9.literal("commit"),
+      sha: z9.string().regex(/^[0-9a-f]{7,40}$/i, "commit sha must be 7-40 hex characters")
     });
-    filesAtomSchema = z8.object({
-      kind: z8.literal("files"),
-      paths: z8.array(z8.string().min(1)).min(1, "files atom requires at least one path")
+    filesAtomSchema = z9.object({
+      kind: z9.literal("files"),
+      paths: z9.array(z9.string().min(1)).min(1, "files atom requires at least one path")
     });
-    testRunAtomSchema = z8.object({
-      kind: z8.literal("test-run"),
-      path: z8.string().min(1, "test-run atom requires a non-empty path")
+    testRunAtomSchema = z9.object({
+      kind: z9.literal("test-run"),
+      path: z9.string().min(1, "test-run atom requires a non-empty path")
     });
-    toolAtomSchema = z8.object({
-      kind: z8.literal("tool"),
-      tool: z8.string().min(1, "tool atom requires a non-empty tool name")
+    toolAtomSchema = z9.object({
+      kind: z9.literal("tool"),
+      tool: z9.string().min(1, "tool atom requires a non-empty tool name")
     });
-    urlAtomSchema = z8.object({
-      kind: z8.literal("url"),
-      url: z8.string().min(1).regex(/^https?:\/\//, "url atom must start with http:// or https://")
+    urlAtomSchema = z9.object({
+      kind: z9.literal("url"),
+      url: z9.string().min(1).regex(/^https?:\/\//, "url atom must start with http:// or https://")
     });
-    noteAtomSchema = z8.object({
-      kind: z8.literal("note"),
-      note: z8.string().min(1, "note atom must be non-empty").max(512, "note atom is too long (max 512 chars)")
+    noteAtomSchema = z9.object({
+      kind: z9.literal("note"),
+      note: z9.string().min(1, "note atom must be non-empty").max(512, "note atom is too long (max 512 chars)")
     });
-    decisionAtomSchema = z8.object({
-      kind: z8.literal("decision"),
-      decisionId: z8.string().min(1, "decision atom requires a non-empty decision ID")
+    decisionAtomSchema = z9.object({
+      kind: z9.literal("decision"),
+      decisionId: z9.string().min(1, "decision atom requires a non-empty decision ID")
     });
-    prAtomSchema = z8.object({
-      kind: z8.literal("pr"),
-      prNumber: z8.number().int().positive("pr atom requires a positive integer PR number")
+    prAtomSchema = z9.object({
+      kind: z9.literal("pr"),
+      prNumber: z9.number().int().positive("pr atom requires a positive integer PR number")
     });
-    locDropAtomSchema = z8.object({
-      kind: z8.literal("loc-drop"),
-      fromLines: z8.number().int().nonnegative("loc-drop fromLines must be \u2265 0"),
-      toLines: z8.number().int().nonnegative("loc-drop toLines must be \u2265 0")
+    locDropAtomSchema = z9.object({
+      kind: z9.literal("loc-drop"),
+      fromLines: z9.number().int().nonnegative("loc-drop fromLines must be \u2265 0"),
+      toLines: z9.number().int().nonnegative("loc-drop toLines must be \u2265 0")
     });
-    callsiteCoverageAtomSchema = z8.object({
-      kind: z8.literal("callsite-coverage"),
-      symbolName: z8.string().min(1, "callsite-coverage atom requires a non-empty symbolName"),
-      relativeSourcePath: z8.string().min(1, "callsite-coverage atom requires a non-empty relativeSourcePath")
+    callsiteCoverageAtomSchema = z9.object({
+      kind: z9.literal("callsite-coverage"),
+      symbolName: z9.string().min(1, "callsite-coverage atom requires a non-empty symbolName"),
+      relativeSourcePath: z9.string().min(1, "callsite-coverage atom requires a non-empty relativeSourcePath")
     });
     AC_UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[45][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
     AC_ALIAS_REGEX = /^AC[0-9]{1,4}$/;
     SATISFIES_TASK_ID_REGEX = /^T[0-9]{1,7}$/;
     SATISFIES_VERSION_PIN_REGEX = /^[0-9]{14}$/;
-    satisfiesAtomSchema = z8.object({
-      kind: z8.literal("satisfies"),
+    satisfiesAtomSchema = z9.object({
+      kind: z9.literal("satisfies"),
       /** Target task ID — `T<1-7 digits>` per ADR-079-r2 §2.1. */
-      targetTaskId: z8.string().regex(SATISFIES_TASK_ID_REGEX, "satisfies atom targetTaskId must match /^T[0-9]{1,7}$/"),
+      targetTaskId: z9.string().regex(SATISFIES_TASK_ID_REGEX, "satisfies atom targetTaskId must match /^T[0-9]{1,7}$/"),
       /** Lowercase UUIDv4/v5 — populated for the canonical form; undefined for alias form. */
-      targetAcId: z8.string().regex(AC_UUID_REGEX, "satisfies atom targetAcId must be a lowercase UUIDv4/v5").optional(),
+      targetAcId: z9.string().regex(AC_UUID_REGEX, "satisfies atom targetAcId must be a lowercase UUIDv4/v5").optional(),
       /** Positional alias `AC<1-4 digits>` — populated for alias form; undefined for UUID form. */
-      targetAcAlias: z8.string().regex(AC_ALIAS_REGEX, "satisfies atom targetAcAlias must match /^AC[0-9]{1,4}$/").optional(),
+      targetAcAlias: z9.string().regex(AC_ALIAS_REGEX, "satisfies atom targetAcAlias must match /^AC[0-9]{1,4}$/").optional(),
       /** Optional `@<14-digit YYYYMMDDhhmmss>` pin captured at mint time. */
-      versionPin: z8.string().regex(
+      versionPin: z9.string().regex(
         SATISFIES_VERSION_PIN_REGEX,
         "satisfies atom versionPin must be 14 digits (YYYYMMDDhhmmss)"
       ).optional()
     });
-    EvidenceAtomSchema = z8.discriminatedUnion("kind", [
+    EvidenceAtomSchema = z9.discriminatedUnion("kind", [
       commitAtomSchema,
       filesAtomSchema,
       testRunAtomSchema,
@@ -10366,58 +10408,58 @@ var init_evidence_atom_schema = __esm({
 });
 
 // packages/contracts/src/evidence-record-schema.ts
-import { z as z9 } from "zod";
+import { z as z10 } 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 = z9.object({
+    evidenceBaseSchema = z10.object({
       /** Identity string of the agent that produced this record. */
-      agentIdentity: z9.string().min(1),
+      agentIdentity: z10.string().min(1),
       /** SHA-256 hex digest (64 chars) of the attached artifact. */
-      attachmentSha256: z9.string().length(64),
+      attachmentSha256: z10.string().length(64),
       /** ISO 8601 timestamp at which the action ran. */
-      ranAt: z9.string().datetime(),
+      ranAt: z10.string().datetime(),
       /** Wall-clock duration of the action in milliseconds. */
-      durationMs: z9.number().nonnegative()
+      durationMs: z10.number().nonnegative()
     });
     implDiffRecordSchema = evidenceBaseSchema.extend({
-      kind: z9.literal("impl-diff"),
-      phase: z9.literal("implement"),
-      filesChanged: z9.array(z9.string().min(1)).min(1),
-      linesAdded: z9.number().int().nonnegative(),
-      linesRemoved: z9.number().int().nonnegative()
+      kind: z10.literal("impl-diff"),
+      phase: z10.literal("implement"),
+      filesChanged: z10.array(z10.string().min(1)).min(1),
+      linesAdded: z10.number().int().nonnegative(),
+      linesRemoved: z10.number().int().nonnegative()
     });
     validateSpecCheckRecordSchema = evidenceBaseSchema.extend({
-      kind: z9.literal("validate-spec-check"),
-      phase: z9.literal("validate"),
-      reqIdsChecked: z9.array(z9.string().min(1)).min(1),
-      passed: z9.boolean(),
-      details: z9.string().min(1)
+      kind: z10.literal("validate-spec-check"),
+      phase: z10.literal("validate"),
+      reqIdsChecked: z10.array(z10.string().min(1)).min(1),
+      passed: z10.boolean(),
+      details: z10.string().min(1)
     });
     testOutputRecordSchema = evidenceBaseSchema.extend({
-      kind: z9.literal("test-output"),
-      phase: z9.literal("test"),
-      command: z9.string().min(1),
-      exitCode: z9.number().int(),
-      testsPassed: z9.number().int().nonnegative(),
-      testsFailed: z9.number().int().nonnegative()
+      kind: z10.literal("test-output"),
+      phase: z10.literal("test"),
+      command: z10.string().min(1),
+      exitCode: z10.number().int(),
+      testsPassed: z10.number().int().nonnegative(),
+      testsFailed: z10.number().int().nonnegative()
     });
     lintReportRecordSchema = evidenceBaseSchema.extend({
-      kind: z9.literal("lint-report"),
-      phase: z9.enum(["implement", "test"]),
-      tool: z9.string().min(1),
-      passed: z9.boolean(),
-      warnings: z9.number().int().nonnegative(),
-      errors: z9.number().int().nonnegative()
+      kind: z10.literal("lint-report"),
+      phase: z10.enum(["implement", "test"]),
+      tool: z10.string().min(1),
+      passed: z10.boolean(),
+      warnings: z10.number().int().nonnegative(),
+      errors: z10.number().int().nonnegative()
     });
     commandOutputRecordSchema = evidenceBaseSchema.extend({
-      kind: z9.literal("command-output"),
-      phase: z9.enum(["implement", "validate", "test"]),
-      cmd: z9.string().min(1),
-      exitCode: z9.number().int()
+      kind: z10.literal("command-output"),
+      phase: z10.enum(["implement", "validate", "test"]),
+      cmd: z10.string().min(1),
+      exitCode: z10.number().int()
     });
-    evidenceRecordSchema = z9.discriminatedUnion("kind", [
+    evidenceRecordSchema = z10.discriminatedUnion("kind", [
       implDiffRecordSchema,
       validateSpecCheckRecordSchema,
       testOutputRecordSchema,
@@ -10973,7 +11015,7 @@ var init_status_registry = __esm({
 });
 
 // packages/contracts/src/workgraph.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var E_WORKGRAPH_PARENT_TYPE_MATRIX, taskTypeSchema, taskPrioritySchema, taskStatusSchema, verificationGateSchema, workGraphRelationKindSchema, workGraphTraversalDirectionSchema, workGraphEdgeDirectionSchema, paginationParamsSchema, workGraphNodeSchema, workGraphEdgeSchema, workGraphHierarchyEdgeSchema, workGraphPageInfoSchema, workGraphRollupCountsSchema, workGraphSubtreePercentagesSchema, workGraphProjectionMismatchSchema, workGraphReadyFrontierTaskSchema, workGraphRelationEdgeSchema, workGraphDependencyEdgeSchema, workGraphOmissionReasonSchema, workGraphContextBudgetSchema, workGraphOmissionSchema, workGraphDirectEdgeSchema, workGraphContextPackParamsSchema, workGraphSliceParamsSchema, workGraphSliceSchema, workGraphReadinessParamsSchema, workGraphReadinessResultSchema, workGraphContextPackSchema, workGraphScaffoldValidateParamsSchema, workGraphScaffoldValidationIssueSchema, workGraphScaffoldValidateResultSchema, workGraphScaffoldApplyParamsSchema, workGraphScaffoldApplyResultSchema, workGraphPlanningDocParamsSchema, workGraphPlanningDocSchema, tasksTraverseParamsSchema, tasksTraverseResultSchema, tasksTreeParamsSchema, tasksTreeResultSchema, tasksRollupParamsSchema, tasksRollupResultSchema, tasksFrontierParamsSchema, tasksFrontierResultSchema, tasksWorkGraphAuditParamsSchema, tasksWorkGraphAuditResultSchema;
 var init_workgraph = __esm({
   "packages/contracts/src/workgraph.ts"() {
@@ -10981,10 +11023,10 @@ var init_workgraph = __esm({
     init_enums();
     init_status_registry();
     E_WORKGRAPH_PARENT_TYPE_MATRIX = "E_WORKGRAPH_PARENT_TYPE_MATRIX";
-    taskTypeSchema = z10.enum(["saga", "epic", "task", "subtask"]);
-    taskPrioritySchema = z10.enum(["critical", "high", "medium", "low"]);
-    taskStatusSchema = z10.enum(TASK_STATUSES);
-    verificationGateSchema = z10.enum([
+    taskTypeSchema = z11.enum(["saga", "epic", "task", "subtask"]);
+    taskPrioritySchema = z11.enum(["critical", "high", "medium", "low"]);
+    taskStatusSchema = z11.enum(TASK_STATUSES);
+    verificationGateSchema = z11.enum([
       "implemented",
       "testsPassed",
       "qaPassed",
@@ -10993,7 +11035,7 @@ var init_workgraph = __esm({
       "documented",
       "nexusImpact"
     ]);
-    workGraphRelationKindSchema = z10.enum([
+    workGraphRelationKindSchema = z11.enum([
       "contains",
       "depends_on",
       "blocks",
@@ -11001,317 +11043,317 @@ var init_workgraph = __esm({
       "groups",
       "satisfies"
     ]);
-    workGraphTraversalDirectionSchema = z10.enum([
+    workGraphTraversalDirectionSchema = z11.enum([
       "ancestors",
       "descendants",
       "upstream",
       "downstream"
     ]);
-    workGraphEdgeDirectionSchema = z10.enum(["out", "in", "both"]);
-    paginationParamsSchema = z10.object({
-      cursor: z10.string().min(1).optional(),
-      limit: z10.number().int().positive().max(500).optional()
+    workGraphEdgeDirectionSchema = z11.enum(["out", "in", "both"]);
+    paginationParamsSchema = z11.object({
+      cursor: z11.string().min(1).optional(),
+      limit: z11.number().int().positive().max(500).optional()
     });
-    workGraphNodeSchema = z10.object({
-      id: z10.string().min(1),
+    workGraphNodeSchema = z11.object({
+      id: z11.string().min(1),
       type: taskTypeSchema,
-      title: z10.string(),
+      title: z11.string(),
       status: taskStatusSchema,
       priority: taskPrioritySchema,
-      parentId: z10.string().min(1).optional()
+      parentId: z11.string().min(1).optional()
     });
-    workGraphEdgeSchema = z10.object({
-      fromId: z10.string().min(1),
-      toId: z10.string().min(1),
+    workGraphEdgeSchema = z11.object({
+      fromId: z11.string().min(1),
+      toId: z11.string().min(1),
       kind: workGraphRelationKindSchema
     });
-    workGraphHierarchyEdgeSchema = z10.object({
-      fromId: z10.string().min(1),
-      toId: z10.string().min(1),
-      kind: z10.literal("contains")
+    workGraphHierarchyEdgeSchema = z11.object({
+      fromId: z11.string().min(1),
+      toId: z11.string().min(1),
+      kind: z11.literal("contains")
     }).strict();
-    workGraphPageInfoSchema = z10.object({
-      nextCursor: z10.string().min(1).optional(),
-      hasMore: z10.boolean()
-    });
-    workGraphRollupCountsSchema = z10.object({
-      total: z10.number().int().nonnegative(),
-      byStatus: z10.partialRecord(taskStatusSchema, z10.number().int().nonnegative()),
-      byType: z10.partialRecord(taskTypeSchema, z10.number().int().nonnegative())
-    });
-    workGraphSubtreePercentagesSchema = z10.object({
-      done: z10.number().nonnegative(),
-      active: z10.number().nonnegative(),
-      blocked: z10.number().nonnegative(),
-      pending: z10.number().nonnegative(),
-      cancelled: z10.number().nonnegative()
-    });
-    workGraphProjectionMismatchSchema = z10.object({
-      field: z10.string().min(1),
-      expected: z10.number().int().nonnegative(),
-      actual: z10.number().int().nonnegative()
+    workGraphPageInfoSchema = z11.object({
+      nextCursor: z11.string().min(1).optional(),
+      hasMore: z11.boolean()
+    });
+    workGraphRollupCountsSchema = z11.object({
+      total: z11.number().int().nonnegative(),
+      byStatus: z11.partialRecord(taskStatusSchema, z11.number().int().nonnegative()),
+      byType: z11.partialRecord(taskTypeSchema, z11.number().int().nonnegative())
+    });
+    workGraphSubtreePercentagesSchema = z11.object({
+      done: z11.number().nonnegative(),
+      active: z11.number().nonnegative(),
+      blocked: z11.number().nonnegative(),
+      pending: z11.number().nonnegative(),
+      cancelled: z11.number().nonnegative()
+    });
+    workGraphProjectionMismatchSchema = z11.object({
+      field: z11.string().min(1),
+      expected: z11.number().int().nonnegative(),
+      actual: z11.number().int().nonnegative()
     });
     workGraphReadyFrontierTaskSchema = workGraphNodeSchema.extend({
-      role: z10.string().min(1).optional(),
-      dependencyBlockers: z10.array(z10.object({ taskId: z10.string().min(1), status: taskStatusSchema })),
-      gateBlockers: z10.array(z10.object({ gate: verificationGateSchema }))
+      role: z11.string().min(1).optional(),
+      dependencyBlockers: z11.array(z11.object({ taskId: z11.string().min(1), status: taskStatusSchema })),
+      gateBlockers: z11.array(z11.object({ gate: verificationGateSchema }))
     });
     workGraphRelationEdgeSchema = workGraphEdgeSchema.extend({
-      source: z10.literal("relation"),
-      relationType: z10.enum(TASK_RELATION_TYPES),
-      reason: z10.string().min(1).optional()
+      source: z11.literal("relation"),
+      relationType: z11.enum(TASK_RELATION_TYPES),
+      reason: z11.string().min(1).optional()
     });
     workGraphDependencyEdgeSchema = workGraphEdgeSchema.extend({
-      source: z10.literal("dependency"),
-      kind: z10.literal("depends_on")
+      source: z11.literal("dependency"),
+      kind: z11.literal("depends_on")
     });
-    workGraphOmissionReasonSchema = z10.enum([
+    workGraphOmissionReasonSchema = z11.enum([
       "budget_exceeded",
       "not_requested",
       "not_available",
       "redacted",
       "truncated"
     ]);
-    workGraphContextBudgetSchema = z10.object({
-      tokenBudget: z10.number().int().nonnegative(),
-      estimatedTokens: z10.number().int().nonnegative(),
-      remainingTokens: z10.number().int().nonnegative(),
-      truncated: z10.boolean()
-    });
-    workGraphOmissionSchema = z10.object({
-      path: z10.string().min(1),
+    workGraphContextBudgetSchema = z11.object({
+      tokenBudget: z11.number().int().nonnegative(),
+      estimatedTokens: z11.number().int().nonnegative(),
+      remainingTokens: z11.number().int().nonnegative(),
+      truncated: z11.boolean()
+    });
+    workGraphOmissionSchema = z11.object({
+      path: z11.string().min(1),
       reason: workGraphOmissionReasonSchema,
-      message: z10.string().min(1),
-      estimatedTokens: z10.number().int().nonnegative().optional()
+      message: z11.string().min(1),
+      estimatedTokens: z11.number().int().nonnegative().optional()
     });
-    workGraphDirectEdgeSchema = z10.discriminatedUnion("source", [
+    workGraphDirectEdgeSchema = z11.discriminatedUnion("source", [
       workGraphRelationEdgeSchema,
       workGraphDependencyEdgeSchema
     ]);
     workGraphContextPackParamsSchema = paginationParamsSchema.extend({
-      rootId: z10.string().min(1),
-      tokenBudget: z10.number().int().positive().optional(),
-      includeRelations: z10.boolean().optional(),
-      includeReadiness: z10.boolean().optional(),
-      includeRollup: z10.boolean().optional()
+      rootId: z11.string().min(1),
+      tokenBudget: z11.number().int().positive().optional(),
+      includeRelations: z11.boolean().optional(),
+      includeReadiness: z11.boolean().optional(),
+      includeRollup: z11.boolean().optional()
     });
     workGraphSliceParamsSchema = paginationParamsSchema.extend({
-      rootId: z10.string().min(1),
+      rootId: z11.string().min(1),
       direction: workGraphTraversalDirectionSchema.optional(),
-      maxDepth: z10.number().int().nonnegative().optional(),
-      includeRelations: z10.boolean().optional()
+      maxDepth: z11.number().int().nonnegative().optional(),
+      includeRelations: z11.boolean().optional()
     });
-    workGraphSliceSchema = z10.object({
-      rootId: z10.string().min(1),
+    workGraphSliceSchema = z11.object({
+      rootId: z11.string().min(1),
       direction: workGraphTraversalDirectionSchema,
-      nodes: z10.array(workGraphNodeSchema),
-      edges: z10.array(workGraphEdgeSchema),
+      nodes: z11.array(workGraphNodeSchema),
+      edges: z11.array(workGraphEdgeSchema),
       pageInfo: workGraphPageInfoSchema,
-      omissions: z10.array(workGraphOmissionSchema).optional()
-    });
-    workGraphReadinessParamsSchema = z10.object({
-      rootId: z10.string().min(1),
-      role: z10.string().min(1).optional(),
-      includeGateBlockers: z10.boolean().optional()
-    });
-    workGraphReadinessResultSchema = z10.object({
-      rootId: z10.string().min(1),
-      role: z10.string().min(1).optional(),
-      ready: z10.boolean(),
-      warnings: z10.array(z10.string()),
-      groups: z10.object({
-        ready: z10.array(workGraphReadyFrontierTaskSchema),
-        blocked: z10.array(workGraphReadyFrontierTaskSchema),
-        blockedBy: z10.array(
-          z10.discriminatedUnion("kind", [
-            z10.object({
-              kind: z10.literal("dependency"),
-              blockerId: z10.string().min(1),
-              blocks: z10.array(z10.string().min(1))
+      omissions: z11.array(workGraphOmissionSchema).optional()
+    });
+    workGraphReadinessParamsSchema = z11.object({
+      rootId: z11.string().min(1),
+      role: z11.string().min(1).optional(),
+      includeGateBlockers: z11.boolean().optional()
+    });
+    workGraphReadinessResultSchema = z11.object({
+      rootId: z11.string().min(1),
+      role: z11.string().min(1).optional(),
+      ready: z11.boolean(),
+      warnings: z11.array(z11.string()),
+      groups: z11.object({
+        ready: z11.array(workGraphReadyFrontierTaskSchema),
+        blocked: z11.array(workGraphReadyFrontierTaskSchema),
+        blockedBy: z11.array(
+          z11.discriminatedUnion("kind", [
+            z11.object({
+              kind: z11.literal("dependency"),
+              blockerId: z11.string().min(1),
+              blocks: z11.array(z11.string().min(1))
             }),
-            z10.object({
-              kind: z10.literal("gate"),
+            z11.object({
+              kind: z11.literal("gate"),
               gate: verificationGateSchema,
-              blocks: z10.array(z10.string().min(1))
+              blocks: z11.array(z11.string().min(1))
             })
           ])
         )
       })
     });
-    workGraphContextPackSchema = z10.object({
-      rootId: z10.string().min(1),
-      generatedAt: z10.string().min(1),
+    workGraphContextPackSchema = z11.object({
+      rootId: z11.string().min(1),
+      generatedAt: z11.string().min(1),
       budget: workGraphContextBudgetSchema,
       slice: workGraphSliceSchema,
-      relationEdges: z10.object({
-        rootId: z10.string().min(1),
+      relationEdges: z11.object({
+        rootId: z11.string().min(1),
         direction: workGraphEdgeDirectionSchema,
-        edges: z10.array(workGraphDirectEdgeSchema)
+        edges: z11.array(workGraphDirectEdgeSchema)
       }).optional(),
       readiness: workGraphReadinessResultSchema.optional(),
-      rollup: z10.lazy(() => tasksRollupResultSchema).optional(),
-      omissions: z10.array(workGraphOmissionSchema)
-    });
-    workGraphScaffoldValidateParamsSchema = z10.object({
-      rootId: z10.string().min(1),
-      nodes: z10.array(
-        z10.object({
-          id: z10.string().min(1),
+      rollup: z11.lazy(() => tasksRollupResultSchema).optional(),
+      omissions: z11.array(workGraphOmissionSchema)
+    });
+    workGraphScaffoldValidateParamsSchema = z11.object({
+      rootId: z11.string().min(1),
+      nodes: z11.array(
+        z11.object({
+          id: z11.string().min(1),
           type: taskTypeSchema,
-          parentId: z10.string().min(1).nullable().optional()
+          parentId: z11.string().min(1).nullable().optional()
         })
       ),
-      edges: z10.array(workGraphDirectEdgeSchema).optional(),
-      dryRun: z10.boolean().optional()
-    });
-    workGraphScaffoldValidationIssueSchema = z10.object({
-      code: z10.string().min(1),
-      message: z10.string().min(1),
-      taskId: z10.string().min(1).optional(),
-      severity: z10.enum(["error", "warning"])
-    });
-    workGraphScaffoldValidateResultSchema = z10.object({
-      rootId: z10.string().min(1),
-      valid: z10.boolean(),
-      dryRun: z10.boolean(),
-      issues: z10.array(workGraphScaffoldValidationIssueSchema),
-      hierarchy: z10.object({
-        valid: z10.boolean(),
-        violations: z10.array(
-          z10.object({
-            code: z10.literal(E_WORKGRAPH_PARENT_TYPE_MATRIX),
-            taskId: z10.string().min(1),
+      edges: z11.array(workGraphDirectEdgeSchema).optional(),
+      dryRun: z11.boolean().optional()
+    });
+    workGraphScaffoldValidationIssueSchema = z11.object({
+      code: z11.string().min(1),
+      message: z11.string().min(1),
+      taskId: z11.string().min(1).optional(),
+      severity: z11.enum(["error", "warning"])
+    });
+    workGraphScaffoldValidateResultSchema = z11.object({
+      rootId: z11.string().min(1),
+      valid: z11.boolean(),
+      dryRun: z11.boolean(),
+      issues: z11.array(workGraphScaffoldValidationIssueSchema),
+      hierarchy: z11.object({
+        valid: z11.boolean(),
+        violations: z11.array(
+          z11.object({
+            code: z11.literal(E_WORKGRAPH_PARENT_TYPE_MATRIX),
+            taskId: z11.string().min(1),
             taskType: taskTypeSchema,
-            parentId: z10.string().min(1).nullable(),
+            parentId: z11.string().min(1).nullable(),
             parentType: taskTypeSchema.optional(),
-            message: z10.string().min(1)
+            message: z11.string().min(1)
           })
         )
       })
     });
     workGraphScaffoldApplyParamsSchema = workGraphScaffoldValidateParamsSchema.extend({
-      apply: z10.boolean().optional()
+      apply: z11.boolean().optional()
     });
     workGraphScaffoldApplyResultSchema = workGraphScaffoldValidateResultSchema.extend({
-      applied: z10.boolean(),
-      nodesChanged: z10.number().int().nonnegative(),
-      edgesChanged: z10.number().int().nonnegative()
-    });
-    workGraphPlanningDocParamsSchema = z10.object({
-      rootId: z10.string().min(1),
-      audience: z10.enum(["agent", "maintainer"]),
-      tokenBudget: z10.number().int().positive().optional(),
-      includeRelations: z10.boolean().optional(),
-      includeReadiness: z10.boolean().optional(),
-      includeRollup: z10.boolean().optional()
-    });
-    workGraphPlanningDocSchema = z10.object({
-      rootId: z10.string().min(1),
-      generatedAt: z10.string().min(1),
-      audience: z10.enum(["agent", "maintainer"]),
-      title: z10.string().min(1),
-      content: z10.string(),
-      sections: z10.array(z10.string().min(1)),
-      estimatedTokens: z10.number().int().nonnegative(),
-      budget: z10.object({
-        tokenBudget: z10.number().int().positive(),
-        truncated: z10.boolean()
+      applied: z11.boolean(),
+      nodesChanged: z11.number().int().nonnegative(),
+      edgesChanged: z11.number().int().nonnegative()
+    });
+    workGraphPlanningDocParamsSchema = z11.object({
+      rootId: z11.string().min(1),
+      audience: z11.enum(["agent", "maintainer"]),
+      tokenBudget: z11.number().int().positive().optional(),
+      includeRelations: z11.boolean().optional(),
+      includeReadiness: z11.boolean().optional(),
+      includeRollup: z11.boolean().optional()
+    });
+    workGraphPlanningDocSchema = z11.object({
+      rootId: z11.string().min(1),
+      generatedAt: z11.string().min(1),
+      audience: z11.enum(["agent", "maintainer"]),
+      title: z11.string().min(1),
+      content: z11.string(),
+      sections: z11.array(z11.string().min(1)),
+      estimatedTokens: z11.number().int().nonnegative(),
+      budget: z11.object({
+        tokenBudget: z11.number().int().positive(),
+        truncated: z11.boolean()
       }).optional()
     });
     tasksTraverseParamsSchema = paginationParamsSchema.extend({
-      rootId: z10.string().min(1),
+      rootId: z11.string().min(1),
       direction: workGraphTraversalDirectionSchema,
-      maxDepth: z10.number().int().nonnegative().optional(),
-      includeRelations: z10.boolean().optional()
+      maxDepth: z11.number().int().nonnegative().optional(),
+      includeRelations: z11.boolean().optional()
     });
-    tasksTraverseResultSchema = z10.object({
-      rootId: z10.string().min(1),
+    tasksTraverseResultSchema = z11.object({
+      rootId: z11.string().min(1),
       direction: workGraphTraversalDirectionSchema,
-      nodes: z10.array(workGraphNodeSchema),
-      edges: z10.array(workGraphEdgeSchema),
+      nodes: z11.array(workGraphNodeSchema),
+      edges: z11.array(workGraphEdgeSchema),
       pageInfo: workGraphPageInfoSchema
     });
     tasksTreeParamsSchema = paginationParamsSchema.extend({
-      rootId: z10.string().min(1),
-      maxDepth: z10.number().int().nonnegative().optional()
+      rootId: z11.string().min(1),
+      maxDepth: z11.number().int().nonnegative().optional()
     });
-    tasksTreeResultSchema = z10.object({
-      rootId: z10.string().min(1),
-      nodes: z10.array(workGraphNodeSchema.extend({ depth: z10.number().int().positive() })),
-      edges: z10.array(workGraphHierarchyEdgeSchema),
+    tasksTreeResultSchema = z11.object({
+      rootId: z11.string().min(1),
+      nodes: z11.array(workGraphNodeSchema.extend({ depth: z11.number().int().positive() })),
+      edges: z11.array(workGraphHierarchyEdgeSchema),
       pageInfo: workGraphPageInfoSchema
     });
-    tasksRollupParamsSchema = z10.object({
-      rootId: z10.string().min(1),
+    tasksRollupParamsSchema = z11.object({
+      rootId: z11.string().min(1),
       expectedDirectRollup: workGraphRollupCountsSchema.optional()
     });
-    tasksRollupResultSchema = z10.object({
-      rootId: z10.string().min(1),
+    tasksRollupResultSchema = z11.object({
+      rootId: z11.string().min(1),
       direct: workGraphRollupCountsSchema,
       subtree: workGraphRollupCountsSchema,
-      percentDenominator: z10.object({
-        basis: z10.literal("subtree-total"),
-        total: z10.number().int().nonnegative(),
-        description: z10.string().min(1)
+      percentDenominator: z11.object({
+        basis: z11.literal("subtree-total"),
+        total: z11.number().int().nonnegative(),
+        description: z11.string().min(1)
       }),
       percentages: workGraphSubtreePercentagesSchema,
-      staleProjection: z10.boolean(),
-      projectionMismatches: z10.array(workGraphProjectionMismatchSchema)
-    });
-    tasksFrontierParamsSchema = z10.object({
-      rootId: z10.string().min(1),
-      role: z10.string().min(1).optional()
-    });
-    tasksFrontierResultSchema = z10.object({
-      rootId: z10.string().min(1),
-      role: z10.string().min(1).optional(),
-      groups: z10.object({
-        ready: z10.array(workGraphReadyFrontierTaskSchema),
-        blocked: z10.array(workGraphReadyFrontierTaskSchema),
-        blockedBy: z10.array(
-          z10.discriminatedUnion("kind", [
-            z10.object({
-              kind: z10.literal("dependency"),
-              blockerId: z10.string().min(1),
-              blocks: z10.array(z10.string().min(1))
+      staleProjection: z11.boolean(),
+      projectionMismatches: z11.array(workGraphProjectionMismatchSchema)
+    });
+    tasksFrontierParamsSchema = z11.object({
+      rootId: z11.string().min(1),
+      role: z11.string().min(1).optional()
+    });
+    tasksFrontierResultSchema = z11.object({
+      rootId: z11.string().min(1),
+      role: z11.string().min(1).optional(),
+      groups: z11.object({
+        ready: z11.array(workGraphReadyFrontierTaskSchema),
+        blocked: z11.array(workGraphReadyFrontierTaskSchema),
+        blockedBy: z11.array(
+          z11.discriminatedUnion("kind", [
+            z11.object({
+              kind: z11.literal("dependency"),
+              blockerId: z11.string().min(1),
+              blocks: z11.array(z11.string().min(1))
             }),
-            z10.object({
-              kind: z10.literal("gate"),
+            z11.object({
+              kind: z11.literal("gate"),
               gate: verificationGateSchema,
-              blocks: z10.array(z10.string().min(1))
+              blocks: z11.array(z11.string().min(1))
             })
           ])
         )
       })
     });
     tasksWorkGraphAuditParamsSchema = paginationParamsSchema.extend({
-      rootId: z10.string().min(1),
-      maxDepth: z10.number().int().nonnegative().optional(),
-      includeRelations: z10.boolean().optional()
-    });
-    tasksWorkGraphAuditResultSchema = z10.object({
-      rootId: z10.string().min(1),
-      hierarchy: z10.object({
-        valid: z10.boolean(),
-        violations: z10.array(
-          z10.object({
-            code: z10.literal(E_WORKGRAPH_PARENT_TYPE_MATRIX),
-            taskId: z10.string().min(1),
+      rootId: z11.string().min(1),
+      maxDepth: z11.number().int().nonnegative().optional(),
+      includeRelations: z11.boolean().optional()
+    });
+    tasksWorkGraphAuditResultSchema = z11.object({
+      rootId: z11.string().min(1),
+      hierarchy: z11.object({
+        valid: z11.boolean(),
+        violations: z11.array(
+          z11.object({
+            code: z11.literal(E_WORKGRAPH_PARENT_TYPE_MATRIX),
+            taskId: z11.string().min(1),
             taskType: taskTypeSchema,
-            parentId: z10.string().min(1).nullable(),
+            parentId: z11.string().min(1).nullable(),
             parentType: taskTypeSchema.optional(),
-            message: z10.string().min(1)
+            message: z11.string().min(1)
           })
         )
       }),
       traversal: tasksTraverseResultSchema,
       frontier: tasksFrontierResultSchema,
       rollup: tasksRollupResultSchema,
-      relationEdges: z10.object({
-        rootId: z10.string().min(1),
+      relationEdges: z11.object({
+        rootId: z11.string().min(1),
         direction: workGraphEdgeDirectionSchema,
-        edges: z10.array(
-          z10.discriminatedUnion("source", [
+        edges: z11.array(
+          z11.discriminatedUnion("source", [
             workGraphRelationEdgeSchema,
             workGraphDependencyEdgeSchema
           ])
@@ -11577,6 +11619,87 @@ var init_nexus_scope_map = __esm({
   }
 });
 
+// packages/contracts/src/operations/output-contracts-data.ts
+var TASK_MUTATION_DATA_SCHEMA, tasksAddOutputContract, tasksAddBatchOutputContract, tasksUpdateOutputContract, tasksCompleteOutputContract;
+var init_output_contracts_data = __esm({
+  "packages/contracts/src/operations/output-contracts-data.ts"() {
+    "use strict";
+    TASK_MUTATION_DATA_SCHEMA = {
+      type: "object",
+      required: ["count", "created", "updated", "deleted"],
+      additionalProperties: true,
+      properties: {
+        count: { type: "number", description: "Number of records the mutation affected." },
+        created: {
+          type: "array",
+          description: 'Task IDs created by the mutation (bare strings, e.g. "T11692"). Empty for update/delete-only mutations.',
+          items: { type: "string" }
+        },
+        updated: {
+          type: "array",
+          description: "Task IDs updated by the mutation (bare strings). Empty for create/delete-only mutations.",
+          items: { type: "string" }
+        },
+        deleted: {
+          type: "array",
+          description: "Task IDs deleted by the mutation (bare strings). Empty for create/update-only mutations.",
+          items: { type: "string" }
+        },
+        ids: {
+          type: "array",
+          description: "Deprecated alias for the non-empty bucket. Prefer created/updated/deleted.",
+          items: { type: "string" }
+        },
+        dryRun: { type: "boolean", description: "True when this was a preview-only mutation." },
+        status: { type: "string", description: "Post-mutation task status (add/update/complete)." }
+      }
+    };
+    tasksAddOutputContract = {
+      operation: "tasks.add",
+      shapeNote: 'The created task ID (bare string) is at /data/created/0 \u2014 NOT /data/created/0/id. Example: /data/created/0 \u2192 "T11692".',
+      dataSchema: { ...TASK_MUTATION_DATA_SCHEMA },
+      fieldPointers: ["/data/created/0", "/data/count"]
+    };
+    tasksAddBatchOutputContract = {
+      operation: "tasks.add-batch",
+      shapeNote: "Atomic batch insert. Each created task ID (bare string) is in /data/created (array). Dry-run projections are at root: /data/wouldCreate and /data/insertedCount (=0). NOT under /data/dryRunSummary.",
+      dataSchema: {
+        type: "object",
+        required: ["count", "created", "updated", "deleted"],
+        additionalProperties: true,
+        properties: {
+          ...TASK_MUTATION_DATA_SCHEMA.properties,
+          wouldCreate: {
+            type: "number",
+            description: "Dry-run: predicted write count. Present only when dryRun=true."
+          },
+          insertedCount: {
+            type: "number",
+            description: "Dry-run: always 0 (no DB write). Present only when dryRun=true."
+          },
+          wouldAffect: {
+            type: "number",
+            description: "Dry-run: generic affected count. Present only when dryRun=true."
+          }
+        }
+      },
+      fieldPointers: ["/data/created/0", "/data/count", "/data/wouldCreate", "/data/insertedCount"]
+    };
+    tasksUpdateOutputContract = {
+      operation: "tasks.update",
+      shapeNote: "The updated task ID (bare string) is at /data/updated/0 \u2014 NOT /data/updated/0/id. Use /data/status for the post-mutation status.",
+      dataSchema: { ...TASK_MUTATION_DATA_SCHEMA },
+      fieldPointers: ["/data/updated/0", "/data/status", "/data/count"]
+    };
+    tasksCompleteOutputContract = {
+      operation: "tasks.complete",
+      shapeNote: "Completion is a status mutation \u2014 the task ID (bare string) is at /data/updated/0 (status=done). Use /data/status for the post-mutation status.",
+      dataSchema: { ...TASK_MUTATION_DATA_SCHEMA },
+      fieldPointers: ["/data/updated/0", "/data/status", "/data/count"]
+    };
+  }
+});
+
 // packages/contracts/src/peer.ts
 var init_peer = __esm({
   "packages/contracts/src/peer.ts"() {
@@ -11585,31 +11708,31 @@ var init_peer = __esm({
 });
 
 // packages/contracts/src/release/evidence-atoms.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var parsedPrEvidenceAtomSchema, prEvidenceStateModifierSchema, ghPrViewSchema, PR_REQUIRED_WORKFLOWS;
 var init_evidence_atoms = __esm({
   "packages/contracts/src/release/evidence-atoms.ts"() {
     "use strict";
-    parsedPrEvidenceAtomSchema = z11.object({
-      kind: z11.literal("pr"),
-      prNumber: z11.number().int().positive()
-    });
-    prEvidenceStateModifierSchema = z11.object({
-      kind: z11.literal("state"),
-      value: z11.literal("MERGED")
-    });
-    ghPrViewSchema = z11.object({
-      state: z11.enum(["OPEN", "CLOSED", "MERGED"]),
-      mergedAt: z11.string().nullable(),
-      headRefOid: z11.string().optional(),
-      mergeable: z11.string().optional(),
-      statusCheckRollup: z11.array(
-        z11.object({
-          __typename: z11.string().optional(),
-          name: z11.string().optional(),
-          workflowName: z11.string().optional(),
-          conclusion: z11.string().nullable().optional(),
-          status: z11.string().optional()
+    parsedPrEvidenceAtomSchema = z12.object({
+      kind: z12.literal("pr"),
+      prNumber: z12.number().int().positive()
+    });
+    prEvidenceStateModifierSchema = z12.object({
+      kind: z12.literal("state"),
+      value: z12.literal("MERGED")
+    });
+    ghPrViewSchema = z12.object({
+      state: z12.enum(["OPEN", "CLOSED", "MERGED"]),
+      mergedAt: z12.string().nullable(),
+      headRefOid: z12.string().optional(),
+      mergeable: z12.string().optional(),
+      statusCheckRollup: z12.array(
+        z12.object({
+          __typename: z12.string().optional(),
+          name: z12.string().optional(),
+          workflowName: z12.string().optional(),
+          conclusion: z12.string().nullable().optional(),
+          status: z12.string().optional()
         }).passthrough()
       ).optional().default([])
     }).passthrough();
@@ -11622,7 +11745,7 @@ var init_evidence_atoms = __esm({
 });
 
 // packages/contracts/src/release/plan.ts
-import { z as z12 } from "zod";
+import { z as z13 } 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"() {
@@ -11665,20 +11788,20 @@ var init_plan = __esm({
     ];
     IMPACT = ["major", "minor", "patch"];
     RESOLVED_SOURCE = ["project-context", "language-default", "legacy-alias"];
-    ReleaseChannelSchema = z12.enum(RELEASE_CHANNEL);
-    ReleaseSchemeSchema = z12.enum(RELEASE_SCHEME);
-    ReleaseKindSchema = z12.enum(RELEASE_KIND);
-    ReleaseStatusSchema = z12.enum(RELEASE_STATUS);
-    GateStatusSchema = z12.enum(GATE_STATUS);
-    GateNameSchema = z12.enum(GATE_NAME);
-    PlatformTupleSchema = z12.enum(PLATFORM_TUPLE);
-    PublisherSchema = z12.enum(PUBLISHER);
-    TaskKindSchema = z12.enum(TASK_KIND);
-    ImpactSchema = z12.enum(IMPACT);
-    ResolvedSourceSchema = z12.enum(RESOLVED_SOURCE);
-    Iso8601 = z12.iso.datetime({ offset: true });
-    NonEmptyString = z12.string().min(1);
-    ReleasePlanTaskSchema = z12.object({
+    ReleaseChannelSchema = z13.enum(RELEASE_CHANNEL);
+    ReleaseSchemeSchema = z13.enum(RELEASE_SCHEME);
+    ReleaseKindSchema = z13.enum(RELEASE_KIND);
+    ReleaseStatusSchema = z13.enum(RELEASE_STATUS);
+    GateStatusSchema = z13.enum(GATE_STATUS);
+    GateNameSchema = z13.enum(GATE_NAME);
+    PlatformTupleSchema = z13.enum(PLATFORM_TUPLE);
+    PublisherSchema = z13.enum(PUBLISHER);
+    TaskKindSchema = z13.enum(TASK_KIND);
+    ImpactSchema = z13.enum(IMPACT);
+    ResolvedSourceSchema = z13.enum(RESOLVED_SOURCE);
+    Iso8601 = z13.iso.datetime({ offset: true });
+    NonEmptyString = z13.string().min(1);
+    ReleasePlanTaskSchema = z13.object({
       /** Task ID (e.g. "T10001"). Format intentionally loose so historical IDs validate. */
       id: NonEmptyString,
       /** Conventional-commit-aligned task classification. */
@@ -11686,20 +11809,20 @@ var init_plan = __esm({
       /** SemVer impact classification. */
       impact: ImpactSchema,
       /** Human-readable changelog line for this task. */
-      userFacingSummary: z12.string(),
+      userFacingSummary: z13.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: z12.array(NonEmptyString),
+      evidenceAtoms: z13.array(NonEmptyString),
       /** IVTR phase at plan time — informational only per R-316. */
-      ivtrPhaseAtPlan: z12.string().optional(),
+      ivtrPhaseAtPlan: z13.string().optional(),
       /** Epic this task rolls up to, locked at plan time per R-303. */
       epicAncestor: NonEmptyString
     });
-    ReleaseGateSchema = z12.object({
+    ReleaseGateSchema = z13.object({
       /** Canonical gate name. */
       name: GateNameSchema,
       /** ADR-051 atom string identifying the resolved tool (e.g. `tool:test`). */
@@ -11709,11 +11832,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: z12.string().optional(),
+      resolvedCommand: z13.string().optional(),
       /** Provenance of the resolved command. Optional for unresolved gates. */
       resolvedSource: ResolvedSourceSchema.optional()
     });
-    ReleasePlatformMatrixEntrySchema = z12.object({
+    ReleasePlatformMatrixEntrySchema = z13.object({
       /** Target platform tuple. */
       platform: PlatformTupleSchema,
       /** Distribution backend. */
@@ -11721,47 +11844,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: z12.boolean().default(true).optional()
+      smoke: z13.boolean().default(true).optional()
     });
-    ReleasePreflightSummarySchema = z12.object({
+    ReleasePreflightSummarySchema = z13.object({
       /** True if esbuild externals are out of sync with package.json. */
-      esbuildExternalsDrift: z12.boolean(),
+      esbuildExternalsDrift: z13.boolean(),
       /** True if `pnpm-lock.yaml` diverges from the workspace manifest. */
-      lockfileDrift: z12.boolean(),
+      lockfileDrift: z13.boolean(),
       /** True if all epic children are in terminal lifecycle states. */
-      epicCompletenessClean: z12.boolean(),
+      epicCompletenessClean: z13.boolean(),
       /** True if no task appears in multiple in-flight release plans. */
-      doubleListingClean: z12.boolean(),
+      doubleListingClean: z13.boolean(),
       /** Non-fatal preflight warnings (e.g. unresolved tools per R-024). */
-      preflightWarnings: z12.array(z12.string()).default([]).optional()
+      preflightWarnings: z13.array(z13.string()).default([]).optional()
     });
-    ReleasePlanChangelogSchema = z12.object({
+    ReleasePlanChangelogSchema = z13.object({
       /** `kind=feat` tasks. */
-      features: z12.array(NonEmptyString).default([]),
+      features: z13.array(NonEmptyString).default([]),
       /** `kind=fix` or `kind=hotfix` tasks. */
-      fixes: z12.array(NonEmptyString).default([]),
+      fixes: z13.array(NonEmptyString).default([]),
       /** `kind=chore`, `docs`, `refactor`, `test`, `perf` tasks. */
-      chores: z12.array(NonEmptyString).default([]),
+      chores: z13.array(NonEmptyString).default([]),
       /** `kind=breaking` or `kind=revert` tasks. */
-      breaking: z12.array(NonEmptyString).default([])
+      breaking: z13.array(NonEmptyString).default([])
     });
-    ReleasePlanMetaSchema = z12.object({
+    ReleasePlanMetaSchema = z13.object({
       /** True if this is the project's first ever release. */
-      firstEverRelease: z12.boolean().optional(),
+      firstEverRelease: z13.boolean().optional(),
       /** Canonical tool names that could not be resolved at plan time. */
-      unresolvedTools: z12.array(z12.string()).optional(),
+      unresolvedTools: z13.array(z13.string()).optional(),
       /** Project archetype detected at plan time. */
-      archetype: z12.string().optional()
-    }).catchall(z12.unknown());
-    ReleasePlanSchema = z12.object({
+      archetype: z13.string().optional()
+    }).catchall(z13.unknown());
+    ReleasePlanSchema = z13.object({
       /** Schema URL for this plan version. */
-      $schema: z12.string().optional(),
+      $schema: z13.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: z12.boolean(),
+      suffixApplied: z13.boolean(),
       /** Versioning scheme governing `version` / `resolvedVersion`. */
       scheme: ReleaseSchemeSchema,
       /** npm dist-tag channel for this release. */
@@ -11778,27 +11901,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: z12.string().nullable(),
+      previousVersion: z13.string().nullable(),
       /** Git tag of the previous release (typically `previousVersion` prefixed). */
-      previousTag: z12.string().nullable(),
+      previousTag: z13.string().nullable(),
       /** ISO-8601 timestamp the previous release was published. */
       previousShippedAt: Iso8601.nullable(),
       /** Tasks rolled into this release. */
-      tasks: z12.array(ReleasePlanTaskSchema),
+      tasks: z13.array(ReleasePlanTaskSchema),
       /** Bucketed changelog. */
       changelog: ReleasePlanChangelogSchema,
       /** Per-gate verification status. */
-      gates: z12.array(ReleaseGateSchema),
+      gates: z13.array(ReleaseGateSchema),
       /** Platform / publisher matrix. */
-      platformMatrix: z12.array(ReleasePlatformMatrixEntrySchema),
+      platformMatrix: z13.array(ReleasePlatformMatrixEntrySchema),
       /** Preflight summary from `cleo release plan`. */
       preflightSummary: ReleasePreflightSummarySchema,
       /** URL of the GHA workflow run (populated by `release-prepare.yml`). */
-      workflowRunUrl: z12.string().nullable(),
+      workflowRunUrl: z13.string().nullable(),
       /** URL of the bump PR (populated by `cleo release open`). */
-      prUrl: z12.string().nullable(),
+      prUrl: z13.string().nullable(),
       /** Merge commit SHA on `main` (populated by `release-publish.yml`). */
-      mergeCommitSha: z12.string().nullable(),
+      mergeCommitSha: z13.string().nullable(),
       /** Current FSM state per R-302. */
       status: ReleaseStatusSchema,
       /** Informational / forward-compat metadata. */
@@ -11854,52 +11977,52 @@ var init_session2 = __esm({
 });
 
 // packages/contracts/src/session-journal.ts
-import { z as z13 } from "zod";
+import { z as z14 } 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 = z13.object({
+    sessionJournalDoctorSummarySchema = z14.object({
       /** `true` when zero noise patterns were detected. */
-      isClean: z13.boolean(),
+      isClean: z14.boolean(),
       /** Total number of noise findings across all patterns. */
-      findingsCount: z13.number().int().nonnegative(),
+      findingsCount: z14.number().int().nonnegative(),
       /** Pattern names that were detected (empty when isClean). */
-      patterns: z13.array(z13.string()),
+      patterns: z14.array(z14.string()),
       /** Total brain entries scanned. `0` = empty or unavailable. */
-      totalScanned: z13.number().int().nonnegative()
+      totalScanned: z14.number().int().nonnegative()
     });
-    sessionJournalDebriefSummarySchema = z13.object({
+    sessionJournalDebriefSummarySchema = z14.object({
       /** First 200 characters of the session end note (if provided). */
-      noteExcerpt: z13.string().max(200).optional(),
+      noteExcerpt: z14.string().max(200).optional(),
       /** Number of tasks completed during the session. */
-      tasksCompletedCount: z13.number().int().nonnegative(),
+      tasksCompletedCount: z14.number().int().nonnegative(),
       /** Up to 5 task IDs (not titles) that were the focus of the session. */
-      tasksFocused: z13.array(z13.string()).max(5).optional()
+      tasksFocused: z14.array(z14.string()).max(5).optional()
     });
-    sessionJournalEntrySchema = z13.object({
+    sessionJournalEntrySchema = z14.object({
       // Identity
       /** Schema version for forward-compatibility. Always `'1.0'` in this release. */
-      schemaVersion: z13.literal(SESSION_JOURNAL_SCHEMA_VERSION),
+      schemaVersion: z14.literal(SESSION_JOURNAL_SCHEMA_VERSION),
       /** ISO 8601 timestamp when the entry was written. */
-      timestamp: z13.string(),
+      timestamp: z14.string(),
       /** CLEO session ID (e.g. `ses_20260424055456_ede571`). */
-      sessionId: z13.string(),
+      sessionId: z14.string(),
       /** Event type that triggered this journal entry. */
-      eventType: z13.enum(["session_start", "session_end", "observation", "decision", "error"]),
+      eventType: z14.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: z13.string().optional(),
+      agentIdentifier: z14.string().optional(),
       /** Provider adapter ID active for this session. */
-      providerId: z13.string().optional(),
+      providerId: z14.string().optional(),
       /** Session scope string (e.g. `'global'` or `'epic:T1263'`). */
-      scope: z13.string().optional(),
+      scope: z14.string().optional(),
       // Session-end fields
       /** Duration of the session in seconds (session_end only). */
-      duration: z13.number().int().nonnegative().optional(),
+      duration: z14.number().int().nonnegative().optional(),
       /** Task IDs (not titles) completed during the session. */
-      tasksCompleted: z13.array(z13.string()).optional(),
+      tasksCompleted: z14.array(z14.string()).optional(),
       // Doctor summary (T1262 absorbed)
       /** Compact result of `scanBrainNoise` run at session-end. */
       doctorSummary: sessionJournalDoctorSummarySchema.optional(),
@@ -11908,7 +12031,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: z13.string().optional()
+      prevEntryHash: z14.string().optional()
     });
   }
 });
@@ -11921,52 +12044,52 @@ var init_task = __esm({
 });
 
 // packages/contracts/src/task-evidence.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var fileEvidenceSchema, logEvidenceSchema, screenshotEvidenceSchema, testOutputEvidenceSchema, commandOutputEvidenceSchema, taskEvidenceSchema;
 var init_task_evidence = __esm({
   "packages/contracts/src/task-evidence.ts"() {
     "use strict";
-    fileEvidenceSchema = z14.object({
-      kind: z14.literal("file"),
-      sha256: z14.string().length(64),
-      timestamp: z14.string().datetime(),
-      path: z14.string().min(1),
-      mime: z14.string().optional(),
-      description: z14.string().optional()
-    });
-    logEvidenceSchema = z14.object({
-      kind: z14.literal("log"),
-      sha256: z14.string().length(64),
-      timestamp: z14.string().datetime(),
-      source: z14.string().min(1),
-      description: z14.string().optional()
-    });
-    screenshotEvidenceSchema = z14.object({
-      kind: z14.literal("screenshot"),
-      sha256: z14.string().length(64),
-      timestamp: z14.string().datetime(),
-      mime: z14.enum(["image/png", "image/jpeg", "image/webp"]).optional(),
-      description: z14.string().optional()
-    });
-    testOutputEvidenceSchema = z14.object({
-      kind: z14.literal("test-output"),
-      sha256: z14.string().length(64),
-      timestamp: z14.string().datetime(),
-      passed: z14.number().int().nonnegative(),
-      failed: z14.number().int().nonnegative(),
-      skipped: z14.number().int().nonnegative(),
-      exitCode: z14.number().int(),
-      description: z14.string().optional()
-    });
-    commandOutputEvidenceSchema = z14.object({
-      kind: z14.literal("command-output"),
-      sha256: z14.string().length(64),
-      timestamp: z14.string().datetime(),
-      cmd: z14.string().min(1),
-      exitCode: z14.number().int(),
-      description: z14.string().optional()
-    });
-    taskEvidenceSchema = z14.discriminatedUnion("kind", [
+    fileEvidenceSchema = z15.object({
+      kind: z15.literal("file"),
+      sha256: z15.string().length(64),
+      timestamp: z15.string().datetime(),
+      path: z15.string().min(1),
+      mime: z15.string().optional(),
+      description: z15.string().optional()
+    });
+    logEvidenceSchema = z15.object({
+      kind: z15.literal("log"),
+      sha256: z15.string().length(64),
+      timestamp: z15.string().datetime(),
+      source: z15.string().min(1),
+      description: z15.string().optional()
+    });
+    screenshotEvidenceSchema = z15.object({
+      kind: z15.literal("screenshot"),
+      sha256: z15.string().length(64),
+      timestamp: z15.string().datetime(),
+      mime: z15.enum(["image/png", "image/jpeg", "image/webp"]).optional(),
+      description: z15.string().optional()
+    });
+    testOutputEvidenceSchema = z15.object({
+      kind: z15.literal("test-output"),
+      sha256: z15.string().length(64),
+      timestamp: z15.string().datetime(),
+      passed: z15.number().int().nonnegative(),
+      failed: z15.number().int().nonnegative(),
+      skipped: z15.number().int().nonnegative(),
+      exitCode: z15.number().int(),
+      description: z15.string().optional()
+    });
+    commandOutputEvidenceSchema = z15.object({
+      kind: z15.literal("command-output"),
+      sha256: z15.string().length(64),
+      timestamp: z15.string().datetime(),
+      cmd: z15.string().min(1),
+      exitCode: z15.number().int(),
+      description: z15.string().optional()
+    });
+    taskEvidenceSchema = z15.discriminatedUnion("kind", [
       fileEvidenceSchema,
       logEvidenceSchema,
       screenshotEvidenceSchema,
@@ -11977,12 +12100,12 @@ var init_task_evidence = __esm({
 });
 
 // packages/contracts/src/tasks/archive.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var ArchiveReason, ARCHIVE_REASON_VALUES;
 var init_archive = __esm({
   "packages/contracts/src/tasks/archive.ts"() {
     "use strict";
-    ArchiveReason = z15.enum([
+    ArchiveReason = z16.enum([
       "verified",
       "reconciled",
       "superseded",
@@ -11995,47 +12118,47 @@ var init_archive = __esm({
 });
 
 // packages/contracts/src/tasks.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var taskMutationWarningSeveritySchema, taskMutationWarningSchema, taskMutationDryRunSummarySchema, taskMutationTaskRecordSchema, taskMutationEnvelopeSchema, completionTaskStatusSchema, completionCriterionKindSchema, completionCriterionStatusSchema, completionBlockerReasonSchema, completionStaleReasonSchema, completionProjectionRepairErrorCodeSchema, completionCriterionWaiverSchema, completionCriterionReplacementSchema, completionCriterionEvaluationSchema, unsatisfiedCompletionCriterionSchema, completionTotalsSchema, completionContextPackSchema, completionEvaluationSchema, completionExplanationSchema, completionListParamsSchema, completionListResultSchema, completionEvaluateParamsSchema, completionProjectionRepairErrorSchema, completionProjectionRepairParamsSchema, completionProjectionRepairResultSchema;
 var init_tasks2 = __esm({
   "packages/contracts/src/tasks.ts"() {
     "use strict";
     init_status_registry();
-    taskMutationWarningSeveritySchema = z16.enum(["info", "warning"]);
-    taskMutationWarningSchema = z16.object({
-      code: z16.string().min(1),
-      message: z16.string().min(1),
+    taskMutationWarningSeveritySchema = z17.enum(["info", "warning"]);
+    taskMutationWarningSchema = z17.object({
+      code: z17.string().min(1),
+      message: z17.string().min(1),
       severity: taskMutationWarningSeveritySchema.optional(),
-      taskId: z16.string().min(1).optional(),
-      field: z16.string().min(1).optional(),
-      index: z16.number().int().nonnegative().optional()
-    });
-    taskMutationDryRunSummarySchema = z16.object({
-      dryRun: z16.literal(true),
-      wouldCreate: z16.number().int().nonnegative(),
-      wouldUpdate: z16.number().int().nonnegative(),
-      wouldDelete: z16.number().int().nonnegative(),
-      wouldAffect: z16.number().int().nonnegative(),
-      validatedCount: z16.number().int().nonnegative(),
-      insertedCount: z16.literal(0),
-      updatedCount: z16.literal(0),
-      deletedCount: z16.literal(0),
-      warnings: z16.array(taskMutationWarningSchema)
-    });
-    taskMutationTaskRecordSchema = z16.object({ id: z16.string().min(1) }).passthrough();
-    taskMutationEnvelopeSchema = z16.object({
-      dryRun: z16.boolean().optional(),
-      created: z16.array(taskMutationTaskRecordSchema),
-      updated: z16.array(taskMutationTaskRecordSchema),
-      deleted: z16.array(taskMutationTaskRecordSchema),
-      affectedCount: z16.number().int().nonnegative(),
-      mutationWarnings: z16.array(taskMutationWarningSchema),
+      taskId: z17.string().min(1).optional(),
+      field: z17.string().min(1).optional(),
+      index: z17.number().int().nonnegative().optional()
+    });
+    taskMutationDryRunSummarySchema = z17.object({
+      dryRun: z17.literal(true),
+      wouldCreate: z17.number().int().nonnegative(),
+      wouldUpdate: z17.number().int().nonnegative(),
+      wouldDelete: z17.number().int().nonnegative(),
+      wouldAffect: z17.number().int().nonnegative(),
+      validatedCount: z17.number().int().nonnegative(),
+      insertedCount: z17.literal(0),
+      updatedCount: z17.literal(0),
+      deletedCount: z17.literal(0),
+      warnings: z17.array(taskMutationWarningSchema)
+    });
+    taskMutationTaskRecordSchema = z17.object({ id: z17.string().min(1) }).passthrough();
+    taskMutationEnvelopeSchema = z17.object({
+      dryRun: z17.boolean().optional(),
+      created: z17.array(taskMutationTaskRecordSchema),
+      updated: z17.array(taskMutationTaskRecordSchema),
+      deleted: z17.array(taskMutationTaskRecordSchema),
+      affectedCount: z17.number().int().nonnegative(),
+      mutationWarnings: z17.array(taskMutationWarningSchema),
       dryRunSummary: taskMutationDryRunSummarySchema.optional()
     });
-    completionTaskStatusSchema = z16.enum(TASK_STATUSES);
-    completionCriterionKindSchema = z16.enum(["text", "evidence_bound", "child_task"]);
-    completionCriterionStatusSchema = z16.enum(["satisfied", "unsatisfied", "waived", "replaced"]);
-    completionBlockerReasonSchema = z16.enum([
+    completionTaskStatusSchema = z17.enum(TASK_STATUSES);
+    completionCriterionKindSchema = z17.enum(["text", "evidence_bound", "child_task"]);
+    completionCriterionStatusSchema = z17.enum(["satisfied", "unsatisfied", "waived", "replaced"]);
+    completionBlockerReasonSchema = z17.enum([
       "missing_evidence_binding",
       "child_not_done",
       "child_cancelled_requires_waiver",
@@ -12043,68 +12166,68 @@ var init_tasks2 = __esm({
       "child_missing",
       "done_parent_stale"
     ]);
-    completionStaleReasonSchema = z16.enum(["done_parent_has_unsatisfied_criteria"]);
-    completionProjectionRepairErrorCodeSchema = z16.enum([
+    completionStaleReasonSchema = z17.enum(["done_parent_has_unsatisfied_criteria"]);
+    completionProjectionRepairErrorCodeSchema = z17.enum([
       "projection_not_stale",
       "criteria_missing",
       "binding_target_missing",
       "repair_conflict"
     ]);
-    completionCriterionWaiverSchema = z16.object({
-      criterionAcId: z16.string().min(1),
-      childTaskId: z16.string().min(1),
-      reason: z16.string().min(1),
-      actor: z16.string().min(1),
-      waivedAt: z16.string().min(1)
-    });
-    completionCriterionReplacementSchema = z16.object({
-      criterionAcId: z16.string().min(1),
-      originalChildTaskId: z16.string().min(1),
-      replacementChildTaskId: z16.string().min(1),
-      reason: z16.string().min(1),
-      actor: z16.string().min(1),
-      replacedAt: z16.string().min(1)
-    });
-    completionCriterionEvaluationSchema = z16.object({
-      acId: z16.string().min(1),
-      alias: z16.string().min(1),
-      text: z16.string(),
+    completionCriterionWaiverSchema = z17.object({
+      criterionAcId: z17.string().min(1),
+      childTaskId: z17.string().min(1),
+      reason: z17.string().min(1),
+      actor: z17.string().min(1),
+      waivedAt: z17.string().min(1)
+    });
+    completionCriterionReplacementSchema = z17.object({
+      criterionAcId: z17.string().min(1),
+      originalChildTaskId: z17.string().min(1),
+      replacementChildTaskId: z17.string().min(1),
+      reason: z17.string().min(1),
+      actor: z17.string().min(1),
+      replacedAt: z17.string().min(1)
+    });
+    completionCriterionEvaluationSchema = z17.object({
+      acId: z17.string().min(1),
+      alias: z17.string().min(1),
+      text: z17.string(),
       kind: completionCriterionKindSchema,
       status: completionCriterionStatusSchema,
       reason: completionBlockerReasonSchema.optional(),
-      targetTaskId: z16.string().min(1).optional(),
+      targetTaskId: z17.string().min(1).optional(),
       targetTaskStatus: completionTaskStatusSchema.optional(),
       waiver: completionCriterionWaiverSchema.optional(),
       replacement: completionCriterionReplacementSchema.optional(),
       replacementTaskStatus: completionTaskStatusSchema.optional(),
-      evidenceBindings: z16.number().int().nonnegative()
+      evidenceBindings: z17.number().int().nonnegative()
     });
     unsatisfiedCompletionCriterionSchema = completionCriterionEvaluationSchema.extend({
-      status: z16.literal("unsatisfied"),
+      status: z17.literal("unsatisfied"),
       reason: completionBlockerReasonSchema
     });
-    completionTotalsSchema = z16.object({
-      criteria: z16.number().int().nonnegative(),
-      satisfied: z16.number().int().nonnegative(),
-      unsatisfied: z16.number().int().nonnegative(),
-      waived: z16.number().int().nonnegative(),
-      replaced: z16.number().int().nonnegative()
-    });
-    completionContextPackSchema = z16.object({
-      taskId: z16.string().min(1),
-      generatedAt: z16.string().min(1),
-      source: z16.literal("audit_log"),
-      window: z16.object({
-        limit: z16.number().int().positive(),
-        since: z16.string().min(1).optional(),
-        relationDepth: z16.number().int().nonnegative(),
-        relatedTaskIds: z16.array(z16.string().min(1))
+    completionTotalsSchema = z17.object({
+      criteria: z17.number().int().nonnegative(),
+      satisfied: z17.number().int().nonnegative(),
+      unsatisfied: z17.number().int().nonnegative(),
+      waived: z17.number().int().nonnegative(),
+      replaced: z17.number().int().nonnegative()
+    });
+    completionContextPackSchema = z17.object({
+      taskId: z17.string().min(1),
+      generatedAt: z17.string().min(1),
+      source: z17.literal("audit_log"),
+      window: z17.object({
+        limit: z17.number().int().positive(),
+        since: z17.string().min(1).optional(),
+        relationDepth: z17.number().int().nonnegative(),
+        relatedTaskIds: z17.array(z17.string().min(1))
       }),
-      events: z16.array(
-        z16.object({
-          id: z16.string().min(1),
-          timestamp: z16.string().min(1),
-          action: z16.enum([
+      events: z17.array(
+        z17.object({
+          id: z17.string().min(1),
+          timestamp: z17.string().min(1),
+          action: z17.enum([
             "task_completed",
             "task_reopened",
             "task_cancelled",
@@ -12112,77 +12235,77 @@ var init_tasks2 = __esm({
             "task_reparented",
             "ac_projection_rebuilt"
           ]),
-          taskId: z16.string().min(1),
-          relation: z16.enum(["self", "parent", "child", "sibling", "related"]),
-          actor: z16.string().min(1),
-          details: z16.record(z16.string(), z16.unknown()).optional(),
-          before: z16.record(z16.string(), z16.unknown()).optional(),
-          after: z16.record(z16.string(), z16.unknown()).optional()
+          taskId: z17.string().min(1),
+          relation: z17.enum(["self", "parent", "child", "sibling", "related"]),
+          actor: z17.string().min(1),
+          details: z17.record(z17.string(), z17.unknown()).optional(),
+          before: z17.record(z17.string(), z17.unknown()).optional(),
+          after: z17.record(z17.string(), z17.unknown()).optional()
         })
       ),
-      summary: z16.object({
-        totalEvents: z16.number().int().nonnegative(),
-        byAction: z16.record(z16.string(), z16.number().int().nonnegative()),
-        byRelation: z16.record(z16.string(), z16.number().int().nonnegative()),
-        latestEventAt: z16.string().nullable()
+      summary: z17.object({
+        totalEvents: z17.number().int().nonnegative(),
+        byAction: z17.record(z17.string(), z17.number().int().nonnegative()),
+        byRelation: z17.record(z17.string(), z17.number().int().nonnegative()),
+        latestEventAt: z17.string().nullable()
       })
     });
-    completionEvaluationSchema = z16.object({
-      taskId: z16.string().min(1),
+    completionEvaluationSchema = z17.object({
+      taskId: z17.string().min(1),
       taskStatus: completionTaskStatusSchema,
-      ready: z16.boolean(),
-      stale: z16.boolean(),
-      staleReasons: z16.array(completionStaleReasonSchema),
+      ready: z17.boolean(),
+      stale: z17.boolean(),
+      staleReasons: z17.array(completionStaleReasonSchema),
       contextPack: completionContextPackSchema.optional(),
-      satisfied: z16.array(completionCriterionEvaluationSchema),
-      unsatisfied: z16.array(unsatisfiedCompletionCriterionSchema),
-      waived: z16.array(completionCriterionEvaluationSchema),
-      replaced: z16.array(completionCriterionEvaluationSchema),
+      satisfied: z17.array(completionCriterionEvaluationSchema),
+      unsatisfied: z17.array(unsatisfiedCompletionCriterionSchema),
+      waived: z17.array(completionCriterionEvaluationSchema),
+      replaced: z17.array(completionCriterionEvaluationSchema),
       totals: completionTotalsSchema
     });
-    completionExplanationSchema = z16.object({
-      taskId: z16.string().min(1),
-      ready: z16.boolean(),
-      stale: z16.boolean(),
-      summary: z16.string(),
+    completionExplanationSchema = z17.object({
+      taskId: z17.string().min(1),
+      ready: z17.boolean(),
+      stale: z17.boolean(),
+      summary: z17.string(),
       contextPack: completionContextPackSchema.optional(),
-      blockers: z16.array(completionCriterionEvaluationSchema)
+      blockers: z17.array(completionCriterionEvaluationSchema)
     });
-    completionListParamsSchema = z16.object({
-      taskId: z16.string().min(1),
+    completionListParamsSchema = z17.object({
+      taskId: z17.string().min(1),
       status: completionCriterionStatusSchema.optional(),
       kind: completionCriterionKindSchema.optional()
     });
-    completionListResultSchema = z16.object({
-      taskId: z16.string().min(1),
-      criteria: z16.array(completionCriterionEvaluationSchema),
+    completionListResultSchema = z17.object({
+      taskId: z17.string().min(1),
+      criteria: z17.array(completionCriterionEvaluationSchema),
       totals: completionTotalsSchema
     });
-    completionEvaluateParamsSchema = z16.object({
-      taskId: z16.string().min(1),
-      includeContext: z16.boolean().optional(),
-      limit: z16.number().int().positive().optional(),
-      since: z16.string().min(1).optional(),
-      relationDepth: z16.number().int().nonnegative().optional()
+    completionEvaluateParamsSchema = z17.object({
+      taskId: z17.string().min(1),
+      includeContext: z17.boolean().optional(),
+      limit: z17.number().int().positive().optional(),
+      since: z17.string().min(1).optional(),
+      relationDepth: z17.number().int().nonnegative().optional()
     });
-    completionProjectionRepairErrorSchema = z16.object({
+    completionProjectionRepairErrorSchema = z17.object({
       code: completionProjectionRepairErrorCodeSchema,
-      message: z16.string().min(1),
-      taskId: z16.string().min(1),
-      acId: z16.string().min(1).optional(),
-      evidenceAtomId: z16.string().min(1).optional()
+      message: z17.string().min(1),
+      taskId: z17.string().min(1),
+      acId: z17.string().min(1).optional(),
+      evidenceAtomId: z17.string().min(1).optional()
     });
-    completionProjectionRepairParamsSchema = z16.object({
-      taskId: z16.string().min(1),
-      dryRun: z16.boolean().optional()
+    completionProjectionRepairParamsSchema = z17.object({
+      taskId: z17.string().min(1),
+      dryRun: z17.boolean().optional()
     });
-    completionProjectionRepairResultSchema = z16.object({
-      taskId: z16.string().min(1),
-      repaired: z16.boolean(),
-      dryRun: z16.boolean(),
-      staleBefore: z16.boolean(),
-      staleAfter: z16.boolean(),
-      errors: z16.array(completionProjectionRepairErrorSchema)
+    completionProjectionRepairResultSchema = z17.object({
+      taskId: z17.string().min(1),
+      repaired: z17.boolean(),
+      dryRun: z17.boolean(),
+      staleBefore: z17.boolean(),
+      staleAfter: z17.boolean(),
+      errors: z17.array(completionProjectionRepairErrorSchema)
     });
   }
 });
@@ -12693,7 +12816,7 @@ var init_taxonomy = __esm({
 });
 
 // packages/contracts/src/templates/manifest.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var TEMPLATE_KINDS, TEMPLATE_SUBSTITUTIONS, TEMPLATE_UPDATE_STRATEGIES, PLACEHOLDER_SOURCES, PlaceholderSpecSchema, TemplateManifestEntrySchema;
 var init_manifest2 = __esm({
   "packages/contracts/src/templates/manifest.ts"() {
@@ -12714,85 +12837,85 @@ var init_manifest2 = __esm({
       "tool-resolver",
       "literal"
     ];
-    PlaceholderSpecSchema = z17.object({
+    PlaceholderSpecSchema = z18.object({
       /**
        * Placeholder identifier as it appears in the template body
        * (e.g. `NODE_VERSION` matches `{{NODE_VERSION}}`).
        */
-      name: z17.string().min(1, "placeholder name must be non-empty"),
+      name: z18.string().min(1, "placeholder name must be non-empty"),
       /** Resolver source the installer consults for this placeholder. */
-      source: z17.enum(PLACEHOLDER_SOURCES),
+      source: z18.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: z17.string().min(1, "placeholder sourcePath must be non-empty"),
+      sourcePath: z18.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: z17.union([z17.string(), z17.number(), z17.boolean(), z17.null()]).optional()
+      defaultValue: z18.union([z18.string(), z18.number(), z18.boolean(), z18.null()]).optional()
     });
-    TemplateManifestEntrySchema = z17.object({
+    TemplateManifestEntrySchema = z18.object({
       /** Stable identifier for this template entry. */
-      id: z17.string().min(1, "id must be non-empty"),
+      id: z18.string().min(1, "id must be non-empty"),
       /** Category of file this template represents. */
-      kind: z17.enum(TEMPLATE_KINDS),
+      kind: z18.enum(TEMPLATE_KINDS),
       /** Repo-relative path of the template source file. */
-      sourcePath: z17.string().min(1, "sourcePath must be non-empty"),
+      sourcePath: z18.string().min(1, "sourcePath must be non-empty"),
       /** Project-relative path where the rendered template installs. */
-      installPath: z17.string().min(1, "installPath must be non-empty"),
+      installPath: z18.string().min(1, "installPath must be non-empty"),
       /** Substitution strategy the installer applies to `sourcePath`. */
-      substitution: z17.enum(TEMPLATE_SUBSTITUTIONS),
+      substitution: z18.enum(TEMPLATE_SUBSTITUTIONS),
       /** Declared placeholders this template requires. May be empty. */
-      placeholders: z17.array(PlaceholderSpecSchema),
+      placeholders: z18.array(PlaceholderSpecSchema),
       /** Reconciliation policy on upgrade. */
-      updateStrategy: z17.enum(TEMPLATE_UPDATE_STRATEGIES)
+      updateStrategy: z18.enum(TEMPLATE_UPDATE_STRATEGIES)
     });
   }
 });
 
 // packages/contracts/src/validator/index.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var VALIDATOR_ID_REGEX, validatorFindingSchema, validatorAttestationSchema, validatorRejectionSchema, validatorVerdictSchema;
 var init_validator = __esm({
   "packages/contracts/src/validator/index.ts"() {
     "use strict";
     VALIDATOR_ID_REGEX = /^validator-[a-z0-9][a-z0-9-]*$/;
-    validatorFindingSchema = z18.object({
-      acId: z18.string().min(1, "acId must be non-empty"),
-      status: z18.enum(["pass", "fail", "inconclusive"]),
-      reasoning: z18.string().min(1, "reasoning must be non-empty"),
-      evidenceRefs: z18.array(z18.string()).optional(),
-      checkedAt: z18.string().min(1, "checkedAt must be a non-empty ISO-8601 string")
-    });
-    validatorAttestationSchema = z18.object({
-      verdict: z18.literal("attest"),
-      taskId: z18.string().min(1),
-      validatorId: z18.string().regex(VALIDATOR_ID_REGEX, "validatorId must match the pattern validator-<discriminator>"),
-      findings: z18.array(validatorFindingSchema).min(1, "attestation must contain at least one finding").refine(
+    validatorFindingSchema = z19.object({
+      acId: z19.string().min(1, "acId must be non-empty"),
+      status: z19.enum(["pass", "fail", "inconclusive"]),
+      reasoning: z19.string().min(1, "reasoning must be non-empty"),
+      evidenceRefs: z19.array(z19.string()).optional(),
+      checkedAt: z19.string().min(1, "checkedAt must be a non-empty ISO-8601 string")
+    });
+    validatorAttestationSchema = z19.object({
+      verdict: z19.literal("attest"),
+      taskId: z19.string().min(1),
+      validatorId: z19.string().regex(VALIDATOR_ID_REGEX, "validatorId must match the pattern validator-<discriminator>"),
+      findings: z19.array(validatorFindingSchema).min(1, "attestation must contain at least one finding").refine(
         (findings) => findings.every((f) => f.status === "pass"),
         'attestation requires every finding to have status="pass"'
       ),
-      summary: z18.string().optional(),
-      attestedAt: z18.string().min(1),
-      schemaVersion: z18.literal("1")
-    });
-    validatorRejectionSchema = z18.object({
-      verdict: z18.literal("reject"),
-      taskId: z18.string().min(1),
-      validatorId: z18.string().regex(VALIDATOR_ID_REGEX, "validatorId must match the pattern validator-<discriminator>"),
-      findings: z18.array(validatorFindingSchema).min(1, "rejection must contain at least one finding").refine(
+      summary: z19.string().optional(),
+      attestedAt: z19.string().min(1),
+      schemaVersion: z19.literal("1")
+    });
+    validatorRejectionSchema = z19.object({
+      verdict: z19.literal("reject"),
+      taskId: z19.string().min(1),
+      validatorId: z19.string().regex(VALIDATOR_ID_REGEX, "validatorId must match the pattern validator-<discriminator>"),
+      findings: z19.array(validatorFindingSchema).min(1, "rejection must contain at least one finding").refine(
         (findings) => findings.some((f) => f.status !== "pass"),
         'rejection requires at least one finding with status "fail" or "inconclusive"'
       ),
-      summary: z18.string().min(1, "rejection summary must be non-empty"),
-      remediationHints: z18.array(z18.string()).optional(),
-      rejectedAt: z18.string().min(1),
-      schemaVersion: z18.literal("1")
+      summary: z19.string().min(1, "rejection summary must be non-empty"),
+      remediationHints: z19.array(z19.string()).optional(),
+      rejectedAt: z19.string().min(1),
+      schemaVersion: z19.literal("1")
     });
-    validatorVerdictSchema = z18.discriminatedUnion("verdict", [
+    validatorVerdictSchema = z19.discriminatedUnion("verdict", [
       validatorAttestationSchema,
       validatorRejectionSchema
     ]);
@@ -12816,6 +12939,7 @@ var init_src = __esm({
     init_identity();
     init_operations_registry();
     init_provenance();
+    init_read();
     init_docs_taxonomy();
     init_engine_result();
     init_enums();
@@ -12837,6 +12961,7 @@ var init_src = __esm({
     init_docs();
     init_operations();
     init_nexus_scope_map();
+    init_output_contracts_data();
     init_params();
     init_tasks();
     init_peer();
@@ -26874,7 +26999,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 z19.never();
+      return z20.never();
     }
     throw new Error("not is not supported in Zod (except { not: {} } for never)");
   }
@@ -26896,7 +27021,7 @@ function convertBaseSchema(schema, ctx) {
       return ctx.refs.get(refPath);
     }
     if (ctx.processing.has(refPath)) {
-      return z19.lazy(() => {
+      return z20.lazy(() => {
         if (!ctx.refs.has(refPath)) {
           throw new Error(`Circular reference not resolved: ${refPath}`);
         }
@@ -26913,25 +27038,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 z19.null();
+      return z20.null();
     }
     if (enumValues.length === 0) {
-      return z19.never();
+      return z20.never();
     }
     if (enumValues.length === 1) {
-      return z19.literal(enumValues[0]);
+      return z20.literal(enumValues[0]);
     }
     if (enumValues.every((v) => typeof v === "string")) {
-      return z19.enum(enumValues);
+      return z20.enum(enumValues);
     }
-    const literalSchemas = enumValues.map((v) => z19.literal(v));
+    const literalSchemas = enumValues.map((v) => z20.literal(v));
     if (literalSchemas.length < 2) {
       return literalSchemas[0];
     }
-    return z19.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
+    return z20.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
   }
   if (schema.const !== void 0) {
-    return z19.literal(schema.const);
+    return z20.literal(schema.const);
   }
   const type = schema.type;
   if (Array.isArray(type)) {
@@ -26940,68 +27065,68 @@ function convertBaseSchema(schema, ctx) {
       return convertBaseSchema(typeSchema, ctx);
     });
     if (typeSchemas.length === 0) {
-      return z19.never();
+      return z20.never();
     }
     if (typeSchemas.length === 1) {
       return typeSchemas[0];
     }
-    return z19.union(typeSchemas);
+    return z20.union(typeSchemas);
   }
   if (!type) {
-    return z19.any();
+    return z20.any();
   }
   let zodSchema2;
   switch (type) {
     case "string": {
-      let stringSchema = z19.string();
+      let stringSchema = z20.string();
       if (schema.format) {
         const format = schema.format;
         if (format === "email") {
-          stringSchema = stringSchema.check(z19.email());
+          stringSchema = stringSchema.check(z20.email());
         } else if (format === "uri" || format === "uri-reference") {
-          stringSchema = stringSchema.check(z19.url());
+          stringSchema = stringSchema.check(z20.url());
         } else if (format === "uuid" || format === "guid") {
-          stringSchema = stringSchema.check(z19.uuid());
+          stringSchema = stringSchema.check(z20.uuid());
         } else if (format === "date-time") {
-          stringSchema = stringSchema.check(z19.iso.datetime());
+          stringSchema = stringSchema.check(z20.iso.datetime());
         } else if (format === "date") {
-          stringSchema = stringSchema.check(z19.iso.date());
+          stringSchema = stringSchema.check(z20.iso.date());
         } else if (format === "time") {
-          stringSchema = stringSchema.check(z19.iso.time());
+          stringSchema = stringSchema.check(z20.iso.time());
         } else if (format === "duration") {
-          stringSchema = stringSchema.check(z19.iso.duration());
+          stringSchema = stringSchema.check(z20.iso.duration());
         } else if (format === "ipv4") {
-          stringSchema = stringSchema.check(z19.ipv4());
+          stringSchema = stringSchema.check(z20.ipv4());
         } else if (format === "ipv6") {
-          stringSchema = stringSchema.check(z19.ipv6());
+          stringSchema = stringSchema.check(z20.ipv6());
         } else if (format === "mac") {
-          stringSchema = stringSchema.check(z19.mac());
+          stringSchema = stringSchema.check(z20.mac());
         } else if (format === "cidr") {
-          stringSchema = stringSchema.check(z19.cidrv4());
+          stringSchema = stringSchema.check(z20.cidrv4());
         } else if (format === "cidr-v6") {
-          stringSchema = stringSchema.check(z19.cidrv6());
+          stringSchema = stringSchema.check(z20.cidrv6());
         } else if (format === "base64") {
-          stringSchema = stringSchema.check(z19.base64());
+          stringSchema = stringSchema.check(z20.base64());
         } else if (format === "base64url") {
-          stringSchema = stringSchema.check(z19.base64url());
+          stringSchema = stringSchema.check(z20.base64url());
         } else if (format === "e164") {
-          stringSchema = stringSchema.check(z19.e164());
+          stringSchema = stringSchema.check(z20.e164());
         } else if (format === "jwt") {
-          stringSchema = stringSchema.check(z19.jwt());
+          stringSchema = stringSchema.check(z20.jwt());
         } else if (format === "emoji") {
-          stringSchema = stringSchema.check(z19.emoji());
+          stringSchema = stringSchema.check(z20.emoji());
         } else if (format === "nanoid") {
-          stringSchema = stringSchema.check(z19.nanoid());
+          stringSchema = stringSchema.check(z20.nanoid());
         } else if (format === "cuid") {
-          stringSchema = stringSchema.check(z19.cuid());
+          stringSchema = stringSchema.check(z20.cuid());
         } else if (format === "cuid2") {
-          stringSchema = stringSchema.check(z19.cuid2());
+          stringSchema = stringSchema.check(z20.cuid2());
         } else if (format === "ulid") {
-          stringSchema = stringSchema.check(z19.ulid());
+          stringSchema = stringSchema.check(z20.ulid());
         } else if (format === "xid") {
-          stringSchema = stringSchema.check(z19.xid());
+          stringSchema = stringSchema.check(z20.xid());
         } else if (format === "ksuid") {
-          stringSchema = stringSchema.check(z19.ksuid());
+          stringSchema = stringSchema.check(z20.ksuid());
         }
       }
       if (typeof schema.minLength === "number") {
@@ -27018,7 +27143,7 @@ function convertBaseSchema(schema, ctx) {
     }
     case "number":
     case "integer": {
-      let numberSchema = type === "integer" ? z19.number().int() : z19.number();
+      let numberSchema = type === "integer" ? z20.number().int() : z20.number();
       if (typeof schema.minimum === "number") {
         numberSchema = numberSchema.min(schema.minimum);
       }
@@ -27042,11 +27167,11 @@ function convertBaseSchema(schema, ctx) {
       break;
     }
     case "boolean": {
-      zodSchema2 = z19.boolean();
+      zodSchema2 = z20.boolean();
       break;
     }
     case "null": {
-      zodSchema2 = z19.null();
+      zodSchema2 = z20.null();
       break;
     }
     case "object": {
@@ -27059,14 +27184,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) : z19.any();
+        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z20.any();
         if (Object.keys(shape).length === 0) {
-          zodSchema2 = z19.record(keySchema, valueSchema);
+          zodSchema2 = z20.record(keySchema, valueSchema);
           break;
         }
-        const objectSchema2 = z19.object(shape).passthrough();
-        const recordSchema = z19.looseRecord(keySchema, valueSchema);
-        zodSchema2 = z19.intersection(objectSchema2, recordSchema);
+        const objectSchema2 = z20.object(shape).passthrough();
+        const recordSchema = z20.looseRecord(keySchema, valueSchema);
+        zodSchema2 = z20.intersection(objectSchema2, recordSchema);
         break;
       }
       if (schema.patternProperties) {
@@ -27075,28 +27200,28 @@ function convertBaseSchema(schema, ctx) {
         const looseRecords = [];
         for (const pattern of patternKeys) {
           const patternValue = convertSchema(patternProps[pattern], ctx);
-          const keySchema = z19.string().regex(new RegExp(pattern));
-          looseRecords.push(z19.looseRecord(keySchema, patternValue));
+          const keySchema = z20.string().regex(new RegExp(pattern));
+          looseRecords.push(z20.looseRecord(keySchema, patternValue));
         }
         const schemasToIntersect = [];
         if (Object.keys(shape).length > 0) {
-          schemasToIntersect.push(z19.object(shape).passthrough());
+          schemasToIntersect.push(z20.object(shape).passthrough());
         }
         schemasToIntersect.push(...looseRecords);
         if (schemasToIntersect.length === 0) {
-          zodSchema2 = z19.object({}).passthrough();
+          zodSchema2 = z20.object({}).passthrough();
         } else if (schemasToIntersect.length === 1) {
           zodSchema2 = schemasToIntersect[0];
         } else {
-          let result = z19.intersection(schemasToIntersect[0], schemasToIntersect[1]);
+          let result = z20.intersection(schemasToIntersect[0], schemasToIntersect[1]);
           for (let i = 2; i < schemasToIntersect.length; i++) {
-            result = z19.intersection(result, schemasToIntersect[i]);
+            result = z20.intersection(result, schemasToIntersect[i]);
           }
           zodSchema2 = result;
         }
         break;
       }
-      const objectSchema = z19.object(shape);
+      const objectSchema = z20.object(shape);
       if (schema.additionalProperties === false) {
         zodSchema2 = objectSchema.strict();
       } else if (typeof schema.additionalProperties === "object") {
@@ -27113,33 +27238,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 = z19.tuple(tupleItems).rest(rest);
+          zodSchema2 = z20.tuple(tupleItems).rest(rest);
         } else {
-          zodSchema2 = z19.tuple(tupleItems);
+          zodSchema2 = z20.tuple(tupleItems);
         }
         if (typeof schema.minItems === "number") {
-          zodSchema2 = zodSchema2.check(z19.minLength(schema.minItems));
+          zodSchema2 = zodSchema2.check(z20.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema2 = zodSchema2.check(z19.maxLength(schema.maxItems));
+          zodSchema2 = zodSchema2.check(z20.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 = z19.tuple(tupleItems).rest(rest);
+          zodSchema2 = z20.tuple(tupleItems).rest(rest);
         } else {
-          zodSchema2 = z19.tuple(tupleItems);
+          zodSchema2 = z20.tuple(tupleItems);
         }
         if (typeof schema.minItems === "number") {
-          zodSchema2 = zodSchema2.check(z19.minLength(schema.minItems));
+          zodSchema2 = zodSchema2.check(z20.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema2 = zodSchema2.check(z19.maxLength(schema.maxItems));
+          zodSchema2 = zodSchema2.check(z20.maxLength(schema.maxItems));
         }
       } else if (items !== void 0) {
         const element = convertSchema(items, ctx);
-        let arraySchema = z19.array(element);
+        let arraySchema = z20.array(element);
         if (typeof schema.minItems === "number") {
           arraySchema = arraySchema.min(schema.minItems);
         }
@@ -27148,7 +27273,7 @@ function convertBaseSchema(schema, ctx) {
         }
         zodSchema2 = arraySchema;
       } else {
-        zodSchema2 = z19.array(z19.any());
+        zodSchema2 = z20.array(z20.any());
       }
       break;
     }
@@ -27165,37 +27290,37 @@ function convertBaseSchema(schema, ctx) {
 }
 function convertSchema(schema, ctx) {
   if (typeof schema === "boolean") {
-    return schema ? z19.any() : z19.never();
+    return schema ? z20.any() : z20.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 = z19.union(options);
-    baseSchema = hasExplicitType ? z19.intersection(baseSchema, anyOfUnion) : anyOfUnion;
+    const anyOfUnion = z20.union(options);
+    baseSchema = hasExplicitType ? z20.intersection(baseSchema, anyOfUnion) : anyOfUnion;
   }
   if (schema.oneOf && Array.isArray(schema.oneOf)) {
     const options = schema.oneOf.map((s) => convertSchema(s, ctx));
-    const oneOfUnion = z19.xor(options);
-    baseSchema = hasExplicitType ? z19.intersection(baseSchema, oneOfUnion) : oneOfUnion;
+    const oneOfUnion = z20.xor(options);
+    baseSchema = hasExplicitType ? z20.intersection(baseSchema, oneOfUnion) : oneOfUnion;
   }
   if (schema.allOf && Array.isArray(schema.allOf)) {
     if (schema.allOf.length === 0) {
-      baseSchema = hasExplicitType ? baseSchema : z19.any();
+      baseSchema = hasExplicitType ? baseSchema : z20.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 = z19.intersection(result, convertSchema(schema.allOf[i], ctx));
+        result = z20.intersection(result, convertSchema(schema.allOf[i], ctx));
       }
       baseSchema = result;
     }
   }
   if (schema.nullable === true && ctx.version === "openapi-3.0") {
-    baseSchema = z19.nullable(baseSchema);
+    baseSchema = z20.nullable(baseSchema);
   }
   if (schema.readOnly === true) {
-    baseSchema = z19.readonly(baseSchema);
+    baseSchema = z20.readonly(baseSchema);
   }
   const extraMeta = {};
   const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
@@ -27222,7 +27347,7 @@ function convertSchema(schema, ctx) {
 }
 function fromJSONSchema(schema, params) {
   if (typeof schema === "boolean") {
-    return schema ? z19.any() : z19.never();
+    return schema ? z20.any() : z20.never();
   }
   const version2 = detectVersion(schema, params?.defaultTarget);
   const defs = schema.$defs || schema.definitions || {};
@@ -27236,14 +27361,14 @@ function fromJSONSchema(schema, params) {
   };
   return convertSchema(schema, ctx);
 }
-var z19, RECOGNIZED_KEYS;
+var z20, 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();
-    z19 = {
+    z20 = {
       ...schemas_exports2,
       ...checks_exports2,
       iso: iso_exports