@cleocode/cleo 2026.6.7 → 2026.6.8

package/dist/cli/index.js

@@ -9680,7 +9680,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,
@@ -9704,6 +9704,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",
@@ -11410,7 +11416,8 @@ var init_provenance = __esm({
       "superseded-by",
       "related-task",
       "linked-decision",
-      "derived-from"
+      "derived-from",
+      "shares-topic"
     ];
     DOC_LIFECYCLE_STATUSES = [
       "active",
@@ -11485,6 +11492,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"() {
@@ -11640,72 +11682,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,
@@ -11752,58 +11794,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,
@@ -12363,7 +12405,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"() {
@@ -12371,10 +12413,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",
@@ -12383,7 +12425,7 @@ var init_workgraph = __esm({
       "documented",
       "nexusImpact"
     ]);
-    workGraphRelationKindSchema = z10.enum([
+    workGraphRelationKindSchema = z11.enum([
       "contains",
       "depends_on",
       "blocks",
@@ -12391,317 +12433,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
           ])
@@ -13083,31 +13125,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();
@@ -13120,7 +13162,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"() {
@@ -13163,20 +13205,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. */
@@ -13184,20 +13226,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`). */
@@ -13207,11 +13249,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. */
@@ -13219,47 +13261,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. */
@@ -13276,27 +13318,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. */
@@ -13352,52 +13394,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(),
@@ -13406,7 +13448,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()
     });
   }
 });
@@ -13419,52 +13461,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,
@@ -13475,12 +13517,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",
@@ -13493,47 +13535,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",
@@ -13541,68 +13583,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",
@@ -13610,77 +13652,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)
     });
   }
 });
@@ -14191,7 +14233,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"() {
@@ -14212,85 +14254,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
     ]);
@@ -14314,6 +14356,7 @@ var init_src2 = __esm({
     init_identity();
     init_operations_registry();
     init_provenance();
+    init_read();
     init_docs_taxonomy();
     init_engine_result();
     init_enums();
@@ -19190,6 +19233,7 @@ Recovery command: cleo docs update {slug} --file <your-file>`;
           ownerId,
           file: filePath,
           url,
+          content: inlineContent,
           desc: description,
           labels: rawLabels,
           attachedBy: rawAttachedBy,
@@ -19201,13 +19245,23 @@ Recovery command: cleo docs update {slug} --file <your-file>`;
         if (!ownerId) {
           return lafsError("E_INVALID_INPUT", "ownerId is required", "add");
         }
-        if (!filePath && !url) {
+        const hasContent = typeof inlineContent === "string";
+        const sourceCount = (filePath ? 1 : 0) + (url ? 1 : 0) + (hasContent ? 1 : 0);
+        if (sourceCount === 0) {
           return lafsError(
             "E_INVALID_INPUT",
-            "Provide either a file path (positional or --file) or --url",
+            "Provide a file path (positional or --file), --url, or --content <text>",
             "add"
           );
         }
+        if (sourceCount > 1) {
+          return lafsError(
+            "E_INVALID_INPUT",
+            "--file, --url, and --content are mutually exclusive \u2014 provide exactly one source",
+            "add",
+            'Use `cleo docs add <owner> ./file.md` OR `--url <url>` OR `--content "<text>"` (not more than one).'
+          );
+        }
         let slug;
         if (rawSlug !== void 0) {
           let candidate = rawSlug;
@@ -19544,6 +19598,126 @@ Recovery command: cleo docs update {slug} --file <your-file>`;
             "add"
           );
         }
+        if (hasContent) {
+          const bytes = Buffer.from(inlineContent, "utf-8");
+          if (type2 !== void 0) {
+            let registry;
+            try {
+              registry = DocKindRegistry.load(getProjectRoot5());
+            } catch {
+              registry = void 0;
+            }
+            const check = validateDocBody(type2, inlineContent, registry);
+            if (!check.ok) {
+              const missingList = check.missing.join(", ");
+              if (strictMode === true) {
+                if (slug !== void 0) releaseReservedSlug(slug);
+                return lafsError(
+                  "E_DOC_SCHEMA_MISMATCH",
+                  `body for kind '${type2}' is missing required section(s): ${missingList}`,
+                  "add",
+                  `Add the missing H2 section(s) \u2014 '## ${check.missing[0] ?? ""}' \u2014 then retry. Pass --strict=false (default) to surface as an advisory warning instead of an error.`,
+                  { kind: type2, missing: check.missing, strict: true }
+                );
+              }
+              pushWarning({
+                code: "W_DOC_SCHEMA_MISMATCH",
+                message: `body for kind '${type2}' is missing required section(s): ${missingList}. Add '--strict' to fail on schema violations.`
+              });
+            }
+          }
+          const mime = "text/markdown";
+          const attachment = {
+            kind: "blob",
+            mime,
+            ...description ? { description } : {},
+            ...labels ? { labels } : {}
+          };
+          let meta;
+          try {
+            meta = await store.put(
+              bytes,
+              attachment,
+              ownerType,
+              ownerId,
+              attachedBy,
+              void 0,
+              extras
+            );
+          } catch (err) {
+            if (slug !== void 0) releaseReservedSlug(slug);
+            if (err instanceof SlugCollisionError) {
+              return {
+                success: false,
+                error: {
+                  code: "E_SLUG_RESERVED",
+                  message: SLUG_COLLISION_GUIDANCE.replaceAll("{slug}", err.slug ?? ""),
+                  fix: `cleo docs update ${err.slug ?? "<slug>"} --content "..."`,
+                  details: {
+                    suggestions: err.suggestions,
+                    aliases: ["E_SLUG_TAKEN"]
+                  }
+                }
+              };
+            }
+            throw err;
+          }
+          if (adrNumber !== void 0 && slug !== void 0) consumeReservedSlug(slug);
+          const blobName = slug ?? meta.sha256.slice(0, 12);
+          let backend = "llmtxt";
+          try {
+            const blobMirror = createAttachmentBlobStore(getProjectRoot5());
+            const mirrorResult = await blobMirror.put(ownerId, {
+              name: blobName,
+              data: new Uint8Array(bytes),
+              contentType: mime
+            });
+            backend = mirrorResult.backend;
+          } catch {
+            backend = await currentAttachmentBackend();
+          }
+          import("@cleocode/core/internal").then(
+            ({ ensureLlmtxtNode }) => ensureLlmtxtNode(getProjectRoot5(), meta.sha256, `${ownerType}:${ownerId}`, blobName)
+          ).catch(() => {
+          });
+          const contentPayload = {
+            kind: "doc-attachment",
+            attachmentId: meta.id,
+            ownerId,
+            addedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            ...slug !== void 0 ? { slug } : {},
+            ...type2 !== void 0 ? { type: type2 } : {}
+          };
+          emitDocAttachmentObservation(contentPayload, getProjectRoot5());
+          try {
+            writeAuditEntry(getProjectRoot5(), {
+              op: "docs.add",
+              slug,
+              type: type2,
+              attachmentId: meta.id,
+              sha256: meta.sha256,
+              ownerId,
+              summary: `Added inline doc '${slug ?? meta.sha256.slice(0, 12)}'${type2 ? ` of type '${type2}'` : ""} for owner ${ownerId}`
+            });
+          } catch {
+          }
+          return lafsSuccess(
+            {
+              attachmentId: meta.id,
+              sha256: meta.sha256,
+              refCount: meta.refCount,
+              kind: "blob",
+              ownerId,
+              ownerType,
+              // Cast: core returns 'llmtxt'|'legacy'; contracts uses 'legacy'|'llmstxt-v2' (T1529)
+              attachmentBackend: backend,
+              ...slug !== void 0 ? { slug } : {},
+              ...type2 !== void 0 ? { type: type2 } : {},
+              ...adrNumber !== void 0 ? { adrNumber } : {}
+            },
+            "add"
+          );
+        }
         if (url) {
           const attachment = {
             kind: "url",
@@ -28233,8 +28407,8 @@ async function loadPlaybookByName(name) {
     return null;
   }
   try {
-    const { getProjectRoot: getProjectRoot58 } = await import("@cleocode/core/internal");
-    const projectRoot = __playbookRuntimeOverrides.projectRoot ?? getProjectRoot58();
+    const { getProjectRoot: getProjectRoot59 } = await import("@cleocode/core/internal");
+    const projectRoot = __playbookRuntimeOverrides.projectRoot ?? getProjectRoot59();
     const resolved = resolvePlaybook(name, {
       projectRoot,
       globalPlaybooksDir: __playbookRuntimeOverrides.globalPlaybooksDir,
@@ -28278,8 +28452,8 @@ async function acquireDb() {
 async function buildDefaultDispatcher() {
   if (__playbookRuntimeOverrides.dispatcher) return __playbookRuntimeOverrides.dispatcher;
   const { orchestrateSpawnExecute: orchestrateSpawnExecute2 } = await import("@cleocode/runtime/gateway");
-  const { getProjectRoot: getProjectRoot58, createToolGuard, runSkillNodeOrSpawn } = await import("@cleocode/core/internal");
-  const projectRoot = getProjectRoot58();
+  const { getProjectRoot: getProjectRoot59, createToolGuard, runSkillNodeOrSpawn } = await import("@cleocode/core/internal");
+  const projectRoot = getProjectRoot59();
   const tools = createToolGuard({ allowedRoots: [projectRoot] });
   const spawn5 = async (input2) => {
     const result = await orchestrateSpawnExecute2(
@@ -28476,8 +28650,8 @@ var init_playbook2 = __esm({
             projectRoot = __playbookRuntimeOverrides.projectRoot;
           } else {
             try {
-              const { getProjectRoot: getProjectRoot58 } = await import("@cleocode/core/internal");
-              projectRoot = getProjectRoot58();
+              const { getProjectRoot: getProjectRoot59 } = await import("@cleocode/core/internal");
+              projectRoot = getProjectRoot59();
             } catch {
               projectRoot = void 0;
             }
@@ -28541,14 +28715,14 @@ var init_playbook2 = __esm({
         const dispatcher = await buildDefaultDispatcher();
         let result;
         try {
-          const { getProjectRoot: getProjectRoot58 } = await import("@cleocode/core/internal");
+          const { getProjectRoot: getProjectRoot59 } = await import("@cleocode/core/internal");
           const opts = {
             db,
             playbook: parsed.definition,
             playbookHash: parsed.sourceHash,
             initialContext,
             dispatcher,
-            projectRoot: getProjectRoot58()
+            projectRoot: getProjectRoot59()
           };
           if (__playbookRuntimeOverrides.approvalSecret !== void 0) {
             opts.approvalSecret = __playbookRuntimeOverrides.approvalSecret;
@@ -35258,11 +35432,11 @@ var init_security = __esm({
 });
 
 // packages/cleo/src/dispatch/middleware/sanitizer.ts
-function createSanitizer(getProjectRoot58) {
+function createSanitizer(getProjectRoot59) {
   return async (req, next) => {
     if (req.params) {
       try {
-        const root = getProjectRoot58 ? getProjectRoot58() : void 0;
+        const root = getProjectRoot59 ? getProjectRoot59() : void 0;
         req.params = sanitizeParams(req.params, root, {
           domain: req.domain,
           operation: req.operation
@@ -41093,9 +41267,9 @@ var init_backup = __esm({
       async run({ args }) {
         const scope = args.scope;
         const { packBundle } = await import("@cleocode/core/store/backup-pack.js");
-        const { getProjectRoot: getProjectRoot58 } = await import("@cleocode/core");
+        const { getProjectRoot: getProjectRoot59 } = await import("@cleocode/core");
         const includesProject = scope === "project" || scope === "all";
-        const projectRoot = includesProject ? getProjectRoot58() : void 0;
+        const projectRoot = includesProject ? getProjectRoot59() : void 0;
         let passphrase;
         if (args.encrypt === true) {
           passphrase = process.env["CLEO_BACKUP_PASSPHRASE"];
@@ -41171,12 +41345,12 @@ var init_backup = __esm({
       },
       async run({ args }) {
         const bundlePath = args.bundle;
-        const { getProjectRoot: getProjectRoot58, getCleoHome: getCleoHome6, getCleoVersion } = await import("@cleocode/core");
+        const { getProjectRoot: getProjectRoot59, getCleoHome: getCleoHome6, getCleoVersion } = await import("@cleocode/core");
         const { BundleError, cleanupStaging, unpackBundle } = await import("@cleocode/core/store/backup-unpack.js");
         const { regenerateConfigJson, regenerateProjectContextJson, regenerateProjectInfoJson } = await import("@cleocode/core/store/regenerators.js");
         const { regenerateAndCompare } = await import("@cleocode/core/store/restore-json-merge.js");
         const { buildConflictReport, writeConflictReport } = await import("@cleocode/core/store/restore-conflict-report.js");
-        const projectRoot = getProjectRoot58();
+        const projectRoot = getProjectRoot59();
         if (args.force !== true) {
           const existing = checkForExistingData(projectRoot, getCleoHome6());
           if (existing.length > 0) {
@@ -47234,14 +47408,19 @@ var init_graph2 = __esm({
         format: {
           type: "string",
           description: "Output format: json (default) | dot."
+        },
+        backlinks: {
+          type: "boolean",
+          description: "Hydrate the persisted docs_wikilinks backlink graph (T11826) \u2014 adds bidirectional shares-topic doc\u2194doc edges and any persisted backlinks not surfaced by the on-the-fly BFS. Obsidian-grade graph on existing data."
         }
       },
       async run({ args }) {
         const root = String(args.root);
         const depth = parseDepth(args.depth);
         const format = parseFormat(args.format);
+        const hydrateWikilinks = Boolean(args.backlinks);
         try {
-          const graph = await buildDocProvenanceGraph({ root, depth });
+          const graph = await buildDocProvenanceGraph({ root, depth, hydrateWikilinks });
           const payload = { ...graph };
           if (format === "dot") {
             payload["dot"] = renderProvenanceGraphAsDot(graph);
@@ -48062,6 +48241,7 @@ __export(docs_exports, {
 import { appendFile, mkdir as mkdir3, readdir, readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname8, isAbsolute as isAbsolute2, join as join21, resolve as resolve5 } from "node:path";
 import { pushWarning as pushWarning3 } from "@cleocode/core";
+import { createDocsReadModel as createDocsReadModel2 } from "@cleocode/core/docs/docs-read-model";
 import {
   CleoError as CleoError4,
   CounterMismatchError,
@@ -48081,6 +48261,15 @@ async function dispatchDocsRaw(gateway, operation, params) {
   handleRawError(response, { command: "docs", operation: `docs.${operation}` });
   return response.data;
 }
+async function readDocBodyFromStdin() {
+  if (process.stdin.isTTY) return "";
+  process.stdin.setEncoding("utf-8");
+  let buf = "";
+  for await (const chunk of process.stdin) {
+    buf += chunk;
+  }
+  return buf.replace(/\r?\n$/, "");
+}
 async function getScriptNames(projectRoot) {
   const scriptsDir = join21(projectRoot, "scripts");
   try {
@@ -48231,7 +48420,7 @@ var init_docs3 = __esm({
     addCommand6 = defineCommand({
       meta: {
         name: "add",
-        description: 'Attach a local file or remote URL to a CLEO entity (task, session, observation). Owner type is inferred from the ID prefix: T### \u2192 task, ses_* \u2192 session, O-* \u2192 observation. Use --slug to set a human-friendly alias (unique per project) (T9636).\n\nPositional arguments:\n  <owner-id>             Owner entity ID (T###, ses_*, O-*) \u2014 required\n  [file]                 Local file path to attach \u2014 optional when --url is set\n\nNamed arguments:\n  --url <url>            Remote URL to attach (instead of a local file)\n  --desc <text>          Free-text description of this attachment\n  --labels <csv>         Comma-separated labels (e.g. rfc,spec)\n  --attached-by <name>   Agent identity that created the attachment (default: "human")\n  --slug <kebab>         Human-friendly alias, unique per project (T9636)\n  --title <text>         Human-readable title \u2014 REQUIRED for --type adr when --slug is omitted (T10360)\n  --type <kind>          Taxonomy classification \u2014 run `cleo docs schema` for kinds\n  --allow-similar        Bypass the slug-similarity warn \u2014 every bypass is audited\n                         to .cleo/audit/similar-bypass.jsonl (T10361)\n  --strict               Enforce body-schema (requiredSections) \u2014 fail with\n                         E_DOC_SCHEMA_MISMATCH instead of warning (T10160)\n' + docsOutputFlagHelp + "\n\nValidation behaviors:\n  \u2022 Unknown flags \u2192 E_UNKNOWN_FLAG with did-you-mean suggestions (T10359)\n  \u2022 Slug collision \u2192 E_SLUG_RESERVED + 3 alternative slugs (T10386)\n  \u2022 Near-duplicate slug \u2192 W_SLUG_SIMILAR warning unless --allow-similar (T10361)\n  \u2022 For --type adr without --slug, slug auto-allocates as `adr-NNN-<kebab-title>` via the\n    central allocator (T10360 \u2014 closes T10153). --title is required in this case."
+        description: "Attach a local file or remote URL to a CLEO entity (task, session, observation). Owner type is inferred from the ID prefix: T### \u2192 task, ses_* \u2192 session, O-* \u2192 observation. Use --slug to set a human-friendly alias (unique per project) (T9636).\n\nPositional arguments:\n  <owner-id>             Owner entity ID (T###, ses_*, O-*) \u2014 required\n  [file]                 Local file path to attach \u2014 optional when --url/--content is set\n\nNamed arguments:\n  --url <url>            Remote URL to attach (instead of a local file)\n  --content <text>       Inline document body \u2014 author without a file (T10965); '-' reads stdin\n  --desc <text>          Free-text description of this attachment\n  --labels <csv>         Comma-separated labels (e.g. rfc,spec)\n  --attached-by <name>   Agent identity that created the attachment (default: \"human\")\n  --slug <kebab>         Human-friendly alias, unique per project (T9636)\n  --title <text>         Human-readable title \u2014 REQUIRED for --type adr when --slug is omitted (T10360)\n  --type <kind>          Taxonomy classification \u2014 run `cleo docs schema` for kinds\n  --allow-similar        Bypass the slug-similarity warn \u2014 every bypass is audited\n                         to .cleo/audit/similar-bypass.jsonl (T10361)\n  --strict               Enforce body-schema (requiredSections) \u2014 fail with\n                         E_DOC_SCHEMA_MISMATCH instead of warning (T10160)\n" + docsOutputFlagHelp + "\n\nValidation behaviors:\n  \u2022 Unknown flags \u2192 E_UNKNOWN_FLAG with did-you-mean suggestions (T10359)\n  \u2022 Slug collision \u2192 E_SLUG_RESERVED + 3 alternative slugs (T10386)\n  \u2022 Near-duplicate slug \u2192 W_SLUG_SIMILAR warning unless --allow-similar (T10361)\n  \u2022 For --type adr without --slug, slug auto-allocates as `adr-NNN-<kebab-title>` via the\n    central allocator (T10360 \u2014 closes T10153). --title is required in this case."
       },
       args: {
         "owner-id": {
@@ -48248,6 +48437,10 @@ var init_docs3 = __esm({
           type: "string",
           description: "Remote URL to attach (instead of a local file)"
         },
+        content: {
+          type: "string",
+          description: "Inline document body \u2014 author a doc without a pre-existing file (T10965). Pass '-' to read the body from stdin. Mutually exclusive with the file positional and --url."
+        },
         desc: {
           type: "string",
           description: "Free-text description of this attachment"
@@ -48300,14 +48493,27 @@ var init_docs3 = __esm({
         const ownerId = args["owner-id"];
         const fileArg = args.file ?? void 0;
         const url = args.url ?? void 0;
+        const contentArg = typeof args.content === "string" ? args.content : void 0;
         const allowSimilar = args["allow-similar"] === true;
-        if (!fileArg && !url) {
-          cliError("provide a file path (positional argument) or --url <url>", 6, {
+        const sourceCount = (fileArg ? 1 : 0) + (url ? 1 : 0) + (contentArg !== void 0 ? 1 : 0);
+        if (sourceCount === 0) {
+          cliError("provide a file path (positional), --url <url>, or --content <text>", 6, {
+            name: "E_VALIDATION",
+            fix: 'Example: cleo docs add T123 docs/rfc.md --desc "RFC draft" \u2014 or \u2014 cleo docs add T123 --content "# Note" --slug my-note'
+          });
+          process.exit(6);
+        }
+        if (sourceCount > 1) {
+          cliError("the file positional, --url, and --content are mutually exclusive", 6, {
             name: "E_VALIDATION",
-            fix: 'Example: cleo docs add T123 docs/rfc.md --desc "RFC draft" \u2014 or \u2014 cleo docs add T123 --url https://example.com/spec'
+            fix: "Pass exactly one source: a file path, --url <url>, or --content <text>."
           });
           process.exit(6);
         }
+        let content = contentArg;
+        if (content === "-") {
+          content = await readDocBodyFromStdin();
+        }
         if (args.type === "adr" && !args.slug && !args.title) {
           cliError(
             "--title <text> is required when --type adr is used without --slug \u2014 the allocator needs a title to assemble adr-NNN-<kebab-title>",
@@ -48427,6 +48633,7 @@ var init_docs3 = __esm({
             ownerId,
             ...resolvedFile ? { file: resolvedFile } : {},
             ...url ? { url } : {},
+            ...content !== void 0 ? { content } : {},
             ...args.desc ? { desc: args.desc } : {},
             ...args.labels ? { labels: args.labels } : {},
             ...args["attached-by"] ? { attachedBy: args["attached-by"] } : {},
@@ -48541,14 +48748,26 @@ var init_docs3 = __esm({
     fetchCommand = defineCommand({
       meta: {
         name: "fetch",
-        description: "Retrieve attachment metadata and bytes by attachment ID (att_*) or SHA-256 hex. Files <= 1 MB are returned base64-encoded inline; larger files report the storage path only. Output flags: --json and --output envelope|id|table|count|silent are accepted consistently."
+        description: "Retrieve attachment metadata and bytes by slug, attachment ID (att_*), or SHA-256 hex. Files <= 1 MB are returned base64-encoded inline; larger files report the storage path only. Pass --content (alias --decoded) to emit the decoded UTF-8 document body to stdout instead of the LAFS envelope \u2014 the agent-friendly shortcut over piping bytesBase64 through base64 -d (T10970). Output flags: --json and --output envelope|id|table|count|silent are accepted consistently."
       },
       args: {
         "attachment-ref": {
           type: "positional",
-          description: "Attachment ID (att_*) or SHA-256 hex",
+          description: "Slug, attachment ID (att_*), or SHA-256 hex",
           required: true
         },
+        // T10970 — decoded-text content mode. An explicit opt-out from the
+        // default envelope contract (ADR-086) that streams the raw UTF-8 body
+        // to stdout, mirroring the other text-payload commands (export,
+        // llm-output, view --render markdown).
+        content: {
+          type: "boolean",
+          description: "Emit the decoded UTF-8 document body to stdout instead of the LAFS envelope (text docs only). Replaces the `--field /data/bytesBase64 | base64 -d` two-step (T10970)."
+        },
+        decoded: {
+          type: "boolean",
+          description: "Alias for --content (T10970)."
+        },
         // T9922 — MVI record projection opt-out flags (surfaced for --help).
         verbose: {
           type: "boolean",
@@ -48561,11 +48780,35 @@ var init_docs3 = __esm({
         ...docsOutputArgs
       },
       async run({ args }) {
+        const ref = String(args["attachment-ref"]);
+        if (args.content === true || args.decoded === true) {
+          const model = createDocsReadModel2();
+          const result = await model.fetchDecoded(ref);
+          if (!result.ok) {
+            if (result.reason === "not-found") {
+              cliError(`Doc not found: ${ref}`, 4 /* NOT_FOUND */, {
+                name: "E_NOT_FOUND",
+                fix: "List available docs with: cleo docs list"
+              });
+            } else {
+              cliError(`Content not retrievable: ${ref}`, 4 /* NOT_FOUND */, {
+                name: "E_NOT_FOUND",
+                fix: "The doc metadata exists but its blob may be missing. Try: cleo docs publish <slug>"
+              });
+            }
+            process.exit(4 /* NOT_FOUND */);
+          }
+          process.stdout.write(result.content);
+          if (!result.content.endsWith("\n")) {
+            process.stdout.write("\n");
+          }
+          return;
+        }
         await dispatchFromCli(
           "query",
           "docs",
           "fetch",
-          { attachmentRef: args["attachment-ref"] },
+          { attachmentRef: ref },
           { command: "docs fetch" }
         );
       }
@@ -50859,6 +51102,78 @@ var init_doctor_release_readiness = __esm({
   }
 });
 
+// packages/cleo/src/cli/commands/doctor-repair.ts
+var doctor_repair_exports = {};
+__export(doctor_repair_exports, {
+  doctorRepairCommand: () => doctorRepairCommand
+});
+import { getLogger as getLogger20, getProjectRoot as getProjectRoot41 } from "@cleocode/core";
+import { repairMalformedDbs } from "@cleocode/core/store/repair-malformed-dbs.js";
+var doctorRepairCommand;
+var init_doctor_repair = __esm({
+  "packages/cleo/src/cli/commands/doctor-repair.ts"() {
+    "use strict";
+    init_src2();
+    init_define_cli_command();
+    init_renderers();
+    doctorRepairCommand = defineCommand({
+      meta: {
+        name: "repair",
+        description: "Detect malformed CLEO databases (PRAGMA quick_check) and restore each from its freshest validated snapshot via the recovery pipeline (quarantine \u2192 restore \u2192 verify). Defaults to every present DB; use --role to narrow, --dry-run to plan without mutating."
+      },
+      args: {
+        role: {
+          type: "string",
+          description: `Repair only this DB role (one of: ${DB_INVENTORY.map((e) => e.role).join(", ")})`,
+          default: ""
+        },
+        "dry-run": {
+          type: "boolean",
+          description: "Detect + plan only \u2014 report what would be repaired without quarantining/restoring",
+          default: false
+        }
+      },
+      run({ args }) {
+        const roleArg = typeof args.role === "string" ? args.role.trim() : "";
+        const dryRun = args["dry-run"] === true;
+        if (roleArg.length > 0 && !DB_INVENTORY.some((e) => e.role === roleArg)) {
+          const validRoles = DB_INVENTORY.map((e) => e.role).join(", ");
+          cliError(
+            `Unknown DB role "${roleArg}". Valid roles: ${validRoles}.`,
+            6 /* VALIDATION_ERROR */,
+            {
+              name: "E_VALIDATION",
+              fix: "Run `cleo doctor repair --help` for the list of valid roles."
+            },
+            { command: "doctor repair" }
+          );
+          process.exitCode = 6 /* VALIDATION_ERROR */;
+          return;
+        }
+        const result = repairMalformedDbs({
+          projectRoot: getProjectRoot41(),
+          roles: roleArg.length > 0 ? [roleArg] : void 0,
+          dryRun,
+          logger: getLogger20("doctor-repair")
+        });
+        for (const r of result.roles) {
+          if (!r.healthy) {
+            humanInfo(`  [${r.action.toUpperCase()}] ${r.role} \u2014 ${r.detail}`);
+          }
+        }
+        const verb = dryRun ? "would repair" : "repaired";
+        cliOutput(result, {
+          command: "doctor repair",
+          message: result.malformedCount === 0 ? `All ${result.roles.length} inspected DB(s) healthy \u2014 nothing to repair.` : `${result.malformedCount} malformed DB(s): ${verb} ${result.repairedCount}, ${result.failedCount} failed.`
+        });
+        if (result.failedCount > 0) {
+          process.exitCode = 1 /* GENERAL_ERROR */;
+        }
+      }
+    });
+  }
+});
+
 // packages/cleo/src/cli/progress.ts
 import { stderr } from "node:process";
 function createSelfUpdateProgress(enabled) {
@@ -50996,7 +51311,7 @@ import { join as join23 } from "node:path";
 import {
   ensureGlobalAgentRegistryDb,
   getGlobalAgentRegistryNativeDb,
-  getProjectRoot as getProjectRoot41,
+  getProjectRoot as getProjectRoot42,
   installAgentFromCant
 } from "@cleocode/core/internal";
 function sha256Hex(bytes) {
@@ -51184,7 +51499,7 @@ var init_migrate_agents_v2 = __esm({
         }
       },
       async run({ args }) {
-        const projectRoot = getProjectRoot41();
+        const projectRoot = getProjectRoot42();
         const verbose = args.quiet !== true;
         if (verbose) {
           humanInfo("Scanning .cleo/cant/agents/ and .cleo/agents/ for unregistered agents...");
@@ -51228,7 +51543,7 @@ __export(doctor_exports, {
 });
 import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "node:fs";
 import { join as join24 } from "node:path";
-import { getProjectRoot as getProjectRoot42, pushWarning as pushWarning5 } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot43, pushWarning as pushWarning5 } from "@cleocode/core";
 import { renderInvariantAuditLines } from "@cleocode/core/doctor/invariant-audit-render.js";
 import {
   quarantineRogueCleoDir,
@@ -51350,6 +51665,7 @@ var init_doctor = __esm({
     init_doctor_legacy_backups();
     init_doctor_projects();
     init_doctor_release_readiness();
+    init_doctor_repair();
     init_migrate_agents_v2();
     FIXTURE_ID_PATTERNS = [/^E\d+$/, /^T\d+EP$/];
     FIXTURE_TITLE_KEYWORDS = [
@@ -51369,6 +51685,8 @@ var init_doctor = __esm({
         "exodus-residue": doctorExodusResidueCommand,
         // T11837 / Saga T11242 / Epic T11833 — read-only exodus health report
         "exodus-health": doctorExodusCommand,
+        // T11829 / Saga T11242 / Epic T11833 — DHQ-060 malformed-DB repair entry point
+        repair: doctorRepairCommand,
         // T10458 / Saga T10431 / Epic T10436 — Release-readiness preflight
         "release-readiness": doctorReleaseReadinessCommand
       },
@@ -51573,7 +51891,7 @@ var init_doctor = __esm({
             const { join: pathJoin } = await import("node:path");
             const { existsSync: existsSync22 } = await import("node:fs");
             const { detectAndHealCoreWorktreeLeak } = await import("@cleocode/worktree");
-            const projectRoot = getProjectRoot42();
+            const projectRoot = getProjectRoot43();
             let gitRoot = projectRoot;
             try {
               gitRoot = execFile2("git", ["rev-parse", "--show-toplevel"], {
@@ -51625,7 +51943,7 @@ var init_doctor = __esm({
           }
           if (args.brain) {
             const { computeBrainHealthDashboard } = await import("@cleocode/core/memory/brain-health-dashboard.js");
-            const projectRoot = getProjectRoot42();
+            const projectRoot = getProjectRoot43();
             const dashboard = await computeBrainHealthDashboard(projectRoot);
             cliOutput(dashboard, { command: "doctor", operation: "doctor.brain" });
             if (dashboard.hasP0Failure) {
@@ -51634,7 +51952,7 @@ var init_doctor = __esm({
             return;
           }
           if (args["scan-test-fixtures-in-prod"]) {
-            const projectRoot = getProjectRoot42();
+            const projectRoot = getProjectRoot43();
             const matches = await scanTestFixturesInProd(projectRoot);
             const dryRun = args["dry-run"] !== false && args.quarantine !== true;
             const quarantined = !dryRun && matches.length > 0 ? await quarantineTestFixtures(projectRoot, matches) : void 0;
@@ -51722,7 +52040,7 @@ var init_doctor = __esm({
             progress.complete("Comprehensive diagnostics complete");
           } else if (args["scan-rogue-cleo-dirs"]) {
             progress.step(0, "Scanning for rogue .cleo/ directories");
-            const projectRoot = getProjectRoot42();
+            const projectRoot = getProjectRoot43();
             const reports = scanRogueCleoDirs(projectRoot);
             progress.complete(
               `Found ${reports.length} rogue .cleo/ director${reports.length === 1 ? "y" : "ies"}`
@@ -51731,7 +52049,7 @@ var init_doctor = __esm({
           } else if (args["quarantine-rogue-cleo-dirs"]) {
             const isDryRun = args["dry-run"] === true;
             progress.step(0, `${isDryRun ? "[DRY RUN] " : ""}Scanning for rogue .cleo/ directories`);
-            const projectRoot = getProjectRoot42();
+            const projectRoot = getProjectRoot43();
             const reports = scanRogueCleoDirs(projectRoot);
             if (reports.length === 0) {
               progress.complete("No rogue .cleo/ directories found \u2014 nothing to quarantine");
@@ -51785,7 +52103,7 @@ var init_doctor = __esm({
             const { detectAndRemoveLegacyGlobalFiles, detectAndRemoveStrayProjectNexus } = await import("@cleocode/core/store/cleanup-legacy.js");
             const { getCleoHome: getCleoHome6 } = await import("@cleocode/core");
             const cleoHome = getCleoHome6();
-            const projectRoot = getProjectRoot42();
+            const projectRoot = getProjectRoot43();
             const legacyResult = detectAndRemoveLegacyGlobalFiles(cleoHome);
             const strayResult = detectAndRemoveStrayProjectNexus(projectRoot);
             const isDryRun = args["dry-run"] === true;
@@ -51818,7 +52136,7 @@ var init_doctor = __esm({
           } else if (args["audit-worktree-orphans"]) {
             progress.step(0, "Comprehensive worktree anomaly audit (T9808 / council D009)");
             const { auditWorktreeOrphansComprehensive, scanWorktreeOrphansBudgeted } = await import("@cleocode/core/doctor/worktree-orphans.js");
-            const projectRoot = getProjectRoot42();
+            const projectRoot = getProjectRoot43();
             const timeoutSecs = args["timeout"] !== void 0 ? Number.parseInt(String(args["timeout"]), 10) : 30;
             const timeoutMs = Number.isFinite(timeoutSecs) && timeoutSecs > 0 ? timeoutSecs * 1e3 : 3e4;
             const maxEntriesPerLevel = args["max-entries-per-level"] !== void 0 ? Number.parseInt(String(args["max-entries-per-level"]), 10) : 500;
@@ -51875,7 +52193,7 @@ var init_doctor = __esm({
               `${isDryRun ? "[DRY RUN] " : ""}Scanning + pruning worktree-orphan .cleo/ directories`
             );
             const { pruneWorktreeOrphans, scanWorktreeOrphansBudgeted } = await import("@cleocode/core/doctor/worktree-orphans.js");
-            const projectRoot = getProjectRoot42();
+            const projectRoot = getProjectRoot43();
             const timeoutSecs = args["timeout"] !== void 0 ? Number.parseInt(String(args["timeout"]), 10) : 30;
             const timeoutMs = Number.isFinite(timeoutSecs) && timeoutSecs > 0 ? timeoutSecs * 1e3 : 3e4;
             const maxEntriesPerLevel = args["max-entries-per-level"] !== void 0 ? Number.parseInt(String(args["max-entries-per-level"]), 10) : 500;
@@ -51954,7 +52272,7 @@ var init_doctor = __esm({
               `${isDryRun ? "[DRY RUN] " : ""}Migrating .cleo/worktree-include \u2192 .worktreeinclude`
             );
             const { migrateWorktreeIncludeFile } = await import("@cleocode/core");
-            const projectRoot = getProjectRoot42();
+            const projectRoot = getProjectRoot43();
             const result = await migrateWorktreeIncludeFile(projectRoot, { dryRun: isDryRun });
             progress.complete(`Migration ${result.action}`);
             cliOutput(result, { command: "doctor", operation: "doctor.migrate-worktree-include" });
@@ -51973,7 +52291,7 @@ var init_doctor = __esm({
             const stepLabel = isFocusedAlias ? "Auditing Saga hierarchy for ADR-073 invariants" : "Walking central INVARIANTS_REGISTRY";
             progress.step(0, stepLabel);
             const { auditInvariantRegistry } = await import("@cleocode/core/doctor/invariant-audit.js");
-            const projectRoot = getProjectRoot42();
+            const projectRoot = getProjectRoot43();
             const result = await auditInvariantRegistry(projectRoot, { adrFilter });
             const operation = isFocusedAlias ? "doctor.audit-sagas" : "doctor.audit-invariants";
             const summary = `Invariant audit complete \u2014 ${result.totalCount} entries walked, ${result.errorCount} error / ${result.warningCount} warning / ${result.infoCount} info violation(s), ${result.notApplicableCount} not-applicable, ${result.documentedCount} documented`;
@@ -51995,7 +52313,7 @@ var init_doctor = __esm({
               { command: "doctor", operation: "admin.health" }
             );
             try {
-              const projectRoot = getProjectRoot42();
+              const projectRoot = getProjectRoot43();
               const conflicts = readMigrationConflicts(projectRoot);
               if (conflicts.length > 0) {
                 progress.complete(
@@ -52026,7 +52344,7 @@ var init_doctor = __esm({
               progress.complete("Health check complete");
             }
             try {
-              const projectRoot = getProjectRoot42();
+              const projectRoot = getProjectRoot43();
               const { auditSagaHierarchy } = await import("@cleocode/core/doctor/saga-audit.js");
               const sagaAudit = await auditSagaHierarchy(projectRoot);
               if (sagaAudit.sagas.length === 0) {
@@ -53612,7 +53930,7 @@ var go_exports = {};
 __export(go_exports, {
   goCommand: () => goCommand
 });
-import { getProjectRoot as getProjectRoot43, go } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot44, go } from "@cleocode/core";
 var goCommand;
 var init_go = __esm({
   "packages/cleo/src/cli/commands/go.ts"() {
@@ -53637,7 +53955,7 @@ var init_go = __esm({
         }
       },
       async run({ args }) {
-        const projectRoot = getProjectRoot43();
+        const projectRoot = getProjectRoot44();
         const result = await go.cleoGo({
           sagaId: typeof args.saga === "string" && args.saga.length > 0 ? args.saga : void 0,
           headless: args.headless === true,
@@ -53654,7 +53972,7 @@ var goal_exports = {};
 __export(goal_exports, {
   goalCommand: () => goalCommand
 });
-import { getProjectRoot as getProjectRoot44, goal } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot45, goal } from "@cleocode/core";
 function resolveGoalKind(task) {
   if (typeof task === "string" && task.length > 0) {
     if (!isValidGoalTargetTaskId(task)) {
@@ -53701,7 +54019,7 @@ var init_goal2 = __esm({
         }
         const record = await goal.createGoal(
           { goalKind: kindResult.kind, intent, turnBudget: resolveTurnBudget(args.turns) },
-          getProjectRoot44()
+          getProjectRoot45()
         );
         cliOutput(record, { command: "goal set", operation: "goal.set" });
       }
@@ -53712,7 +54030,7 @@ var init_goal2 = __esm({
         description: "Show the current agent's active goal (per-agent scoped)."
       },
       async run() {
-        const record = await goal.getActiveGoal(getProjectRoot44());
+        const record = await goal.getActiveGoal(getProjectRoot45());
         cliOutput(record ?? { active: null }, { command: "goal status", operation: "goal.status" });
       }
     });
@@ -53734,7 +54052,7 @@ var init_goal2 = __esm({
           });
           return;
         }
-        const cwd = getProjectRoot44();
+        const cwd = getProjectRoot45();
         const parent = await goal.getActiveGoal(cwd);
         if (!parent) {
           cliError(
@@ -53782,7 +54100,7 @@ var init_goal2 = __esm({
           });
           return;
         }
-        const cwd = getProjectRoot44();
+        const cwd = getProjectRoot45();
         const result = await goal.advanceGoalWithPersist(goalId, { cwd });
         if (!result) {
           cliError(`Goal '${goalId}' not found.`, 4 /* NOT_FOUND */, { name: "E_NOT_FOUND" });
@@ -53807,7 +54125,7 @@ var init_goal2 = __esm({
           });
           return;
         }
-        const cwd = getProjectRoot44();
+        const cwd = getProjectRoot45();
         const active = await goal.getActiveGoal(cwd);
         if (!active) {
           cliError(
@@ -54796,7 +55114,7 @@ var hygiene_exports = {};
 __export(hygiene_exports, {
   hygieneCommand: () => hygieneCommand
 });
-import { getProjectRoot as getProjectRoot45 } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot46 } from "@cleocode/core";
 import { runSpawnReadinessHygieneCli } from "@cleocode/core/hygiene/validate-spawn-readiness.js";
 var hygieneCommand;
 var init_hygiene = __esm({
@@ -54825,7 +55143,7 @@ var init_hygiene = __esm({
             }
           },
           async run({ args }) {
-            const projectRoot = args["project-root"] || getProjectRoot45() || process.cwd();
+            const projectRoot = args["project-root"] || getProjectRoot46() || process.cwd();
             const worktreePath = args["worktree-path"];
             await runSpawnReadinessHygieneCli(projectRoot, worktreePath);
           }
@@ -55988,7 +56306,7 @@ var llm_cost_exports = {};
 __export(llm_cost_exports, {
   costCommand: () => costCommand
 });
-import { getProjectRoot as getProjectRoot46 } from "@cleocode/core/internal";
+import { getProjectRoot as getProjectRoot47 } from "@cleocode/core/internal";
 import { computeCost } from "@cleocode/core/llm/usage-pricing";
 function resolveSessionId(raw) {
   if (raw === "current") {
@@ -56061,7 +56379,7 @@ var init_llm_cost = __esm({
           process.exit(6);
         }
         const sessionId = resolveSessionId(rawSessionId);
-        const projectRoot = getProjectRoot46(process.cwd());
+        const projectRoot = getProjectRoot47(process.cwd());
         let breakdown;
         try {
           breakdown = await loadSessionCostBreakdown(projectRoot, sessionId);
@@ -57635,7 +57953,7 @@ var memory_exports = {};
 __export(memory_exports, {
   memoryCommand: () => memoryCommand
 });
-import { getProjectRoot as getProjectRoot47 } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot48 } from "@cleocode/core";
 import {
   getBrainDb as getBrainDb2,
   getDreamStatus,
@@ -58568,7 +58886,7 @@ var init_memory3 = __esm({
       },
       args: {},
       async run() {
-        const root = getProjectRoot47();
+        const root = getProjectRoot48();
         try {
           const result = await runConsolidation(root);
           cliOutput(result, { command: "memory-consolidate", operation: "memory.consolidate" });
@@ -58592,7 +58910,7 @@ var init_memory3 = __esm({
         }
       },
       async run({ args }) {
-        const root = getProjectRoot47();
+        const root = getProjectRoot48();
         if (args.status) {
           try {
             const status = await getDreamStatus(root);
@@ -58629,7 +58947,7 @@ var init_memory3 = __esm({
         }
       },
       async run({ args }) {
-        const root = getProjectRoot47();
+        const root = getProjectRoot48();
         try {
           const { runObserver, runReflector } = await import("@cleocode/core/memory");
           const observerResult = await runObserver(root, args.session, {
@@ -58669,7 +58987,7 @@ var init_memory3 = __esm({
         }
       },
       async run({ args }) {
-        const root = getProjectRoot47();
+        const root = getProjectRoot48();
         try {
           await getBrainDb2(root);
           const { totalDuplicateRows, groups } = await scanDuplicateEntries();
@@ -58715,7 +59033,7 @@ var init_memory3 = __esm({
       async run({ args }) {
         const sourceDir = args.from;
         const isDryRun = !!args["dry-run"];
-        const projectRoot = getProjectRoot47();
+        const projectRoot = getProjectRoot48();
         try {
           const result = await importMemoryFiles({
             sourceDir,
@@ -58866,7 +59184,7 @@ var init_memory3 = __esm({
       },
       args: {},
       async run() {
-        const root = getProjectRoot47();
+        const root = getProjectRoot48();
         try {
           await getBrainDb2(root);
           const result = await getTierStats(root);
@@ -58909,7 +59227,7 @@ var init_memory3 = __esm({
         }
       },
       async run({ args }) {
-        const root = getProjectRoot47();
+        const root = getProjectRoot48();
         const targetTier = args.to;
         const reason = args.reason;
         const validTiers = ["medium", "long"];
@@ -58975,7 +59293,7 @@ var init_memory3 = __esm({
         }
       },
       async run({ args }) {
-        const root = getProjectRoot47();
+        const root = getProjectRoot48();
         const targetTier = args.to;
         const reason = args.reason;
         const validTiers = ["short", "medium"];
@@ -59438,7 +59756,7 @@ var migrate_claude_mem_exports = {};
 __export(migrate_claude_mem_exports, {
   migrateClaudeMemCommand: () => migrateClaudeMemCommand
 });
-import { getProjectRoot as getProjectRoot48, migrateClaudeMem } from "@cleocode/core/internal";
+import { getProjectRoot as getProjectRoot49, migrateClaudeMem } from "@cleocode/core/internal";
 import { ingestLooseAgentOutputs, ingestRcasdDirectories } from "@cleocode/core/memory";
 import { getDb as getDb2 } from "@cleocode/core/store/sqlite";
 var storageCommand, claudeMemCommand, manifestIngestCommand, migrateClaudeMemCommand;
@@ -59501,7 +59819,7 @@ var init_migrate_claude_mem = __esm({
         }
       },
       async run({ args }) {
-        const root = getProjectRoot48();
+        const root = getProjectRoot49();
         try {
           const result = await migrateClaudeMem(root, {
             sourcePath: args.source,
@@ -59550,7 +59868,7 @@ var init_migrate_claude_mem = __esm({
         }
       },
       async run({ args }) {
-        const projectRoot = getProjectRoot48();
+        const projectRoot = getProjectRoot49();
         try {
           const db = await getDb2(projectRoot);
           const rcasdFlag = Boolean(args.rcasd);
@@ -59668,7 +59986,7 @@ __export(nexus_exports, {
 import { appendFile as appendFile2, mkdir as mkdir4 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
 import path4 from "node:path";
-import { getProjectRoot as getProjectRoot49 } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot50 } from "@cleocode/core";
 import { getSymbolImpact } from "@cleocode/core/nexus";
 import { runNexusAnalysis } from "@cleocode/core/nexus/analyze-orchestrator.js";
 import { exportNexusGraph } from "@cleocode/core/nexus/export.js";
@@ -59783,7 +60101,7 @@ var init_nexus3 = __esm({
       async run({ args }) {
         applyJsonFlag2(args.json);
         const projectIdOverride = args["project-id"];
-        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot49();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot50();
         const startTime = Date.now();
         try {
           const [{ getNexusDb, nexusSchema }, { getIndexStats }] = await Promise.all([
@@ -60298,7 +60616,7 @@ var init_nexus3 = __esm({
         applyJsonFlag2(args.json);
         const startTime = Date.now();
         const projectIdOverride = args["project-id"];
-        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot49();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot50();
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const response = await dispatchRaw("query", "nexus", "clusters", { projectId, repoPath });
         const durationMs = Date.now() - startTime;
@@ -60342,7 +60660,7 @@ var init_nexus3 = __esm({
         applyJsonFlag2(args.json);
         const startTime = Date.now();
         const projectIdOverride = args["project-id"];
-        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot49();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot50();
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const response = await dispatchRaw("query", "nexus", "flows", { projectId, repoPath });
         const durationMs = Date.now() - startTime;
@@ -60385,7 +60703,7 @@ var init_nexus3 = __esm({
         void appendDeprecationTelemetry("nexus.context", "cleo graph context");
         const startTime = Date.now();
         const projectIdOverride = args["project-id"];
-        const repoPath = getProjectRoot49();
+        const repoPath = getProjectRoot50();
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const limit = parseInt(args.limit, 10);
         const symbolName = args.symbol;
@@ -60448,7 +60766,7 @@ var init_nexus3 = __esm({
         const startTime = Date.now();
         const whyFlag = !!args.why;
         const projectIdOverride = args["project-id"];
-        const repoPath = getProjectRoot49();
+        const repoPath = getProjectRoot50();
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const maxDepth = Math.min(parseInt(args.depth, 10), 5);
         const symbolName = args.symbol;
@@ -60520,7 +60838,7 @@ var init_nexus3 = __esm({
         const projectIdOverride = args["project-id"];
         const isIncremental = !!args.incremental;
         const ctx = getFormatContext();
-        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot49();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot50();
         humanInfo(`[nexus] Analyzing: ${repoPath}${isIncremental ? " (incremental)" : ""}`);
         if (!isIncremental) humanInfo("[nexus] Clearing existing index for project...");
         try {
@@ -60623,7 +60941,7 @@ var init_nexus3 = __esm({
       async run({ args }) {
         applyJsonFlag2(args.json);
         const startTime = Date.now();
-        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot49();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot50();
         const name = args.name;
         const response = await dispatchRaw("mutate", "nexus", "projects.register", {
           path: repoPath,
@@ -60981,7 +61299,7 @@ var init_nexus3 = __esm({
         applyJsonFlag2(args.json);
         const startTime = Date.now();
         const projectIdOverride = args["project-id"];
-        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot49();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot50();
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const response = await dispatchRaw("mutate", "nexus", "refresh-bridge", {
           repoPath,
@@ -61087,7 +61405,7 @@ var init_nexus3 = __esm({
       async run({ args }) {
         applyJsonFlag2(args.json);
         const startTime = Date.now();
-        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot49();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot50();
         const projectIdOverride = args["project-id"];
         const beforeRef = args.before ?? "HEAD~1";
         const afterRef = args.after ?? "HEAD";
@@ -61205,7 +61523,7 @@ var init_nexus3 = __esm({
         applyJsonFlag2(args.json);
         const startTime = Date.now();
         const projectIdOverride = args["project-id"];
-        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot49();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot50();
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const response = await dispatchRaw("query", "nexus", "route-map", { projectId });
         const durationMs = Date.now() - startTime;
@@ -61261,7 +61579,7 @@ var init_nexus3 = __esm({
         const startTime = Date.now();
         const routeSymbol = args.routeSymbol;
         const projectIdOverride = args["project-id"];
-        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot49();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot50();
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const response = await dispatchRaw("query", "nexus", "shape-check", { routeSymbol, projectId });
         const durationMs = Date.now() - startTime;
@@ -61651,7 +61969,7 @@ var init_nexus3 = __esm({
       async run({ args }) {
         applyJsonFlag2(args.json);
         const startTime = Date.now();
-        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot49();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot50();
         const projectIdOverride = args["project-id"];
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const response = await dispatchRaw("mutate", "nexus", "contracts-sync", {
@@ -61755,7 +62073,7 @@ var init_nexus3 = __esm({
       async run({ args }) {
         applyJsonFlag2(args.json);
         const startTime = Date.now();
-        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot49();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot50();
         const projectId = Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const response = await dispatchRaw("mutate", "nexus", "contracts-link-tasks", {
           projectId,
@@ -61836,7 +62154,7 @@ var init_nexus3 = __esm({
         const isIncremental = !!args.incremental;
         try {
           const result = await runNexusWiki({
-            projectRoot: getProjectRoot49(),
+            projectRoot: getProjectRoot50(),
             outputDir,
             communityFilter,
             incremental: isIncremental
@@ -62186,7 +62504,7 @@ __export(orchestrate_exports, {
 });
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { orchestration } from "@cleocode/core";
-import { BUILD_CONFIG as BUILD_CONFIG2, getProjectRoot as getProjectRoot50 } from "@cleocode/core/internal";
+import { BUILD_CONFIG as BUILD_CONFIG2, getProjectRoot as getProjectRoot51 } from "@cleocode/core/internal";
 function formatRollupTable(rollup) {
   const waves = "waves" in rollup ? rollup.waves : [rollup];
   const lines = [];
@@ -62329,7 +62647,7 @@ var init_orchestrate3 = __esm({
       },
       async run({ args }) {
         const rateWindowHours = args.window !== void 0 ? Number.parseFloat(String(args.window)) : void 0;
-        const metrics = await orchestration.collectOrchestrateDashboard(getProjectRoot50(), {
+        const metrics = await orchestration.collectOrchestrateDashboard(getProjectRoot51(), {
           ...rateWindowHours !== void 0 && Number.isFinite(rateWindowHours) && rateWindowHours > 0 ? { rateWindowHours } : {}
         });
         cliOutput(metrics, {
@@ -64534,7 +64852,7 @@ var refresh_memory_exports = {};
 __export(refresh_memory_exports, {
   refreshMemoryCommand: () => refreshMemoryCommand
 });
-import { getProjectRoot as getProjectRoot51 } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot52 } from "@cleocode/core";
 var refreshMemoryCommand;
 var init_refresh_memory = __esm({
   "packages/cleo/src/cli/commands/refresh-memory.ts"() {
@@ -64547,7 +64865,7 @@ var init_refresh_memory = __esm({
         description: "Regenerate .cleo/memory-bridge.md from brain.db"
       },
       async run() {
-        const projectDir = getProjectRoot51();
+        const projectDir = getProjectRoot52();
         const { writeMemoryBridge } = await import("@cleocode/core/internal");
         const result = await writeMemoryBridge(projectDir);
         if (result.written) {
@@ -66074,7 +66392,7 @@ import fs3 from "node:fs";
 import path5 from "node:path";
 import {
   CleoError as CleoError8,
-  getProjectRoot as getProjectRoot52,
+  getProjectRoot as getProjectRoot53,
   getTaskAccessor as getTaskAccessor3,
   parseConflictReport,
   setAtPath
@@ -66095,7 +66413,7 @@ var init_restore = __esm({
         description: "Apply manually-resolved conflicts from .cleo/restore-conflicts.md"
       },
       async run() {
-        const projectRoot = getProjectRoot52();
+        const projectRoot = getProjectRoot53();
         const reportPath = path5.join(projectRoot, CLEO_DIR_NAME3, RESTORE_CONFLICTS_MD);
         if (!fs3.existsSync(reportPath)) {
           humanLine("No pending restore conflicts. Nothing to finalize.");
@@ -67017,8 +67335,8 @@ var init_saga = __esm({
         }
       },
       async run({ args }) {
-        const { sagas: sagas2, getProjectRoot: getProjectRoot58 } = await import("@cleocode/core");
-        const projectRoot = getProjectRoot58();
+        const { sagas: sagas2, getProjectRoot: getProjectRoot59 } = await import("@cleocode/core");
+        const projectRoot = getProjectRoot59();
         const sagaId = typeof args.sagaId === "string" && args.sagaId.length > 0 ? args.sagaId : void 0;
         const result = await sagas2.sagaNext(projectRoot, { sagaId });
         cliOutput(result.success ? result.data : result, { command: "saga", operation: "saga.next" });
@@ -68760,7 +69078,7 @@ var sequence_exports = {};
 __export(sequence_exports, {
   sequenceCommand: () => sequenceCommand
 });
-import { getProjectRoot as getProjectRoot53 } from "@cleocode/core/internal";
+import { getProjectRoot as getProjectRoot54 } from "@cleocode/core/internal";
 var showCommand13, checkCommand7, repairCommand2, sequenceCommand;
 var init_sequence = __esm({
   "packages/cleo/src/cli/commands/sequence.ts"() {
@@ -68796,7 +69114,7 @@ var init_sequence = __esm({
       meta: { name: "repair", description: "Reset counter to max + 1 if behind" },
       async run() {
         const { repairSequence } = await import("@cleocode/core/internal");
-        const projectRoot = getProjectRoot53();
+        const projectRoot = getProjectRoot54();
         const repair = await repairSequence(projectRoot);
         const result = {
           repaired: repair.repaired,
@@ -69251,8 +69569,8 @@ var init_session4 = __esm({
         "audit-scope": { type: "string", description: "Audit log scope (global|local)" }
       },
       async run({ args }) {
-        const { detectSessionDrift, getProjectRoot: getProjectRoot58 } = await import("@cleocode/core");
-        const projectRoot = await getProjectRoot58();
+        const { detectSessionDrift, getProjectRoot: getProjectRoot59 } = await import("@cleocode/core");
+        const projectRoot = await getProjectRoot59();
         const scope = args["audit-scope"] === "local" ? "local" : "global";
         const report = await detectSessionDrift({ projectRoot, auditScope: scope });
         cliOutput(report, { command: "session drift", operation: "session.drift" });
@@ -71949,13 +72267,13 @@ var init_telemetry2 = __esm({
 // packages/cleo/src/cli/commands/templates/lib.ts
 import { readFileSync as readFileSync15 } from "node:fs";
 import { isAbsolute as isAbsolute3, resolve as resolve8 } from "node:path";
-import { getProjectRoot as getProjectRoot54 } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot55 } from "@cleocode/core";
 import { resolveSourcePathAbsolute } from "@cleocode/core/templates/registry";
 function resolveProjectRoot6(raw) {
   if (typeof raw === "string" && raw.length > 0) {
     return isAbsolute3(raw) ? raw : resolve8(process.cwd(), raw);
   }
-  return getProjectRoot54();
+  return getProjectRoot55();
 }
 function readTemplateSource(entry) {
   const sourceAbsolute = resolveSourcePathAbsolute(entry);
@@ -72739,7 +73057,7 @@ __export(token_exports, {
   tokenCommand: () => tokenCommand
 });
 import { readFileSync as readFileSync19 } from "node:fs";
-import { getProjectRoot as getProjectRoot55, measureTokenExchange, recordTokenExchange as recordTokenExchange2 } from "@cleocode/core/internal";
+import { getProjectRoot as getProjectRoot56, measureTokenExchange, recordTokenExchange as recordTokenExchange2 } from "@cleocode/core/internal";
 function readPayload(args, textKey, fileKey) {
   const text = args[textKey];
   const file = args[fileKey];
@@ -72903,7 +73221,7 @@ var init_token = __esm({
           domain: args.domain,
           operation: args.operation
         };
-        const result = args.record ? await recordTokenExchange2(getProjectRoot55(), input2) : await measureTokenExchange(input2);
+        const result = args.record ? await recordTokenExchange2(getProjectRoot56(), input2) : await measureTokenExchange(input2);
         cliOutput(result, {
           command: "token",
           operation: args.record ? "admin.token.record" : "token.estimate"
@@ -72939,7 +73257,7 @@ __export(transcript_exports, {
 });
 import { homedir as homedir6 } from "node:os";
 import { join as join34 } from "node:path";
-import { getProjectRoot as getProjectRoot56 } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot57 } from "@cleocode/core";
 import {
   parseDurationMs,
   pruneTranscripts,
@@ -72969,7 +73287,7 @@ var init_transcript = __esm({
       async run({ args }) {
         if (args.pending) {
           try {
-            const projectRoot = getProjectRoot56();
+            const projectRoot = getProjectRoot57();
             const { scanPendingTranscripts } = await import("@cleocode/core/memory/transcript-scanner.js");
             const pending = await scanPendingTranscripts(projectRoot);
             cliOutput(
@@ -73066,7 +73384,7 @@ var init_transcript = __esm({
       async run({ args }) {
         const tier = args.tier ?? "warm";
         const dryRun = args["dry-run"] ?? false;
-        const projectRoot = getProjectRoot56();
+        const projectRoot = getProjectRoot57();
         try {
           const { extractTranscript } = await import("@cleocode/core/memory/transcript-extractor.js");
           const { findSessionTranscriptPath, listAllTranscripts } = await import("@cleocode/core/memory/transcript-scanner.js");
@@ -73178,7 +73496,7 @@ var init_transcript = __esm({
         const dryRun = args["dry-run"] ?? false;
         const olderThanHours = args["older-than-hours"] ? Number.parseInt(args["older-than-hours"], 10) : 24;
         const limit = args.limit ? Number.parseInt(args.limit, 10) : void 0;
-        const projectRoot = getProjectRoot56();
+        const projectRoot = getProjectRoot57();
         try {
           const { extractTranscript } = await import("@cleocode/core/memory/transcript-extractor.js");
           const { listAllTranscripts } = await import("@cleocode/core/memory/transcript-scanner.js");
@@ -74653,9 +74971,9 @@ var init_workgraph2 = __esm({
       },
       async run({ args }) {
         const { generatePlanningDoc } = await import("@cleocode/core/workgraph");
-        const { getProjectRoot: getProjectRoot58 } = await import("@cleocode/core");
+        const { getProjectRoot: getProjectRoot59 } = await import("@cleocode/core");
         const { cliOutput: cliOutput2 } = await Promise.resolve().then(() => (init_renderers(), renderers_exports));
-        const projectRoot = getProjectRoot58();
+        const projectRoot = getProjectRoot59();
         const audience = String(args.audience) === "agent" ? "agent" : "maintainer";
         const result = await generatePlanningDoc(projectRoot, {
           sagaId: String(args.sagaId),
@@ -74672,9 +74990,9 @@ var init_workgraph2 = __esm({
       async run() {
         const { validateWorkGraphStructure } = await import("@cleocode/core/workgraph");
         const { taskList: taskList2 } = await import("@cleocode/core/internal");
-        const { getProjectRoot: getProjectRoot58 } = await import("@cleocode/core");
+        const { getProjectRoot: getProjectRoot59 } = await import("@cleocode/core");
         const { cliOutput: cliOutput2 } = await Promise.resolve().then(() => (init_renderers(), renderers_exports));
-        const projectRoot = getProjectRoot58();
+        const projectRoot = getProjectRoot59();
         const listResult = await taskList2(projectRoot, { limit: 5e3 });
         const tasks = listResult.success ? listResult.data?.tasks ?? [] : [];
         const nodes = tasks.map((t) => ({
@@ -74693,9 +75011,9 @@ var init_workgraph2 = __esm({
         description: "One-shot saga-to-saga workgraph dashboard (tracking checklist)"
       },
       async run() {
-        const { sagas: sagas2, getProjectRoot: getProjectRoot58 } = await import("@cleocode/core");
+        const { sagas: sagas2, getProjectRoot: getProjectRoot59 } = await import("@cleocode/core");
         const { cliOutput: cliOutput2 } = await Promise.resolve().then(() => (init_renderers(), renderers_exports));
-        const projectRoot = getProjectRoot58();
+        const projectRoot = getProjectRoot59();
         const listResult = await sagas2.sagaList(projectRoot);
         if (!listResult.success) {
           cliOutput2(listResult, { command: "workgraph", operation: "workgraph.status" });
@@ -74761,7 +75079,7 @@ __export(worktree_exports, {
   worktreeCommand: () => worktreeCommand
 });
 import readline4 from "node:readline";
-import { getProjectRoot as getProjectRoot57, listWorktrees as listWorktrees2 } from "@cleocode/core/internal";
+import { getProjectRoot as getProjectRoot58, listWorktrees as listWorktrees2 } from "@cleocode/core/internal";
 async function promptYesNo2(question) {
   return new Promise((resolve11) => {
     const rl = readline4.createInterface({ input: process.stdin, output: process.stdout });
@@ -74866,7 +75184,7 @@ var init_worktree3 = __esm({
         const staleDays = staleDaysRaw !== void 0 ? Number.parseInt(staleDaysRaw, 10) : void 0;
         const idleDaysRaw = typeof args["idle-days"] === "string" ? args["idle-days"] : void 0;
         const idleDays = idleDaysRaw !== void 0 ? Number.parseInt(idleDaysRaw, 10) : void 0;
-        const projectRoot = getProjectRoot57();
+        const projectRoot = getProjectRoot58();
         const listResult = await listWorktrees2({
           projectRoot,
           ...staleDays !== void 0 && !Number.isNaN(staleDays) ? { staleDays } : {}
@@ -75463,6 +75781,12 @@ var COMMAND_MANIFEST = [
     description: "Pre-flight release readiness check \u2014 lint matrix + changelog + changeset + npm OIDC + tag-trigger sanity (T10458)",
     load: async () => (await Promise.resolve().then(() => (init_doctor_release_readiness(), doctor_release_readiness_exports))).doctorReleaseReadinessCommand
   },
+  {
+    exportName: "doctorRepairCommand",
+    name: "repair",
+    description: "Detect malformed CLEO databases (PRAGMA quick_check) and restore each from its ",
+    load: async () => (await Promise.resolve().then(() => (init_doctor_repair(), doctor_repair_exports))).doctorRepairCommand
+  },
   {
     exportName: "doctorCommand",
     name: "doctor",
@@ -76515,8 +76839,8 @@ async function runStartupMaintenance() {
     detectAndRemoveLegacyGlobalFiles,
     detectAndRemoveStrayProjectNexus,
     getGlobalSalt,
-    getLogger: getLogger20,
-    getProjectRoot: getProjectRoot58,
+    getLogger: getLogger21,
+    getProjectRoot: getProjectRoot59,
     isCleanupMarkerSet,
     migrateSignaldockToConduit,
     needsSignaldockToConduitMigration,
@@ -76525,7 +76849,7 @@ async function runStartupMaintenance() {
   } = await import("@cleocode/core/internal");
   let projectRootForCleanup = "";
   try {
-    projectRootForCleanup = getProjectRoot58();
+    projectRootForCleanup = getProjectRoot59();
   } catch {
   }
   if (!isCleanupMarkerSet(CLI_VERSION, projectRootForCleanup)) {
@@ -76541,11 +76865,11 @@ async function runStartupMaintenance() {
     }
     setCleanupMarker(CLI_VERSION, projectRootForCleanup);
   }
-  const _startupLog = getLogger20("cli-startup");
+  const _startupLog = getLogger21("cli-startup");
   const isInitInvocation = process.argv.slice(2).some((a) => a === "init");
   if (!isInitInvocation) {
     try {
-      const _projectRootForMigration = getProjectRoot58();
+      const _projectRootForMigration = getProjectRoot59();
       if (needsSignaldockToConduitMigration(_projectRootForMigration)) {
         const migrationResult = await migrateSignaldockToConduit(_projectRootForMigration);
         if (migrationResult.status === "failed") {