@cleocode/adapters 2026.5.130 → 2026.5.132

package/dist/index.js

@@ -970,6 +970,240 @@ var init_credentials = __esm({
   }
 });
 
+// packages/contracts/src/supervisor-ipc/messages.ts
+import { z as z5 } from "zod";
+var EnvPairSchema, ChildStateSchema, ChildStatusSchema, SpawnRequestSchema, RestartRequestSchema, MonitorRequestSchema, HealthRequestSchema, SupervisorIpcRequestSchema, SpawnedResponseSchema, RestartedResponseSchema, MonitorResponseSchema, HealthResponseSchema, LifecycleEventKindSchema, LifecycleEventResponseSchema, ErrorResponseSchema, SupervisorIpcResponseSchema, SupervisorIpcRequestEnvelopeSchema, SupervisorIpcResponseEnvelopeSchema, SupervisorIpcEnvelopeSchema, SUPERVISOR_IPC_REQUEST_KINDS, SUPERVISOR_IPC_RESPONSE_KINDS, SUPERVISOR_IPC_MESSAGE_KINDS;
+var init_messages = __esm({
+  "packages/contracts/src/supervisor-ipc/messages.ts"() {
+    "use strict";
+    EnvPairSchema = z5.object({
+      /** Environment variable name. */
+      key: z5.string().min(1),
+      /** Environment variable value. */
+      value: z5.string()
+    }).strict();
+    ChildStateSchema = z5.enum(["running", "restarting", "stopped"]);
+    ChildStatusSchema = z5.object({
+      /** Logical id of the child (stable across restarts). */
+      child_id: z5.string().min(1),
+      /** Current OS pid (0 when not currently running). */
+      pid: z5.number().int().nonnegative(),
+      /** Current liveness state. */
+      state: ChildStateSchema,
+      /** Total restarts observed for this child. */
+      restart_count: z5.number().int().nonnegative()
+    }).strict();
+    SpawnRequestSchema = z5.object({
+      /** Tag discriminating this request variant. */
+      kind: z5.literal("spawn"),
+      /** Caller-chosen logical id for the child (stable across restarts). */
+      child_id: z5.string().min(1),
+      /** Absolute path to the program to execute. */
+      program: z5.string().min(1),
+      /** Arguments passed to the program. */
+      args: z5.array(z5.string()).default([]),
+      /** Environment overrides applied on top of the supervisor's environment. */
+      env: z5.array(EnvPairSchema).default([]),
+      /** Optional working directory for the child. */
+      cwd: z5.string().optional()
+    }).strict();
+    RestartRequestSchema = z5.object({
+      /** Tag discriminating this request variant. */
+      kind: z5.literal("restart"),
+      /** Logical id of the child to restart. */
+      child_id: z5.string().min(1)
+    }).strict();
+    MonitorRequestSchema = z5.object({
+      /** Tag discriminating this request variant. */
+      kind: z5.literal("monitor"),
+      /** Specific child id to monitor; omit to request all children. */
+      child_id: z5.string().optional()
+    }).strict();
+    HealthRequestSchema = z5.object({
+      /** Tag discriminating this request variant. */
+      kind: z5.literal("health")
+    }).strict();
+    SupervisorIpcRequestSchema = z5.discriminatedUnion("kind", [
+      SpawnRequestSchema,
+      RestartRequestSchema,
+      MonitorRequestSchema,
+      HealthRequestSchema
+    ]);
+    SpawnedResponseSchema = z5.object({
+      /** Tag discriminating this response variant. */
+      kind: z5.literal("spawned"),
+      /** Logical id of the spawned child. */
+      child_id: z5.string().min(1),
+      /** OS pid assigned to the spawned child. */
+      pid: z5.number().int().nonnegative()
+    }).strict();
+    RestartedResponseSchema = z5.object({
+      /** Tag discriminating this response variant. */
+      kind: z5.literal("restarted"),
+      /** Logical id of the restarted child. */
+      child_id: z5.string().min(1),
+      /** New OS pid after the restart. */
+      pid: z5.number().int().nonnegative(),
+      /** Number of times this child has been restarted in total. */
+      restart_count: z5.number().int().nonnegative()
+    }).strict();
+    MonitorResponseSchema = z5.object({
+      /** Tag discriminating this response variant. */
+      kind: z5.literal("monitor"),
+      /** One row per monitored child. */
+      children: z5.array(ChildStatusSchema)
+    }).strict();
+    HealthResponseSchema = z5.object({
+      /** Tag discriminating this response variant. */
+      kind: z5.literal("health"),
+      /** Supervisor process pid. */
+      pid: z5.number().int().nonnegative(),
+      /** Number of children currently tracked. */
+      child_count: z5.number().int().nonnegative(),
+      /** Seconds the supervisor has been running. */
+      uptime_secs: z5.number().int().nonnegative(),
+      /** Frozen protocol version the supervisor speaks. */
+      protocol_version: z5.string()
+    }).strict();
+    LifecycleEventKindSchema = z5.enum(["child_exited", "child_restarted"]);
+    LifecycleEventResponseSchema = z5.object({
+      /** Tag discriminating this response variant. */
+      kind: z5.literal("event"),
+      /** What happened. */
+      event: LifecycleEventKindSchema,
+      /** Logical id of the affected child. */
+      child_id: z5.string().min(1),
+      /** Exit code, when the OS reported one. */
+      exit_code: z5.number().int().optional(),
+      /** Terminating signal name, when the child was signalled (Unix). */
+      signal: z5.string().optional(),
+      /** Backoff delay (ms) before the pending restart, when applicable. */
+      restart_delay_ms: z5.number().int().nonnegative().optional()
+    }).strict();
+    ErrorResponseSchema = z5.object({
+      /** Tag discriminating this response variant. */
+      kind: z5.literal("error"),
+      /** Machine-readable error code (e.g. `E_UNKNOWN_CHILD`). */
+      code: z5.string().min(1),
+      /** Human-readable error message. */
+      message: z5.string()
+    }).strict();
+    SupervisorIpcResponseSchema = z5.discriminatedUnion("kind", [
+      SpawnedResponseSchema,
+      RestartedResponseSchema,
+      MonitorResponseSchema,
+      HealthResponseSchema,
+      LifecycleEventResponseSchema,
+      ErrorResponseSchema
+    ]);
+    SupervisorIpcRequestEnvelopeSchema = z5.object({
+      /** Frozen protocol version. */
+      protocol_version: z5.string(),
+      /** Correlation id echoed back on the matching response. */
+      id: z5.string().min(1),
+      /** Direction discriminator. */
+      direction: z5.literal("request"),
+      /** The request body. */
+      request: SupervisorIpcRequestSchema
+    }).strict();
+    SupervisorIpcResponseEnvelopeSchema = z5.object({
+      /** Frozen protocol version. */
+      protocol_version: z5.string(),
+      /** Correlation id echoed from the originating request (or a fresh id for events). */
+      id: z5.string().min(1),
+      /** Direction discriminator. */
+      direction: z5.literal("response"),
+      /** The response body. */
+      response: SupervisorIpcResponseSchema
+    }).strict();
+    SupervisorIpcEnvelopeSchema = z5.discriminatedUnion("direction", [
+      SupervisorIpcRequestEnvelopeSchema,
+      SupervisorIpcResponseEnvelopeSchema
+    ]);
+    SUPERVISOR_IPC_REQUEST_KINDS = ["spawn", "restart", "monitor", "health"];
+    SUPERVISOR_IPC_RESPONSE_KINDS = [
+      "spawned",
+      "restarted",
+      "monitor",
+      "health",
+      "event",
+      "error"
+    ];
+    SUPERVISOR_IPC_MESSAGE_KINDS = [
+      ...SUPERVISOR_IPC_REQUEST_KINDS,
+      ...SUPERVISOR_IPC_RESPONSE_KINDS
+    ];
+  }
+});
+
+// packages/contracts/src/daemon/health.ts
+import { z as z6 } from "zod";
+var SubsystemHealthSchema, HealthStatusSchema;
+var init_health = __esm({
+  "packages/contracts/src/daemon/health.ts"() {
+    "use strict";
+    init_messages();
+    SubsystemHealthSchema = ChildStatusSchema.extend({
+      /**
+       * Optional human-readable detail (e.g. last error message, queue depth).
+       * Diagnostic only — not part of the supervisor wire contract.
+       */
+      detail: z6.string().optional()
+    }).strict();
+    HealthStatusSchema = z6.object({
+      /** One health row per registered subsystem. */
+      subsystems: z6.array(SubsystemHealthSchema),
+      /**
+       * `true` iff every subsystem is in the `running` state. A convenience roll-up
+       * derived from {@link HealthStatusSchema.shape.subsystems}; recomputed by
+       * {@link summarizeHealth} so producers cannot desync it.
+       */
+      allHealthy: z6.boolean()
+    }).strict();
+  }
+});
+
+// packages/contracts/src/daemon/subsystem.ts
+var init_subsystem = __esm({
+  "packages/contracts/src/daemon/subsystem.ts"() {
+    "use strict";
+  }
+});
+
+// packages/contracts/src/daemon/index.ts
+var init_daemon = __esm({
+  "packages/contracts/src/daemon/index.ts"() {
+    "use strict";
+    init_health();
+    init_subsystem();
+  }
+});
+
+// packages/contracts/src/supervisor-ipc/version.ts
+var init_version = __esm({
+  "packages/contracts/src/supervisor-ipc/version.ts"() {
+    "use strict";
+  }
+});
+
+// packages/contracts/src/supervisor-ipc/index.ts
+var init_supervisor_ipc = __esm({
+  "packages/contracts/src/supervisor-ipc/index.ts"() {
+    "use strict";
+    init_messages();
+    init_version();
+  }
+});
+
+// packages/contracts/src/daemon-ipc/index.ts
+var init_daemon_ipc = __esm({
+  "packages/contracts/src/daemon-ipc/index.ts"() {
+    "use strict";
+    init_supervisor_ipc();
+    init_version();
+  }
+});
+
 // packages/contracts/src/db-inventory.json
 var db_inventory_default;
 var init_db_inventory = __esm({
@@ -998,7 +1232,7 @@ var init_db_inventory = __esm({
           role: "brain",
           tier: "project",
           filePathTemplate: "<projectRoot>/.cleo/brain.db",
-          drizzleSchemaPath: "packages/core/src/store/memory-schema.ts",
+          drizzleSchemaPath: "packages/core/src/store/schema/memory-schema.ts",
           migrationsDir: "packages/core/migrations/drizzle-brain/",
           ownerPackage: "@cleocode/brain",
           openedVia: "openCleoDb('brain', cwd)",
@@ -1011,7 +1245,7 @@ var init_db_inventory = __esm({
           role: "conduit",
           tier: "project",
           filePathTemplate: "<projectRoot>/.cleo/conduit.db",
-          drizzleSchemaPath: "packages/core/src/store/conduit-schema.ts",
+          drizzleSchemaPath: "packages/core/src/store/schema/conduit-schema.ts",
           migrationsDir: "packages/core/migrations/drizzle-conduit/",
           ownerPackage: "@cleocode/core",
           openedVia: "openCleoDb('conduit', cwd)",
@@ -1050,7 +1284,7 @@ var init_db_inventory = __esm({
           role: "nexus",
           tier: "global",
           filePathTemplate: "$XDG_DATA_HOME/cleo/nexus.db",
-          drizzleSchemaPath: "packages/core/src/store/nexus-schema.ts",
+          drizzleSchemaPath: "packages/core/src/store/schema/nexus-schema.ts",
           migrationsDir: "packages/core/migrations/drizzle-nexus/",
           ownerPackage: "@cleocode/core",
           openedVia: "openCleoDb('nexus')",
@@ -1063,7 +1297,7 @@ var init_db_inventory = __esm({
           role: "signaldock-project",
           tier: "project",
           filePathTemplate: "<projectRoot>/.cleo/signaldock.db",
-          drizzleSchemaPath: "packages/core/src/store/signaldock-schema.ts",
+          drizzleSchemaPath: "packages/core/src/store/schema/signaldock-schema.ts",
           migrationsDir: "packages/core/migrations/drizzle-signaldock/",
           ownerPackage: "@cleocode/core",
           openedVia: "HISTORICAL \u2014 project-tier signaldock.db was migrated into conduit.db post-T310/ADR-037. No live opener; charter row retained for migration provenance and legacy backup detection.",
@@ -1076,7 +1310,7 @@ var init_db_inventory = __esm({
           role: "signaldock-global",
           tier: "global",
           filePathTemplate: "$XDG_DATA_HOME/cleo/signaldock.db",
-          drizzleSchemaPath: "packages/core/src/store/signaldock-schema.ts",
+          drizzleSchemaPath: "packages/core/src/store/schema/signaldock-schema.ts",
           migrationsDir: "packages/core/migrations/drizzle-signaldock/",
           ownerPackage: "@cleocode/core",
           openedVia: "openCleoDb('signaldock')",
@@ -1089,7 +1323,7 @@ var init_db_inventory = __esm({
           role: "telemetry",
           tier: "global",
           filePathTemplate: "$XDG_DATA_HOME/cleo/telemetry.db",
-          drizzleSchemaPath: "packages/core/src/telemetry/schema.ts",
+          drizzleSchemaPath: "packages/core/src/store/schema/telemetry-schema.ts",
           migrationsDir: "packages/core/migrations/drizzle-telemetry/",
           ownerPackage: "@cleocode/core",
           openedVia: "@cleocode/core telemetry/sqlite.ts \u2014 lazy open on first event when opted-in; not yet registered as openCleoDb role",
@@ -1102,7 +1336,7 @@ var init_db_inventory = __esm({
           role: "skills",
           tier: "global",
           filePathTemplate: "$XDG_DATA_HOME/cleo/skills.db",
-          drizzleSchemaPath: "packages/core/src/store/skills-schema.ts",
+          drizzleSchemaPath: "packages/core/src/store/schema/skills-schema.ts",
           migrationsDir: "packages/core/migrations/drizzle-skills/",
           ownerPackage: "@cleocode/core",
           openedVia: "openCleoDb('skills')",
@@ -1115,7 +1349,7 @@ var init_db_inventory = __esm({
           role: "global-brain",
           tier: "global",
           filePathTemplate: "$XDG_DATA_HOME/cleo/brain.db",
-          drizzleSchemaPath: "packages/core/src/store/memory-schema.ts",
+          drizzleSchemaPath: "packages/core/src/store/schema/memory-schema.ts",
           migrationsDir: "packages/core/migrations/drizzle-brain/",
           ownerPackage: "@cleocode/brain",
           openedVia: "UNREGISTERED \u2014 file exists on disk (audit \xA71.2 row 3) but no live opener. Provenance unclear; likely orphan from a getCleoHome()-vs-project-resolution path bug. Tracked for cleanup decision under T10282/T10307.",
@@ -8671,6 +8905,20 @@ var init_operations_registry = __esm({
       // in the DomainHandler map) but absent from OPERATIONS, making them invisible
       // to public SDK consumers using @cleocode/core. Adding all 10 ops here.
       // ---------------------------------------------------------------------------
+      // sentient query: status (T11448 — exposed over MCP; mirrors the standalone
+      // mcp-adapter `cleo_sentient_status` tool + the `cleo sentient status` CLI op).
+      {
+        gateway: "query",
+        domain: "sentient",
+        operation: "status",
+        description: "sentient.status (query) \u2014 daemon state, kill-switch status, Tier-2 enabled flag, and proposal statistics",
+        tier: 2,
+        idempotent: true,
+        sessionRequired: false,
+        requiredParams: [],
+        params: [],
+        mcpExposed: true
+      },
       // sentient query: propose.list
       {
         gateway: "query",
@@ -8688,7 +8936,8 @@ var init_operations_registry = __esm({
             required: false,
             description: "Maximum number of proposals to return (default: 50)"
           }
-        ]
+        ],
+        mcpExposed: true
       },
       // sentient query: propose.diff
       {
@@ -8790,7 +9039,8 @@ var init_operations_registry = __esm({
         idempotent: true,
         sessionRequired: false,
         requiredParams: [],
-        params: []
+        params: [],
+        mcpExposed: true
       },
       // sentient mutate: propose.disable
       {
@@ -9628,6 +9878,118 @@ var init_operations_registry = __esm({
         ]
       },
       // ---------------------------------------------------------------------------
+      // T11373 — attention domain: Tier-2 scope-keyed working-memory jots (E2)
+      // ---------------------------------------------------------------------------
+      {
+        gateway: "mutate",
+        domain: "attention",
+        operation: "add",
+        description: "attention.add (mutate \xB7 alias jot) \u2014 record a scope-keyed working-memory jot. Session/agent identity + current task are auto-resolved from the environment (E0); the item keys to the narrowest scope (agent>task>epic>saga>session>global). No session/agent/task flags by default.",
+        tier: 1,
+        idempotent: false,
+        sessionRequired: false,
+        requiredParams: ["content"],
+        params: [
+          {
+            name: "content",
+            type: "string",
+            required: true,
+            description: "The jot content",
+            cli: { positional: true }
+          },
+          {
+            name: "tags",
+            type: "array",
+            required: false,
+            description: "Tags to attach (comma-separated on the CLI)"
+          },
+          {
+            name: "scope",
+            type: "string",
+            required: false,
+            description: "Explicit scope escalation: agent|task|epic|saga|session|global (default: narrowest)"
+          },
+          {
+            name: "ttlSeconds",
+            type: "number",
+            required: false,
+            description: "Optional time-to-live in seconds (sets expires_at)"
+          }
+        ]
+      },
+      {
+        gateway: "query",
+        domain: "attention",
+        operation: "list",
+        description: "attention.list (query) \u2014 list open working-memory jots visible to the calling agent across its resolved scope chain. Optional --scope / --tag filters.",
+        tier: 1,
+        idempotent: true,
+        sessionRequired: false,
+        requiredParams: [],
+        params: [
+          {
+            name: "scope",
+            type: "string",
+            required: false,
+            description: "Restrict to one scope kind: agent|task|epic|saga|session|global"
+          },
+          {
+            name: "tags",
+            type: "array",
+            required: false,
+            description: "Filter by tags (contains-ALL; comma-separated on the CLI)"
+          },
+          {
+            name: "includeAll",
+            type: "boolean",
+            required: false,
+            description: "Include non-open (consolidated/discarded) items too. Default: false"
+          },
+          {
+            name: "limit",
+            type: "number",
+            required: false,
+            description: "Maximum rows. Default: 50"
+          }
+        ]
+      },
+      {
+        gateway: "query",
+        domain: "attention",
+        operation: "show",
+        description: "attention.show (query) \u2014 synonym for attention.list; emits the open working-memory jots for the calling agent within token budget.",
+        tier: 1,
+        idempotent: true,
+        sessionRequired: false,
+        requiredParams: [],
+        params: [
+          {
+            name: "scope",
+            type: "string",
+            required: false,
+            description: "Restrict to one scope kind: agent|task|epic|saga|session|global"
+          },
+          {
+            name: "tags",
+            type: "array",
+            required: false,
+            description: "Filter by tags (contains-ALL; comma-separated on the CLI)"
+          },
+          {
+            name: "includeAll",
+            type: "boolean",
+            required: false,
+            description: "Include non-open items too. Default: false"
+          },
+          {
+            name: "limit",
+            type: "number",
+            required: false,
+            description: "Maximum rows. Default: 50"
+          }
+        ]
+      },
+      // ---------------------------------------------------------------------------
       // T10629 — tasks.context: bounded task-scoped context pack with token budget
       // ---------------------------------------------------------------------------
       {
@@ -9702,7 +10064,7 @@ var init_operations_registry = __esm({
 });
 
 // packages/contracts/src/docs/provenance.ts
-import { z as z5 } from "zod";
+import { z as z7 } from "zod";
 var PROVENANCE_NODE_KINDS, PROVENANCE_EDGE_RELATIONS, DOC_LIFECYCLE_STATUSES, provenanceNodeKindSchema, provenanceEdgeRelationSchema, docLifecycleStatusSchema, provenanceNodeBaseFields, provenanceDocNodeSchema, provenanceTaskNodeSchema, provenanceDecisionNodeSchema, provenanceSessionNodeSchema, provenanceMemoryNodeSchema, provenanceNodeSchema, provenanceEdgeSchema, docProvenanceResponseSchema;
 var init_provenance = __esm({
   "packages/contracts/src/docs/provenance.ts"() {
@@ -9728,69 +10090,69 @@ var init_provenance = __esm({
       "archived",
       "draft"
     ];
-    provenanceNodeKindSchema = z5.enum(PROVENANCE_NODE_KINDS);
-    provenanceEdgeRelationSchema = z5.enum(PROVENANCE_EDGE_RELATIONS);
-    docLifecycleStatusSchema = z5.enum(DOC_LIFECYCLE_STATUSES);
+    provenanceNodeKindSchema = z7.enum(PROVENANCE_NODE_KINDS);
+    provenanceEdgeRelationSchema = z7.enum(PROVENANCE_EDGE_RELATIONS);
+    docLifecycleStatusSchema = z7.enum(DOC_LIFECYCLE_STATUSES);
     provenanceNodeBaseFields = {
-      id: z5.string().min(1),
-      title: z5.string().min(1),
-      metadata: z5.record(z5.string(), z5.unknown()).optional()
+      id: z7.string().min(1),
+      title: z7.string().min(1),
+      metadata: z7.record(z7.string(), z7.unknown()).optional()
     };
-    provenanceDocNodeSchema = z5.object({
+    provenanceDocNodeSchema = z7.object({
       ...provenanceNodeBaseFields,
-      kind: z5.literal("doc"),
-      slug: z5.string().min(1),
-      docKind: z5.string().min(1),
+      kind: z7.literal("doc"),
+      slug: z7.string().min(1),
+      docKind: z7.string().min(1),
       lifecycleStatus: docLifecycleStatusSchema,
-      publishedAt: z5.string().min(1),
-      supersededAt: z5.string().min(1).optional(),
-      summary: z5.string().optional()
+      publishedAt: z7.string().min(1),
+      supersededAt: z7.string().min(1).optional(),
+      summary: z7.string().optional()
     });
-    provenanceTaskNodeSchema = z5.object({
+    provenanceTaskNodeSchema = z7.object({
       ...provenanceNodeBaseFields,
-      kind: z5.literal("task"),
-      taskType: z5.enum(["saga", "epic", "task", "subtask"]),
-      status: z5.enum(["pending", "in_progress", "done", "blocked", "cancelled", "archived"])
+      kind: z7.literal("task"),
+      taskType: z7.enum(["saga", "epic", "task", "subtask"]),
+      status: z7.enum(["pending", "in_progress", "done", "blocked", "cancelled", "archived"])
     });
-    provenanceDecisionNodeSchema = z5.object({
+    provenanceDecisionNodeSchema = z7.object({
       ...provenanceNodeBaseFields,
-      kind: z5.literal("decision"),
-      outcome: z5.enum(["proposed", "accepted", "rejected", "superseded"]),
-      decidedAt: z5.string().min(1)
+      kind: z7.literal("decision"),
+      outcome: z7.enum(["proposed", "accepted", "rejected", "superseded"]),
+      decidedAt: z7.string().min(1)
     });
-    provenanceSessionNodeSchema = z5.object({
+    provenanceSessionNodeSchema = z7.object({
       ...provenanceNodeBaseFields,
-      kind: z5.literal("session"),
-      startedAt: z5.string().min(1),
-      endedAt: z5.string().min(1).optional()
+      kind: z7.literal("session"),
+      startedAt: z7.string().min(1),
+      endedAt: z7.string().min(1).optional()
     });
-    provenanceMemoryNodeSchema = z5.object({
+    provenanceMemoryNodeSchema = z7.object({
       ...provenanceNodeBaseFields,
-      kind: z5.literal("memory"),
-      memoryType: z5.enum(["observation", "pattern", "decision", "diary"]),
-      recordedAt: z5.string().min(1)
+      kind: z7.literal("memory"),
+      memoryType: z7.enum(["observation", "pattern", "decision", "diary"]),
+      recordedAt: z7.string().min(1)
     });
-    provenanceNodeSchema = z5.discriminatedUnion("kind", [
+    provenanceNodeSchema = z7.discriminatedUnion("kind", [
       provenanceDocNodeSchema,
       provenanceTaskNodeSchema,
       provenanceDecisionNodeSchema,
       provenanceSessionNodeSchema,
       provenanceMemoryNodeSchema
     ]);
-    provenanceEdgeSchema = z5.object({
+    provenanceEdgeSchema = z7.object({
       relation: provenanceEdgeRelationSchema,
-      from: z5.string().min(1),
+      from: z7.string().min(1),
       fromKind: provenanceNodeKindSchema,
-      to: z5.string().min(1),
+      to: z7.string().min(1),
       toKind: provenanceNodeKindSchema,
-      addedAt: z5.string().min(1),
-      summary: z5.string().optional()
+      addedAt: z7.string().min(1),
+      summary: z7.string().optional()
     });
-    docProvenanceResponseSchema = z5.object({
-      nodes: z5.array(provenanceNodeSchema).readonly(),
-      edges: z5.array(provenanceEdgeSchema).readonly(),
-      totalNodes: z5.number().int().nonnegative(),
-      totalEdges: z5.number().int().nonnegative()
+    docProvenanceResponseSchema = z7.object({
+      nodes: z7.array(provenanceNodeSchema).readonly(),
+      edges: z7.array(provenanceEdgeSchema).readonly(),
+      totalNodes: z7.number().int().nonnegative(),
+      totalEdges: z7.number().int().nonnegative()
     });
   }
 });
@@ -9848,72 +10210,72 @@ var init_errors = __esm({
 });
 
 // packages/contracts/src/evidence-atom-schema.ts
-import { z as z6 } from "zod";
+import { z as z8 } 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 = z6.object({
-      kind: z6.literal("commit"),
-      sha: z6.string().regex(/^[0-9a-f]{7,40}$/i, "commit sha must be 7-40 hex characters")
+    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")
     });
-    filesAtomSchema = z6.object({
-      kind: z6.literal("files"),
-      paths: z6.array(z6.string().min(1)).min(1, "files atom requires at least one path")
+    filesAtomSchema = z8.object({
+      kind: z8.literal("files"),
+      paths: z8.array(z8.string().min(1)).min(1, "files atom requires at least one path")
     });
-    testRunAtomSchema = z6.object({
-      kind: z6.literal("test-run"),
-      path: z6.string().min(1, "test-run atom requires a non-empty path")
+    testRunAtomSchema = z8.object({
+      kind: z8.literal("test-run"),
+      path: z8.string().min(1, "test-run atom requires a non-empty path")
     });
-    toolAtomSchema = z6.object({
-      kind: z6.literal("tool"),
-      tool: z6.string().min(1, "tool atom requires a non-empty tool name")
+    toolAtomSchema = z8.object({
+      kind: z8.literal("tool"),
+      tool: z8.string().min(1, "tool atom requires a non-empty tool name")
     });
-    urlAtomSchema = z6.object({
-      kind: z6.literal("url"),
-      url: z6.string().min(1).regex(/^https?:\/\//, "url atom must start with http:// or https://")
+    urlAtomSchema = z8.object({
+      kind: z8.literal("url"),
+      url: z8.string().min(1).regex(/^https?:\/\//, "url atom must start with http:// or https://")
     });
-    noteAtomSchema = z6.object({
-      kind: z6.literal("note"),
-      note: z6.string().min(1, "note atom must be non-empty").max(512, "note atom is too long (max 512 chars)")
+    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)")
     });
-    decisionAtomSchema = z6.object({
-      kind: z6.literal("decision"),
-      decisionId: z6.string().min(1, "decision atom requires a non-empty decision ID")
+    decisionAtomSchema = z8.object({
+      kind: z8.literal("decision"),
+      decisionId: z8.string().min(1, "decision atom requires a non-empty decision ID")
     });
-    prAtomSchema = z6.object({
-      kind: z6.literal("pr"),
-      prNumber: z6.number().int().positive("pr atom requires a positive integer PR number")
+    prAtomSchema = z8.object({
+      kind: z8.literal("pr"),
+      prNumber: z8.number().int().positive("pr atom requires a positive integer PR number")
     });
-    locDropAtomSchema = z6.object({
-      kind: z6.literal("loc-drop"),
-      fromLines: z6.number().int().nonnegative("loc-drop fromLines must be \u2265 0"),
-      toLines: z6.number().int().nonnegative("loc-drop toLines must be \u2265 0")
+    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")
     });
-    callsiteCoverageAtomSchema = z6.object({
-      kind: z6.literal("callsite-coverage"),
-      symbolName: z6.string().min(1, "callsite-coverage atom requires a non-empty symbolName"),
-      relativeSourcePath: z6.string().min(1, "callsite-coverage atom requires a non-empty relativeSourcePath")
+    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")
     });
     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 = z6.object({
-      kind: z6.literal("satisfies"),
+    satisfiesAtomSchema = z8.object({
+      kind: z8.literal("satisfies"),
       /** Target task ID — `T<1-7 digits>` per ADR-079-r2 §2.1. */
-      targetTaskId: z6.string().regex(SATISFIES_TASK_ID_REGEX, "satisfies atom targetTaskId must match /^T[0-9]{1,7}$/"),
+      targetTaskId: z8.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: z6.string().regex(AC_UUID_REGEX, "satisfies atom targetAcId must be a lowercase UUIDv4/v5").optional(),
+      targetAcId: z8.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: z6.string().regex(AC_ALIAS_REGEX, "satisfies atom targetAcAlias must match /^AC[0-9]{1,4}$/").optional(),
+      targetAcAlias: z8.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: z6.string().regex(
+      versionPin: z8.string().regex(
         SATISFIES_VERSION_PIN_REGEX,
         "satisfies atom versionPin must be 14 digits (YYYYMMDDhhmmss)"
       ).optional()
     });
-    EvidenceAtomSchema = z6.discriminatedUnion("kind", [
+    EvidenceAtomSchema = z8.discriminatedUnion("kind", [
       commitAtomSchema,
       filesAtomSchema,
       testRunAtomSchema,
@@ -9960,58 +10322,58 @@ var init_evidence_atom_schema = __esm({
 });
 
 // packages/contracts/src/evidence-record-schema.ts
-import { z as z7 } from "zod";
+import { z as z9 } 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 = z7.object({
+    evidenceBaseSchema = z9.object({
       /** Identity string of the agent that produced this record. */
-      agentIdentity: z7.string().min(1),
+      agentIdentity: z9.string().min(1),
       /** SHA-256 hex digest (64 chars) of the attached artifact. */
-      attachmentSha256: z7.string().length(64),
+      attachmentSha256: z9.string().length(64),
       /** ISO 8601 timestamp at which the action ran. */
-      ranAt: z7.string().datetime(),
+      ranAt: z9.string().datetime(),
       /** Wall-clock duration of the action in milliseconds. */
-      durationMs: z7.number().nonnegative()
+      durationMs: z9.number().nonnegative()
     });
     implDiffRecordSchema = evidenceBaseSchema.extend({
-      kind: z7.literal("impl-diff"),
-      phase: z7.literal("implement"),
-      filesChanged: z7.array(z7.string().min(1)).min(1),
-      linesAdded: z7.number().int().nonnegative(),
-      linesRemoved: z7.number().int().nonnegative()
+      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()
     });
     validateSpecCheckRecordSchema = evidenceBaseSchema.extend({
-      kind: z7.literal("validate-spec-check"),
-      phase: z7.literal("validate"),
-      reqIdsChecked: z7.array(z7.string().min(1)).min(1),
-      passed: z7.boolean(),
-      details: z7.string().min(1)
+      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)
     });
     testOutputRecordSchema = evidenceBaseSchema.extend({
-      kind: z7.literal("test-output"),
-      phase: z7.literal("test"),
-      command: z7.string().min(1),
-      exitCode: z7.number().int(),
-      testsPassed: z7.number().int().nonnegative(),
-      testsFailed: z7.number().int().nonnegative()
+      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()
     });
     lintReportRecordSchema = evidenceBaseSchema.extend({
-      kind: z7.literal("lint-report"),
-      phase: z7.enum(["implement", "test"]),
-      tool: z7.string().min(1),
-      passed: z7.boolean(),
-      warnings: z7.number().int().nonnegative(),
-      errors: z7.number().int().nonnegative()
+      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()
     });
     commandOutputRecordSchema = evidenceBaseSchema.extend({
-      kind: z7.literal("command-output"),
-      phase: z7.enum(["implement", "validate", "test"]),
-      cmd: z7.string().min(1),
-      exitCode: z7.number().int()
+      kind: z9.literal("command-output"),
+      phase: z9.enum(["implement", "validate", "test"]),
+      cmd: z9.string().min(1),
+      exitCode: z9.number().int()
     });
-    evidenceRecordSchema = z7.discriminatedUnion("kind", [
+    evidenceRecordSchema = z9.discriminatedUnion("kind", [
       implDiffRecordSchema,
       validateSpecCheckRecordSchema,
       testOutputRecordSchema,
@@ -10028,6 +10390,26 @@ var init_facade = __esm({
   }
 });
 
+// packages/contracts/src/goal.ts
+var GOAL_STATUSES, GOAL_TERMINAL_STATUSES;
+var init_goal = __esm({
+  "packages/contracts/src/goal.ts"() {
+    "use strict";
+    GOAL_STATUSES = Object.freeze([
+      "active",
+      "paused",
+      "satisfied",
+      "abandoned",
+      "impossible"
+    ]);
+    GOAL_TERMINAL_STATUSES = Object.freeze([
+      "satisfied",
+      "abandoned",
+      "impossible"
+    ]);
+  }
+});
+
 // packages/contracts/src/graph.ts
 var init_graph = __esm({
   "packages/contracts/src/graph.ts"() {
@@ -10508,6 +10890,13 @@ var init_observe = __esm({
   }
 });
 
+// packages/contracts/src/mvi.ts
+var init_mvi = __esm({
+  "packages/contracts/src/mvi.ts"() {
+    "use strict";
+  }
+});
+
 // packages/contracts/src/status-registry.ts
 var TASK_STATUSES;
 var init_status_registry = __esm({
@@ -10526,7 +10915,7 @@ var init_status_registry = __esm({
 });
 
 // packages/contracts/src/workgraph.ts
-import { z as z8 } from "zod";
+import { z as z10 } 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"() {
@@ -10534,10 +10923,10 @@ var init_workgraph = __esm({
     init_enums();
     init_status_registry();
     E_WORKGRAPH_PARENT_TYPE_MATRIX = "E_WORKGRAPH_PARENT_TYPE_MATRIX";
-    taskTypeSchema = z8.enum(["saga", "epic", "task", "subtask"]);
-    taskPrioritySchema = z8.enum(["critical", "high", "medium", "low"]);
-    taskStatusSchema = z8.enum(TASK_STATUSES);
-    verificationGateSchema = z8.enum([
+    taskTypeSchema = z10.enum(["saga", "epic", "task", "subtask"]);
+    taskPrioritySchema = z10.enum(["critical", "high", "medium", "low"]);
+    taskStatusSchema = z10.enum(TASK_STATUSES);
+    verificationGateSchema = z10.enum([
       "implemented",
       "testsPassed",
       "qaPassed",
@@ -10546,7 +10935,7 @@ var init_workgraph = __esm({
       "documented",
       "nexusImpact"
     ]);
-    workGraphRelationKindSchema = z8.enum([
+    workGraphRelationKindSchema = z10.enum([
       "contains",
       "depends_on",
       "blocks",
@@ -10554,317 +10943,317 @@ var init_workgraph = __esm({
       "groups",
       "satisfies"
     ]);
-    workGraphTraversalDirectionSchema = z8.enum([
+    workGraphTraversalDirectionSchema = z10.enum([
       "ancestors",
       "descendants",
       "upstream",
       "downstream"
     ]);
-    workGraphEdgeDirectionSchema = z8.enum(["out", "in", "both"]);
-    paginationParamsSchema = z8.object({
-      cursor: z8.string().min(1).optional(),
-      limit: z8.number().int().positive().max(500).optional()
+    workGraphEdgeDirectionSchema = z10.enum(["out", "in", "both"]);
+    paginationParamsSchema = z10.object({
+      cursor: z10.string().min(1).optional(),
+      limit: z10.number().int().positive().max(500).optional()
     });
-    workGraphNodeSchema = z8.object({
-      id: z8.string().min(1),
+    workGraphNodeSchema = z10.object({
+      id: z10.string().min(1),
       type: taskTypeSchema,
-      title: z8.string(),
+      title: z10.string(),
       status: taskStatusSchema,
       priority: taskPrioritySchema,
-      parentId: z8.string().min(1).optional()
+      parentId: z10.string().min(1).optional()
     });
-    workGraphEdgeSchema = z8.object({
-      fromId: z8.string().min(1),
-      toId: z8.string().min(1),
+    workGraphEdgeSchema = z10.object({
+      fromId: z10.string().min(1),
+      toId: z10.string().min(1),
       kind: workGraphRelationKindSchema
     });
-    workGraphHierarchyEdgeSchema = z8.object({
-      fromId: z8.string().min(1),
-      toId: z8.string().min(1),
-      kind: z8.literal("contains")
+    workGraphHierarchyEdgeSchema = z10.object({
+      fromId: z10.string().min(1),
+      toId: z10.string().min(1),
+      kind: z10.literal("contains")
     }).strict();
-    workGraphPageInfoSchema = z8.object({
-      nextCursor: z8.string().min(1).optional(),
-      hasMore: z8.boolean()
-    });
-    workGraphRollupCountsSchema = z8.object({
-      total: z8.number().int().nonnegative(),
-      byStatus: z8.partialRecord(taskStatusSchema, z8.number().int().nonnegative()),
-      byType: z8.partialRecord(taskTypeSchema, z8.number().int().nonnegative())
-    });
-    workGraphSubtreePercentagesSchema = z8.object({
-      done: z8.number().nonnegative(),
-      active: z8.number().nonnegative(),
-      blocked: z8.number().nonnegative(),
-      pending: z8.number().nonnegative(),
-      cancelled: z8.number().nonnegative()
-    });
-    workGraphProjectionMismatchSchema = z8.object({
-      field: z8.string().min(1),
-      expected: z8.number().int().nonnegative(),
-      actual: z8.number().int().nonnegative()
+    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()
     });
     workGraphReadyFrontierTaskSchema = workGraphNodeSchema.extend({
-      role: z8.string().min(1).optional(),
-      dependencyBlockers: z8.array(z8.object({ taskId: z8.string().min(1), status: taskStatusSchema })),
-      gateBlockers: z8.array(z8.object({ gate: verificationGateSchema }))
+      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 }))
     });
     workGraphRelationEdgeSchema = workGraphEdgeSchema.extend({
-      source: z8.literal("relation"),
-      relationType: z8.enum(TASK_RELATION_TYPES),
-      reason: z8.string().min(1).optional()
+      source: z10.literal("relation"),
+      relationType: z10.enum(TASK_RELATION_TYPES),
+      reason: z10.string().min(1).optional()
     });
     workGraphDependencyEdgeSchema = workGraphEdgeSchema.extend({
-      source: z8.literal("dependency"),
-      kind: z8.literal("depends_on")
+      source: z10.literal("dependency"),
+      kind: z10.literal("depends_on")
     });
-    workGraphOmissionReasonSchema = z8.enum([
+    workGraphOmissionReasonSchema = z10.enum([
       "budget_exceeded",
       "not_requested",
       "not_available",
       "redacted",
       "truncated"
     ]);
-    workGraphContextBudgetSchema = z8.object({
-      tokenBudget: z8.number().int().nonnegative(),
-      estimatedTokens: z8.number().int().nonnegative(),
-      remainingTokens: z8.number().int().nonnegative(),
-      truncated: z8.boolean()
-    });
-    workGraphOmissionSchema = z8.object({
-      path: z8.string().min(1),
+    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),
       reason: workGraphOmissionReasonSchema,
-      message: z8.string().min(1),
-      estimatedTokens: z8.number().int().nonnegative().optional()
+      message: z10.string().min(1),
+      estimatedTokens: z10.number().int().nonnegative().optional()
     });
-    workGraphDirectEdgeSchema = z8.discriminatedUnion("source", [
+    workGraphDirectEdgeSchema = z10.discriminatedUnion("source", [
       workGraphRelationEdgeSchema,
       workGraphDependencyEdgeSchema
     ]);
     workGraphContextPackParamsSchema = paginationParamsSchema.extend({
-      rootId: z8.string().min(1),
-      tokenBudget: z8.number().int().positive().optional(),
-      includeRelations: z8.boolean().optional(),
-      includeReadiness: z8.boolean().optional(),
-      includeRollup: z8.boolean().optional()
+      rootId: z10.string().min(1),
+      tokenBudget: z10.number().int().positive().optional(),
+      includeRelations: z10.boolean().optional(),
+      includeReadiness: z10.boolean().optional(),
+      includeRollup: z10.boolean().optional()
     });
     workGraphSliceParamsSchema = paginationParamsSchema.extend({
-      rootId: z8.string().min(1),
+      rootId: z10.string().min(1),
       direction: workGraphTraversalDirectionSchema.optional(),
-      maxDepth: z8.number().int().nonnegative().optional(),
-      includeRelations: z8.boolean().optional()
+      maxDepth: z10.number().int().nonnegative().optional(),
+      includeRelations: z10.boolean().optional()
     });
-    workGraphSliceSchema = z8.object({
-      rootId: z8.string().min(1),
+    workGraphSliceSchema = z10.object({
+      rootId: z10.string().min(1),
       direction: workGraphTraversalDirectionSchema,
-      nodes: z8.array(workGraphNodeSchema),
-      edges: z8.array(workGraphEdgeSchema),
+      nodes: z10.array(workGraphNodeSchema),
+      edges: z10.array(workGraphEdgeSchema),
       pageInfo: workGraphPageInfoSchema,
-      omissions: z8.array(workGraphOmissionSchema).optional()
-    });
-    workGraphReadinessParamsSchema = z8.object({
-      rootId: z8.string().min(1),
-      role: z8.string().min(1).optional(),
-      includeGateBlockers: z8.boolean().optional()
-    });
-    workGraphReadinessResultSchema = z8.object({
-      rootId: z8.string().min(1),
-      role: z8.string().min(1).optional(),
-      ready: z8.boolean(),
-      warnings: z8.array(z8.string()),
-      groups: z8.object({
-        ready: z8.array(workGraphReadyFrontierTaskSchema),
-        blocked: z8.array(workGraphReadyFrontierTaskSchema),
-        blockedBy: z8.array(
-          z8.discriminatedUnion("kind", [
-            z8.object({
-              kind: z8.literal("dependency"),
-              blockerId: z8.string().min(1),
-              blocks: z8.array(z8.string().min(1))
+      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))
             }),
-            z8.object({
-              kind: z8.literal("gate"),
+            z10.object({
+              kind: z10.literal("gate"),
               gate: verificationGateSchema,
-              blocks: z8.array(z8.string().min(1))
+              blocks: z10.array(z10.string().min(1))
             })
           ])
         )
       })
     });
-    workGraphContextPackSchema = z8.object({
-      rootId: z8.string().min(1),
-      generatedAt: z8.string().min(1),
+    workGraphContextPackSchema = z10.object({
+      rootId: z10.string().min(1),
+      generatedAt: z10.string().min(1),
       budget: workGraphContextBudgetSchema,
       slice: workGraphSliceSchema,
-      relationEdges: z8.object({
-        rootId: z8.string().min(1),
+      relationEdges: z10.object({
+        rootId: z10.string().min(1),
         direction: workGraphEdgeDirectionSchema,
-        edges: z8.array(workGraphDirectEdgeSchema)
+        edges: z10.array(workGraphDirectEdgeSchema)
       }).optional(),
       readiness: workGraphReadinessResultSchema.optional(),
-      rollup: z8.lazy(() => tasksRollupResultSchema).optional(),
-      omissions: z8.array(workGraphOmissionSchema)
-    });
-    workGraphScaffoldValidateParamsSchema = z8.object({
-      rootId: z8.string().min(1),
-      nodes: z8.array(
-        z8.object({
-          id: z8.string().min(1),
+      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),
           type: taskTypeSchema,
-          parentId: z8.string().min(1).nullable().optional()
+          parentId: z10.string().min(1).nullable().optional()
         })
       ),
-      edges: z8.array(workGraphDirectEdgeSchema).optional(),
-      dryRun: z8.boolean().optional()
-    });
-    workGraphScaffoldValidationIssueSchema = z8.object({
-      code: z8.string().min(1),
-      message: z8.string().min(1),
-      taskId: z8.string().min(1).optional(),
-      severity: z8.enum(["error", "warning"])
-    });
-    workGraphScaffoldValidateResultSchema = z8.object({
-      rootId: z8.string().min(1),
-      valid: z8.boolean(),
-      dryRun: z8.boolean(),
-      issues: z8.array(workGraphScaffoldValidationIssueSchema),
-      hierarchy: z8.object({
-        valid: z8.boolean(),
-        violations: z8.array(
-          z8.object({
-            code: z8.literal(E_WORKGRAPH_PARENT_TYPE_MATRIX),
-            taskId: z8.string().min(1),
+      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),
             taskType: taskTypeSchema,
-            parentId: z8.string().min(1).nullable(),
+            parentId: z10.string().min(1).nullable(),
             parentType: taskTypeSchema.optional(),
-            message: z8.string().min(1)
+            message: z10.string().min(1)
           })
         )
       })
     });
     workGraphScaffoldApplyParamsSchema = workGraphScaffoldValidateParamsSchema.extend({
-      apply: z8.boolean().optional()
+      apply: z10.boolean().optional()
     });
     workGraphScaffoldApplyResultSchema = workGraphScaffoldValidateResultSchema.extend({
-      applied: z8.boolean(),
-      nodesChanged: z8.number().int().nonnegative(),
-      edgesChanged: z8.number().int().nonnegative()
-    });
-    workGraphPlanningDocParamsSchema = z8.object({
-      rootId: z8.string().min(1),
-      audience: z8.enum(["agent", "maintainer"]),
-      tokenBudget: z8.number().int().positive().optional(),
-      includeRelations: z8.boolean().optional(),
-      includeReadiness: z8.boolean().optional(),
-      includeRollup: z8.boolean().optional()
-    });
-    workGraphPlanningDocSchema = z8.object({
-      rootId: z8.string().min(1),
-      generatedAt: z8.string().min(1),
-      audience: z8.enum(["agent", "maintainer"]),
-      title: z8.string().min(1),
-      content: z8.string(),
-      sections: z8.array(z8.string().min(1)),
-      estimatedTokens: z8.number().int().nonnegative(),
-      budget: z8.object({
-        tokenBudget: z8.number().int().positive(),
-        truncated: z8.boolean()
+      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()
       }).optional()
     });
     tasksTraverseParamsSchema = paginationParamsSchema.extend({
-      rootId: z8.string().min(1),
+      rootId: z10.string().min(1),
       direction: workGraphTraversalDirectionSchema,
-      maxDepth: z8.number().int().nonnegative().optional(),
-      includeRelations: z8.boolean().optional()
+      maxDepth: z10.number().int().nonnegative().optional(),
+      includeRelations: z10.boolean().optional()
     });
-    tasksTraverseResultSchema = z8.object({
-      rootId: z8.string().min(1),
+    tasksTraverseResultSchema = z10.object({
+      rootId: z10.string().min(1),
       direction: workGraphTraversalDirectionSchema,
-      nodes: z8.array(workGraphNodeSchema),
-      edges: z8.array(workGraphEdgeSchema),
+      nodes: z10.array(workGraphNodeSchema),
+      edges: z10.array(workGraphEdgeSchema),
       pageInfo: workGraphPageInfoSchema
     });
     tasksTreeParamsSchema = paginationParamsSchema.extend({
-      rootId: z8.string().min(1),
-      maxDepth: z8.number().int().nonnegative().optional()
+      rootId: z10.string().min(1),
+      maxDepth: z10.number().int().nonnegative().optional()
     });
-    tasksTreeResultSchema = z8.object({
-      rootId: z8.string().min(1),
-      nodes: z8.array(workGraphNodeSchema.extend({ depth: z8.number().int().positive() })),
-      edges: z8.array(workGraphHierarchyEdgeSchema),
+    tasksTreeResultSchema = z10.object({
+      rootId: z10.string().min(1),
+      nodes: z10.array(workGraphNodeSchema.extend({ depth: z10.number().int().positive() })),
+      edges: z10.array(workGraphHierarchyEdgeSchema),
       pageInfo: workGraphPageInfoSchema
     });
-    tasksRollupParamsSchema = z8.object({
-      rootId: z8.string().min(1),
+    tasksRollupParamsSchema = z10.object({
+      rootId: z10.string().min(1),
       expectedDirectRollup: workGraphRollupCountsSchema.optional()
     });
-    tasksRollupResultSchema = z8.object({
-      rootId: z8.string().min(1),
+    tasksRollupResultSchema = z10.object({
+      rootId: z10.string().min(1),
       direct: workGraphRollupCountsSchema,
       subtree: workGraphRollupCountsSchema,
-      percentDenominator: z8.object({
-        basis: z8.literal("subtree-total"),
-        total: z8.number().int().nonnegative(),
-        description: z8.string().min(1)
+      percentDenominator: z10.object({
+        basis: z10.literal("subtree-total"),
+        total: z10.number().int().nonnegative(),
+        description: z10.string().min(1)
       }),
       percentages: workGraphSubtreePercentagesSchema,
-      staleProjection: z8.boolean(),
-      projectionMismatches: z8.array(workGraphProjectionMismatchSchema)
-    });
-    tasksFrontierParamsSchema = z8.object({
-      rootId: z8.string().min(1),
-      role: z8.string().min(1).optional()
-    });
-    tasksFrontierResultSchema = z8.object({
-      rootId: z8.string().min(1),
-      role: z8.string().min(1).optional(),
-      groups: z8.object({
-        ready: z8.array(workGraphReadyFrontierTaskSchema),
-        blocked: z8.array(workGraphReadyFrontierTaskSchema),
-        blockedBy: z8.array(
-          z8.discriminatedUnion("kind", [
-            z8.object({
-              kind: z8.literal("dependency"),
-              blockerId: z8.string().min(1),
-              blocks: z8.array(z8.string().min(1))
+      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))
             }),
-            z8.object({
-              kind: z8.literal("gate"),
+            z10.object({
+              kind: z10.literal("gate"),
               gate: verificationGateSchema,
-              blocks: z8.array(z8.string().min(1))
+              blocks: z10.array(z10.string().min(1))
             })
           ])
         )
       })
     });
     tasksWorkGraphAuditParamsSchema = paginationParamsSchema.extend({
-      rootId: z8.string().min(1),
-      maxDepth: z8.number().int().nonnegative().optional(),
-      includeRelations: z8.boolean().optional()
-    });
-    tasksWorkGraphAuditResultSchema = z8.object({
-      rootId: z8.string().min(1),
-      hierarchy: z8.object({
-        valid: z8.boolean(),
-        violations: z8.array(
-          z8.object({
-            code: z8.literal(E_WORKGRAPH_PARENT_TYPE_MATRIX),
-            taskId: z8.string().min(1),
+      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),
             taskType: taskTypeSchema,
-            parentId: z8.string().min(1).nullable(),
+            parentId: z10.string().min(1).nullable(),
             parentType: taskTypeSchema.optional(),
-            message: z8.string().min(1)
+            message: z10.string().min(1)
           })
         )
       }),
       traversal: tasksTraverseResultSchema,
       frontier: tasksFrontierResultSchema,
       rollup: tasksRollupResultSchema,
-      relationEdges: z8.object({
-        rootId: z8.string().min(1),
+      relationEdges: z10.object({
+        rootId: z10.string().min(1),
         direction: workGraphEdgeDirectionSchema,
-        edges: z8.array(
-          z8.discriminatedUnion("source", [
+        edges: z10.array(
+          z10.discriminatedUnion("source", [
             workGraphRelationEdgeSchema,
             workGraphDependencyEdgeSchema
           ])
@@ -10897,6 +11286,13 @@ var init_agent_operation_contract = __esm({
   }
 });
 
+// packages/contracts/src/operations/attention.ts
+var init_attention = __esm({
+  "packages/contracts/src/operations/attention.ts"() {
+    "use strict";
+  }
+});
+
 // packages/contracts/src/operations/brain.ts
 var init_brain = __esm({
   "packages/contracts/src/operations/brain.ts"() {
@@ -11085,6 +11481,7 @@ var init_operations = __esm({
     "use strict";
     init_admin();
     init_agent_operation_contract();
+    init_attention();
     init_brain();
     init_conduit();
     init_dialectic();
@@ -11130,31 +11527,31 @@ var init_peer = __esm({
 });
 
 // packages/contracts/src/release/evidence-atoms.ts
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
 var parsedPrEvidenceAtomSchema, prEvidenceStateModifierSchema, ghPrViewSchema, PR_REQUIRED_WORKFLOWS;
 var init_evidence_atoms = __esm({
   "packages/contracts/src/release/evidence-atoms.ts"() {
     "use strict";
-    parsedPrEvidenceAtomSchema = z9.object({
-      kind: z9.literal("pr"),
-      prNumber: z9.number().int().positive()
-    });
-    prEvidenceStateModifierSchema = z9.object({
-      kind: z9.literal("state"),
-      value: z9.literal("MERGED")
-    });
-    ghPrViewSchema = z9.object({
-      state: z9.enum(["OPEN", "CLOSED", "MERGED"]),
-      mergedAt: z9.string().nullable(),
-      headRefOid: z9.string().optional(),
-      mergeable: z9.string().optional(),
-      statusCheckRollup: z9.array(
-        z9.object({
-          __typename: z9.string().optional(),
-          name: z9.string().optional(),
-          workflowName: z9.string().optional(),
-          conclusion: z9.string().nullable().optional(),
-          status: z9.string().optional()
+    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()
         }).passthrough()
       ).optional().default([])
     }).passthrough();
@@ -11167,7 +11564,7 @@ var init_evidence_atoms = __esm({
 });
 
 // packages/contracts/src/release/plan.ts
-import { z as z10 } from "zod";
+import { z as z12 } 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"() {
@@ -11210,20 +11607,20 @@ var init_plan = __esm({
     ];
     IMPACT = ["major", "minor", "patch"];
     RESOLVED_SOURCE = ["project-context", "language-default", "legacy-alias"];
-    ReleaseChannelSchema = z10.enum(RELEASE_CHANNEL);
-    ReleaseSchemeSchema = z10.enum(RELEASE_SCHEME);
-    ReleaseKindSchema = z10.enum(RELEASE_KIND);
-    ReleaseStatusSchema = z10.enum(RELEASE_STATUS);
-    GateStatusSchema = z10.enum(GATE_STATUS);
-    GateNameSchema = z10.enum(GATE_NAME);
-    PlatformTupleSchema = z10.enum(PLATFORM_TUPLE);
-    PublisherSchema = z10.enum(PUBLISHER);
-    TaskKindSchema = z10.enum(TASK_KIND);
-    ImpactSchema = z10.enum(IMPACT);
-    ResolvedSourceSchema = z10.enum(RESOLVED_SOURCE);
-    Iso8601 = z10.iso.datetime({ offset: true });
-    NonEmptyString = z10.string().min(1);
-    ReleasePlanTaskSchema = z10.object({
+    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({
       /** Task ID (e.g. "T10001"). Format intentionally loose so historical IDs validate. */
       id: NonEmptyString,
       /** Conventional-commit-aligned task classification. */
@@ -11231,20 +11628,20 @@ var init_plan = __esm({
       /** SemVer impact classification. */
       impact: ImpactSchema,
       /** Human-readable changelog line for this task. */
-      userFacingSummary: z10.string(),
+      userFacingSummary: z12.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: z10.array(NonEmptyString),
+      evidenceAtoms: z12.array(NonEmptyString),
       /** IVTR phase at plan time — informational only per R-316. */
-      ivtrPhaseAtPlan: z10.string().optional(),
+      ivtrPhaseAtPlan: z12.string().optional(),
       /** Epic this task rolls up to, locked at plan time per R-303. */
       epicAncestor: NonEmptyString
     });
-    ReleaseGateSchema = z10.object({
+    ReleaseGateSchema = z12.object({
       /** Canonical gate name. */
       name: GateNameSchema,
       /** ADR-051 atom string identifying the resolved tool (e.g. `tool:test`). */
@@ -11254,11 +11651,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: z10.string().optional(),
+      resolvedCommand: z12.string().optional(),
       /** Provenance of the resolved command. Optional for unresolved gates. */
       resolvedSource: ResolvedSourceSchema.optional()
     });
-    ReleasePlatformMatrixEntrySchema = z10.object({
+    ReleasePlatformMatrixEntrySchema = z12.object({
       /** Target platform tuple. */
       platform: PlatformTupleSchema,
       /** Distribution backend. */
@@ -11266,47 +11663,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: z10.boolean().default(true).optional()
+      smoke: z12.boolean().default(true).optional()
     });
-    ReleasePreflightSummarySchema = z10.object({
+    ReleasePreflightSummarySchema = z12.object({
       /** True if esbuild externals are out of sync with package.json. */
-      esbuildExternalsDrift: z10.boolean(),
+      esbuildExternalsDrift: z12.boolean(),
       /** True if `pnpm-lock.yaml` diverges from the workspace manifest. */
-      lockfileDrift: z10.boolean(),
+      lockfileDrift: z12.boolean(),
       /** True if all epic children are in terminal lifecycle states. */
-      epicCompletenessClean: z10.boolean(),
+      epicCompletenessClean: z12.boolean(),
       /** True if no task appears in multiple in-flight release plans. */
-      doubleListingClean: z10.boolean(),
+      doubleListingClean: z12.boolean(),
       /** Non-fatal preflight warnings (e.g. unresolved tools per R-024). */
-      preflightWarnings: z10.array(z10.string()).default([]).optional()
+      preflightWarnings: z12.array(z12.string()).default([]).optional()
     });
-    ReleasePlanChangelogSchema = z10.object({
+    ReleasePlanChangelogSchema = z12.object({
       /** `kind=feat` tasks. */
-      features: z10.array(NonEmptyString).default([]),
+      features: z12.array(NonEmptyString).default([]),
       /** `kind=fix` or `kind=hotfix` tasks. */
-      fixes: z10.array(NonEmptyString).default([]),
+      fixes: z12.array(NonEmptyString).default([]),
       /** `kind=chore`, `docs`, `refactor`, `test`, `perf` tasks. */
-      chores: z10.array(NonEmptyString).default([]),
+      chores: z12.array(NonEmptyString).default([]),
       /** `kind=breaking` or `kind=revert` tasks. */
-      breaking: z10.array(NonEmptyString).default([])
+      breaking: z12.array(NonEmptyString).default([])
     });
-    ReleasePlanMetaSchema = z10.object({
+    ReleasePlanMetaSchema = z12.object({
       /** True if this is the project's first ever release. */
-      firstEverRelease: z10.boolean().optional(),
+      firstEverRelease: z12.boolean().optional(),
       /** Canonical tool names that could not be resolved at plan time. */
-      unresolvedTools: z10.array(z10.string()).optional(),
+      unresolvedTools: z12.array(z12.string()).optional(),
       /** Project archetype detected at plan time. */
-      archetype: z10.string().optional()
-    }).catchall(z10.unknown());
-    ReleasePlanSchema = z10.object({
+      archetype: z12.string().optional()
+    }).catchall(z12.unknown());
+    ReleasePlanSchema = z12.object({
       /** Schema URL for this plan version. */
-      $schema: z10.string().optional(),
+      $schema: z12.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: z10.boolean(),
+      suffixApplied: z12.boolean(),
       /** Versioning scheme governing `version` / `resolvedVersion`. */
       scheme: ReleaseSchemeSchema,
       /** npm dist-tag channel for this release. */
@@ -11323,27 +11720,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: z10.string().nullable(),
+      previousVersion: z12.string().nullable(),
       /** Git tag of the previous release (typically `previousVersion` prefixed). */
-      previousTag: z10.string().nullable(),
+      previousTag: z12.string().nullable(),
       /** ISO-8601 timestamp the previous release was published. */
       previousShippedAt: Iso8601.nullable(),
       /** Tasks rolled into this release. */
-      tasks: z10.array(ReleasePlanTaskSchema),
+      tasks: z12.array(ReleasePlanTaskSchema),
       /** Bucketed changelog. */
       changelog: ReleasePlanChangelogSchema,
       /** Per-gate verification status. */
-      gates: z10.array(ReleaseGateSchema),
+      gates: z12.array(ReleaseGateSchema),
       /** Platform / publisher matrix. */
-      platformMatrix: z10.array(ReleasePlatformMatrixEntrySchema),
+      platformMatrix: z12.array(ReleasePlatformMatrixEntrySchema),
       /** Preflight summary from `cleo release plan`. */
       preflightSummary: ReleasePreflightSummarySchema,
       /** URL of the GHA workflow run (populated by `release-prepare.yml`). */
-      workflowRunUrl: z10.string().nullable(),
+      workflowRunUrl: z12.string().nullable(),
       /** URL of the bump PR (populated by `cleo release open`). */
-      prUrl: z10.string().nullable(),
+      prUrl: z12.string().nullable(),
       /** Merge commit SHA on `main` (populated by `release-publish.yml`). */
-      mergeCommitSha: z10.string().nullable(),
+      mergeCommitSha: z12.string().nullable(),
       /** Current FSM state per R-302. */
       status: ReleaseStatusSchema,
       /** Informational / forward-compat metadata. */
@@ -11399,52 +11796,52 @@ var init_session2 = __esm({
 });
 
 // packages/contracts/src/session-journal.ts
-import { z as z11 } from "zod";
+import { z as z13 } 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 = z11.object({
+    sessionJournalDoctorSummarySchema = z13.object({
       /** `true` when zero noise patterns were detected. */
-      isClean: z11.boolean(),
+      isClean: z13.boolean(),
       /** Total number of noise findings across all patterns. */
-      findingsCount: z11.number().int().nonnegative(),
+      findingsCount: z13.number().int().nonnegative(),
       /** Pattern names that were detected (empty when isClean). */
-      patterns: z11.array(z11.string()),
+      patterns: z13.array(z13.string()),
       /** Total brain entries scanned. `0` = empty or unavailable. */
-      totalScanned: z11.number().int().nonnegative()
+      totalScanned: z13.number().int().nonnegative()
     });
-    sessionJournalDebriefSummarySchema = z11.object({
+    sessionJournalDebriefSummarySchema = z13.object({
       /** First 200 characters of the session end note (if provided). */
-      noteExcerpt: z11.string().max(200).optional(),
+      noteExcerpt: z13.string().max(200).optional(),
       /** Number of tasks completed during the session. */
-      tasksCompletedCount: z11.number().int().nonnegative(),
+      tasksCompletedCount: z13.number().int().nonnegative(),
       /** Up to 5 task IDs (not titles) that were the focus of the session. */
-      tasksFocused: z11.array(z11.string()).max(5).optional()
+      tasksFocused: z13.array(z13.string()).max(5).optional()
     });
-    sessionJournalEntrySchema = z11.object({
+    sessionJournalEntrySchema = z13.object({
       // Identity
       /** Schema version for forward-compatibility. Always `'1.0'` in this release. */
-      schemaVersion: z11.literal(SESSION_JOURNAL_SCHEMA_VERSION),
+      schemaVersion: z13.literal(SESSION_JOURNAL_SCHEMA_VERSION),
       /** ISO 8601 timestamp when the entry was written. */
-      timestamp: z11.string(),
+      timestamp: z13.string(),
       /** CLEO session ID (e.g. `ses_20260424055456_ede571`). */
-      sessionId: z11.string(),
+      sessionId: z13.string(),
       /** Event type that triggered this journal entry. */
-      eventType: z11.enum(["session_start", "session_end", "observation", "decision", "error"]),
+      eventType: z13.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: z11.string().optional(),
+      agentIdentifier: z13.string().optional(),
       /** Provider adapter ID active for this session. */
-      providerId: z11.string().optional(),
+      providerId: z13.string().optional(),
       /** Session scope string (e.g. `'global'` or `'epic:T1263'`). */
-      scope: z11.string().optional(),
+      scope: z13.string().optional(),
       // Session-end fields
       /** Duration of the session in seconds (session_end only). */
-      duration: z11.number().int().nonnegative().optional(),
+      duration: z13.number().int().nonnegative().optional(),
       /** Task IDs (not titles) completed during the session. */
-      tasksCompleted: z11.array(z11.string()).optional(),
+      tasksCompleted: z13.array(z13.string()).optional(),
       // Doctor summary (T1262 absorbed)
       /** Compact result of `scanBrainNoise` run at session-end. */
       doctorSummary: sessionJournalDoctorSummarySchema.optional(),
@@ -11453,7 +11850,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: z11.string().optional()
+      prevEntryHash: z13.string().optional()
     });
   }
 });
@@ -11466,52 +11863,52 @@ var init_task = __esm({
 });
 
 // packages/contracts/src/task-evidence.ts
-import { z as z12 } from "zod";
+import { z as z14 } from "zod";
 var fileEvidenceSchema, logEvidenceSchema, screenshotEvidenceSchema, testOutputEvidenceSchema, commandOutputEvidenceSchema, taskEvidenceSchema;
 var init_task_evidence = __esm({
   "packages/contracts/src/task-evidence.ts"() {
     "use strict";
-    fileEvidenceSchema = z12.object({
-      kind: z12.literal("file"),
-      sha256: z12.string().length(64),
-      timestamp: z12.string().datetime(),
-      path: z12.string().min(1),
-      mime: z12.string().optional(),
-      description: z12.string().optional()
-    });
-    logEvidenceSchema = z12.object({
-      kind: z12.literal("log"),
-      sha256: z12.string().length(64),
-      timestamp: z12.string().datetime(),
-      source: z12.string().min(1),
-      description: z12.string().optional()
-    });
-    screenshotEvidenceSchema = z12.object({
-      kind: z12.literal("screenshot"),
-      sha256: z12.string().length(64),
-      timestamp: z12.string().datetime(),
-      mime: z12.enum(["image/png", "image/jpeg", "image/webp"]).optional(),
-      description: z12.string().optional()
-    });
-    testOutputEvidenceSchema = z12.object({
-      kind: z12.literal("test-output"),
-      sha256: z12.string().length(64),
-      timestamp: z12.string().datetime(),
-      passed: z12.number().int().nonnegative(),
-      failed: z12.number().int().nonnegative(),
-      skipped: z12.number().int().nonnegative(),
-      exitCode: z12.number().int(),
-      description: z12.string().optional()
-    });
-    commandOutputEvidenceSchema = z12.object({
-      kind: z12.literal("command-output"),
-      sha256: z12.string().length(64),
-      timestamp: z12.string().datetime(),
-      cmd: z12.string().min(1),
-      exitCode: z12.number().int(),
-      description: z12.string().optional()
-    });
-    taskEvidenceSchema = z12.discriminatedUnion("kind", [
+    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,
       logEvidenceSchema,
       screenshotEvidenceSchema,
@@ -11522,12 +11919,12 @@ var init_task_evidence = __esm({
 });
 
 // packages/contracts/src/tasks/archive.ts
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 var ArchiveReason, ARCHIVE_REASON_VALUES;
 var init_archive = __esm({
   "packages/contracts/src/tasks/archive.ts"() {
     "use strict";
-    ArchiveReason = z13.enum([
+    ArchiveReason = z15.enum([
       "verified",
       "reconciled",
       "superseded",
@@ -11540,47 +11937,47 @@ var init_archive = __esm({
 });
 
 // packages/contracts/src/tasks.ts
-import { z as z14 } from "zod";
+import { z as z16 } 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 = z14.enum(["info", "warning"]);
-    taskMutationWarningSchema = z14.object({
-      code: z14.string().min(1),
-      message: z14.string().min(1),
+    taskMutationWarningSeveritySchema = z16.enum(["info", "warning"]);
+    taskMutationWarningSchema = z16.object({
+      code: z16.string().min(1),
+      message: z16.string().min(1),
       severity: taskMutationWarningSeveritySchema.optional(),
-      taskId: z14.string().min(1).optional(),
-      field: z14.string().min(1).optional(),
-      index: z14.number().int().nonnegative().optional()
-    });
-    taskMutationDryRunSummarySchema = z14.object({
-      dryRun: z14.literal(true),
-      wouldCreate: z14.number().int().nonnegative(),
-      wouldUpdate: z14.number().int().nonnegative(),
-      wouldDelete: z14.number().int().nonnegative(),
-      wouldAffect: z14.number().int().nonnegative(),
-      validatedCount: z14.number().int().nonnegative(),
-      insertedCount: z14.literal(0),
-      updatedCount: z14.literal(0),
-      deletedCount: z14.literal(0),
-      warnings: z14.array(taskMutationWarningSchema)
-    });
-    taskMutationTaskRecordSchema = z14.object({ id: z14.string().min(1) }).passthrough();
-    taskMutationEnvelopeSchema = z14.object({
-      dryRun: z14.boolean().optional(),
-      created: z14.array(taskMutationTaskRecordSchema),
-      updated: z14.array(taskMutationTaskRecordSchema),
-      deleted: z14.array(taskMutationTaskRecordSchema),
-      affectedCount: z14.number().int().nonnegative(),
-      mutationWarnings: z14.array(taskMutationWarningSchema),
+      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),
       dryRunSummary: taskMutationDryRunSummarySchema.optional()
     });
-    completionTaskStatusSchema = z14.enum(TASK_STATUSES);
-    completionCriterionKindSchema = z14.enum(["text", "evidence_bound", "child_task"]);
-    completionCriterionStatusSchema = z14.enum(["satisfied", "unsatisfied", "waived", "replaced"]);
-    completionBlockerReasonSchema = z14.enum([
+    completionTaskStatusSchema = z16.enum(TASK_STATUSES);
+    completionCriterionKindSchema = z16.enum(["text", "evidence_bound", "child_task"]);
+    completionCriterionStatusSchema = z16.enum(["satisfied", "unsatisfied", "waived", "replaced"]);
+    completionBlockerReasonSchema = z16.enum([
       "missing_evidence_binding",
       "child_not_done",
       "child_cancelled_requires_waiver",
@@ -11588,68 +11985,68 @@ var init_tasks2 = __esm({
       "child_missing",
       "done_parent_stale"
     ]);
-    completionStaleReasonSchema = z14.enum(["done_parent_has_unsatisfied_criteria"]);
-    completionProjectionRepairErrorCodeSchema = z14.enum([
+    completionStaleReasonSchema = z16.enum(["done_parent_has_unsatisfied_criteria"]);
+    completionProjectionRepairErrorCodeSchema = z16.enum([
       "projection_not_stale",
       "criteria_missing",
       "binding_target_missing",
       "repair_conflict"
     ]);
-    completionCriterionWaiverSchema = z14.object({
-      criterionAcId: z14.string().min(1),
-      childTaskId: z14.string().min(1),
-      reason: z14.string().min(1),
-      actor: z14.string().min(1),
-      waivedAt: z14.string().min(1)
-    });
-    completionCriterionReplacementSchema = z14.object({
-      criterionAcId: z14.string().min(1),
-      originalChildTaskId: z14.string().min(1),
-      replacementChildTaskId: z14.string().min(1),
-      reason: z14.string().min(1),
-      actor: z14.string().min(1),
-      replacedAt: z14.string().min(1)
-    });
-    completionCriterionEvaluationSchema = z14.object({
-      acId: z14.string().min(1),
-      alias: z14.string().min(1),
-      text: z14.string(),
+    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(),
       kind: completionCriterionKindSchema,
       status: completionCriterionStatusSchema,
       reason: completionBlockerReasonSchema.optional(),
-      targetTaskId: z14.string().min(1).optional(),
+      targetTaskId: z16.string().min(1).optional(),
       targetTaskStatus: completionTaskStatusSchema.optional(),
       waiver: completionCriterionWaiverSchema.optional(),
       replacement: completionCriterionReplacementSchema.optional(),
       replacementTaskStatus: completionTaskStatusSchema.optional(),
-      evidenceBindings: z14.number().int().nonnegative()
+      evidenceBindings: z16.number().int().nonnegative()
     });
     unsatisfiedCompletionCriterionSchema = completionCriterionEvaluationSchema.extend({
-      status: z14.literal("unsatisfied"),
+      status: z16.literal("unsatisfied"),
       reason: completionBlockerReasonSchema
     });
-    completionTotalsSchema = z14.object({
-      criteria: z14.number().int().nonnegative(),
-      satisfied: z14.number().int().nonnegative(),
-      unsatisfied: z14.number().int().nonnegative(),
-      waived: z14.number().int().nonnegative(),
-      replaced: z14.number().int().nonnegative()
-    });
-    completionContextPackSchema = z14.object({
-      taskId: z14.string().min(1),
-      generatedAt: z14.string().min(1),
-      source: z14.literal("audit_log"),
-      window: z14.object({
-        limit: z14.number().int().positive(),
-        since: z14.string().min(1).optional(),
-        relationDepth: z14.number().int().nonnegative(),
-        relatedTaskIds: z14.array(z14.string().min(1))
+    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))
       }),
-      events: z14.array(
-        z14.object({
-          id: z14.string().min(1),
-          timestamp: z14.string().min(1),
-          action: z14.enum([
+      events: z16.array(
+        z16.object({
+          id: z16.string().min(1),
+          timestamp: z16.string().min(1),
+          action: z16.enum([
             "task_completed",
             "task_reopened",
             "task_cancelled",
@@ -11657,77 +12054,77 @@ var init_tasks2 = __esm({
             "task_reparented",
             "ac_projection_rebuilt"
           ]),
-          taskId: z14.string().min(1),
-          relation: z14.enum(["self", "parent", "child", "sibling", "related"]),
-          actor: z14.string().min(1),
-          details: z14.record(z14.string(), z14.unknown()).optional(),
-          before: z14.record(z14.string(), z14.unknown()).optional(),
-          after: z14.record(z14.string(), z14.unknown()).optional()
+          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()
         })
       ),
-      summary: z14.object({
-        totalEvents: z14.number().int().nonnegative(),
-        byAction: z14.record(z14.string(), z14.number().int().nonnegative()),
-        byRelation: z14.record(z14.string(), z14.number().int().nonnegative()),
-        latestEventAt: z14.string().nullable()
+      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()
       })
     });
-    completionEvaluationSchema = z14.object({
-      taskId: z14.string().min(1),
+    completionEvaluationSchema = z16.object({
+      taskId: z16.string().min(1),
       taskStatus: completionTaskStatusSchema,
-      ready: z14.boolean(),
-      stale: z14.boolean(),
-      staleReasons: z14.array(completionStaleReasonSchema),
+      ready: z16.boolean(),
+      stale: z16.boolean(),
+      staleReasons: z16.array(completionStaleReasonSchema),
       contextPack: completionContextPackSchema.optional(),
-      satisfied: z14.array(completionCriterionEvaluationSchema),
-      unsatisfied: z14.array(unsatisfiedCompletionCriterionSchema),
-      waived: z14.array(completionCriterionEvaluationSchema),
-      replaced: z14.array(completionCriterionEvaluationSchema),
+      satisfied: z16.array(completionCriterionEvaluationSchema),
+      unsatisfied: z16.array(unsatisfiedCompletionCriterionSchema),
+      waived: z16.array(completionCriterionEvaluationSchema),
+      replaced: z16.array(completionCriterionEvaluationSchema),
       totals: completionTotalsSchema
     });
-    completionExplanationSchema = z14.object({
-      taskId: z14.string().min(1),
-      ready: z14.boolean(),
-      stale: z14.boolean(),
-      summary: z14.string(),
+    completionExplanationSchema = z16.object({
+      taskId: z16.string().min(1),
+      ready: z16.boolean(),
+      stale: z16.boolean(),
+      summary: z16.string(),
       contextPack: completionContextPackSchema.optional(),
-      blockers: z14.array(completionCriterionEvaluationSchema)
+      blockers: z16.array(completionCriterionEvaluationSchema)
     });
-    completionListParamsSchema = z14.object({
-      taskId: z14.string().min(1),
+    completionListParamsSchema = z16.object({
+      taskId: z16.string().min(1),
       status: completionCriterionStatusSchema.optional(),
       kind: completionCriterionKindSchema.optional()
     });
-    completionListResultSchema = z14.object({
-      taskId: z14.string().min(1),
-      criteria: z14.array(completionCriterionEvaluationSchema),
+    completionListResultSchema = z16.object({
+      taskId: z16.string().min(1),
+      criteria: z16.array(completionCriterionEvaluationSchema),
       totals: completionTotalsSchema
     });
-    completionEvaluateParamsSchema = z14.object({
-      taskId: z14.string().min(1),
-      includeContext: z14.boolean().optional(),
-      limit: z14.number().int().positive().optional(),
-      since: z14.string().min(1).optional(),
-      relationDepth: z14.number().int().nonnegative().optional()
+    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()
     });
-    completionProjectionRepairErrorSchema = z14.object({
+    completionProjectionRepairErrorSchema = z16.object({
       code: completionProjectionRepairErrorCodeSchema,
-      message: z14.string().min(1),
-      taskId: z14.string().min(1),
-      acId: z14.string().min(1).optional(),
-      evidenceAtomId: z14.string().min(1).optional()
+      message: z16.string().min(1),
+      taskId: z16.string().min(1),
+      acId: z16.string().min(1).optional(),
+      evidenceAtomId: z16.string().min(1).optional()
     });
-    completionProjectionRepairParamsSchema = z14.object({
-      taskId: z14.string().min(1),
-      dryRun: z14.boolean().optional()
+    completionProjectionRepairParamsSchema = z16.object({
+      taskId: z16.string().min(1),
+      dryRun: z16.boolean().optional()
     });
-    completionProjectionRepairResultSchema = z14.object({
-      taskId: z14.string().min(1),
-      repaired: z14.boolean(),
-      dryRun: z14.boolean(),
-      staleBefore: z14.boolean(),
-      staleAfter: z14.boolean(),
-      errors: z14.array(completionProjectionRepairErrorSchema)
+    completionProjectionRepairResultSchema = z16.object({
+      taskId: z16.string().min(1),
+      repaired: z16.boolean(),
+      dryRun: z16.boolean(),
+      staleBefore: z16.boolean(),
+      staleAfter: z16.boolean(),
+      errors: z16.array(completionProjectionRepairErrorSchema)
     });
   }
 });
@@ -12238,7 +12635,7 @@ var init_taxonomy = __esm({
 });
 
 // packages/contracts/src/templates/manifest.ts
-import { z as z15 } from "zod";
+import { z as z17 } from "zod";
 var TEMPLATE_KINDS, TEMPLATE_SUBSTITUTIONS, TEMPLATE_UPDATE_STRATEGIES, PLACEHOLDER_SOURCES, PlaceholderSpecSchema, TemplateManifestEntrySchema;
 var init_manifest2 = __esm({
   "packages/contracts/src/templates/manifest.ts"() {
@@ -12259,85 +12656,85 @@ var init_manifest2 = __esm({
       "tool-resolver",
       "literal"
     ];
-    PlaceholderSpecSchema = z15.object({
+    PlaceholderSpecSchema = z17.object({
       /**
        * Placeholder identifier as it appears in the template body
        * (e.g. `NODE_VERSION` matches `{{NODE_VERSION}}`).
        */
-      name: z15.string().min(1, "placeholder name must be non-empty"),
+      name: z17.string().min(1, "placeholder name must be non-empty"),
       /** Resolver source the installer consults for this placeholder. */
-      source: z15.enum(PLACEHOLDER_SOURCES),
+      source: z17.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: z15.string().min(1, "placeholder sourcePath must be non-empty"),
+      sourcePath: z17.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: z15.union([z15.string(), z15.number(), z15.boolean(), z15.null()]).optional()
+      defaultValue: z17.union([z17.string(), z17.number(), z17.boolean(), z17.null()]).optional()
     });
-    TemplateManifestEntrySchema = z15.object({
+    TemplateManifestEntrySchema = z17.object({
       /** Stable identifier for this template entry. */
-      id: z15.string().min(1, "id must be non-empty"),
+      id: z17.string().min(1, "id must be non-empty"),
       /** Category of file this template represents. */
-      kind: z15.enum(TEMPLATE_KINDS),
+      kind: z17.enum(TEMPLATE_KINDS),
       /** Repo-relative path of the template source file. */
-      sourcePath: z15.string().min(1, "sourcePath must be non-empty"),
+      sourcePath: z17.string().min(1, "sourcePath must be non-empty"),
       /** Project-relative path where the rendered template installs. */
-      installPath: z15.string().min(1, "installPath must be non-empty"),
+      installPath: z17.string().min(1, "installPath must be non-empty"),
       /** Substitution strategy the installer applies to `sourcePath`. */
-      substitution: z15.enum(TEMPLATE_SUBSTITUTIONS),
+      substitution: z17.enum(TEMPLATE_SUBSTITUTIONS),
       /** Declared placeholders this template requires. May be empty. */
-      placeholders: z15.array(PlaceholderSpecSchema),
+      placeholders: z17.array(PlaceholderSpecSchema),
       /** Reconciliation policy on upgrade. */
-      updateStrategy: z15.enum(TEMPLATE_UPDATE_STRATEGIES)
+      updateStrategy: z17.enum(TEMPLATE_UPDATE_STRATEGIES)
     });
   }
 });
 
 // packages/contracts/src/validator/index.ts
-import { z as z16 } from "zod";
+import { z as z18 } 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 = z16.object({
-      acId: z16.string().min(1, "acId must be non-empty"),
-      status: z16.enum(["pass", "fail", "inconclusive"]),
-      reasoning: z16.string().min(1, "reasoning must be non-empty"),
-      evidenceRefs: z16.array(z16.string()).optional(),
-      checkedAt: z16.string().min(1, "checkedAt must be a non-empty ISO-8601 string")
-    });
-    validatorAttestationSchema = z16.object({
-      verdict: z16.literal("attest"),
-      taskId: z16.string().min(1),
-      validatorId: z16.string().regex(VALIDATOR_ID_REGEX, "validatorId must match the pattern validator-<discriminator>"),
-      findings: z16.array(validatorFindingSchema).min(1, "attestation must contain at least one finding").refine(
+    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(
         (findings) => findings.every((f) => f.status === "pass"),
         'attestation requires every finding to have status="pass"'
       ),
-      summary: z16.string().optional(),
-      attestedAt: z16.string().min(1),
-      schemaVersion: z16.literal("1")
-    });
-    validatorRejectionSchema = z16.object({
-      verdict: z16.literal("reject"),
-      taskId: z16.string().min(1),
-      validatorId: z16.string().regex(VALIDATOR_ID_REGEX, "validatorId must match the pattern validator-<discriminator>"),
-      findings: z16.array(validatorFindingSchema).min(1, "rejection must contain at least one finding").refine(
+      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(
         (findings) => findings.some((f) => f.status !== "pass"),
         'rejection requires at least one finding with status "fail" or "inconclusive"'
       ),
-      summary: z16.string().min(1, "rejection summary must be non-empty"),
-      remediationHints: z16.array(z16.string()).optional(),
-      rejectedAt: z16.string().min(1),
-      schemaVersion: z16.literal("1")
+      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")
     });
-    validatorVerdictSchema = z16.discriminatedUnion("verdict", [
+    validatorVerdictSchema = z18.discriminatedUnion("verdict", [
       validatorAttestationSchema,
       validatorRejectionSchema
     ]);
@@ -12355,6 +12752,8 @@ var init_src = __esm({
     init_cli_category();
     init_manifest();
     init_credentials();
+    init_daemon();
+    init_daemon_ipc();
     init_db_inventory2();
     init_identity();
     init_operations_registry();
@@ -12367,11 +12766,13 @@ var init_src = __esm({
     init_evidence_record_schema();
     init_exit_codes();
     init_facade();
+    init_goal();
     init_graph();
     init_invariants();
     init_lafs();
     init_plugin_llm();
     init_observe();
+    init_mvi();
     init_operation_envelope_validation();
     init_docs();
     init_operations();
@@ -12385,6 +12786,7 @@ var init_src = __esm({
     init_session2();
     init_session_journal();
     init_status_registry();
+    init_supervisor_ipc();
     init_task();
     init_task_evidence();
     init_archive();
@@ -26412,7 +26814,7 @@ function resolveRef(ref, ctx) {
 function convertBaseSchema(schema, ctx) {
   if (schema.not !== void 0) {
     if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) {
-      return z17.never();
+      return z19.never();
     }
     throw new Error("not is not supported in Zod (except { not: {} } for never)");
   }
@@ -26434,7 +26836,7 @@ function convertBaseSchema(schema, ctx) {
       return ctx.refs.get(refPath);
     }
     if (ctx.processing.has(refPath)) {
-      return z17.lazy(() => {
+      return z19.lazy(() => {
         if (!ctx.refs.has(refPath)) {
           throw new Error(`Circular reference not resolved: ${refPath}`);
         }
@@ -26451,25 +26853,25 @@ function convertBaseSchema(schema, ctx) {
   if (schema.enum !== void 0) {
     const enumValues = schema.enum;
     if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
-      return z17.null();
+      return z19.null();
     }
     if (enumValues.length === 0) {
-      return z17.never();
+      return z19.never();
     }
     if (enumValues.length === 1) {
-      return z17.literal(enumValues[0]);
+      return z19.literal(enumValues[0]);
     }
     if (enumValues.every((v) => typeof v === "string")) {
-      return z17.enum(enumValues);
+      return z19.enum(enumValues);
     }
-    const literalSchemas = enumValues.map((v) => z17.literal(v));
+    const literalSchemas = enumValues.map((v) => z19.literal(v));
     if (literalSchemas.length < 2) {
       return literalSchemas[0];
     }
-    return z17.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
+    return z19.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
   }
   if (schema.const !== void 0) {
-    return z17.literal(schema.const);
+    return z19.literal(schema.const);
   }
   const type = schema.type;
   if (Array.isArray(type)) {
@@ -26478,68 +26880,68 @@ function convertBaseSchema(schema, ctx) {
       return convertBaseSchema(typeSchema, ctx);
     });
     if (typeSchemas.length === 0) {
-      return z17.never();
+      return z19.never();
     }
     if (typeSchemas.length === 1) {
       return typeSchemas[0];
     }
-    return z17.union(typeSchemas);
+    return z19.union(typeSchemas);
   }
   if (!type) {
-    return z17.any();
+    return z19.any();
   }
   let zodSchema2;
   switch (type) {
     case "string": {
-      let stringSchema = z17.string();
+      let stringSchema = z19.string();
       if (schema.format) {
         const format = schema.format;
         if (format === "email") {
-          stringSchema = stringSchema.check(z17.email());
+          stringSchema = stringSchema.check(z19.email());
         } else if (format === "uri" || format === "uri-reference") {
-          stringSchema = stringSchema.check(z17.url());
+          stringSchema = stringSchema.check(z19.url());
         } else if (format === "uuid" || format === "guid") {
-          stringSchema = stringSchema.check(z17.uuid());
+          stringSchema = stringSchema.check(z19.uuid());
         } else if (format === "date-time") {
-          stringSchema = stringSchema.check(z17.iso.datetime());
+          stringSchema = stringSchema.check(z19.iso.datetime());
         } else if (format === "date") {
-          stringSchema = stringSchema.check(z17.iso.date());
+          stringSchema = stringSchema.check(z19.iso.date());
         } else if (format === "time") {
-          stringSchema = stringSchema.check(z17.iso.time());
+          stringSchema = stringSchema.check(z19.iso.time());
         } else if (format === "duration") {
-          stringSchema = stringSchema.check(z17.iso.duration());
+          stringSchema = stringSchema.check(z19.iso.duration());
         } else if (format === "ipv4") {
-          stringSchema = stringSchema.check(z17.ipv4());
+          stringSchema = stringSchema.check(z19.ipv4());
         } else if (format === "ipv6") {
-          stringSchema = stringSchema.check(z17.ipv6());
+          stringSchema = stringSchema.check(z19.ipv6());
         } else if (format === "mac") {
-          stringSchema = stringSchema.check(z17.mac());
+          stringSchema = stringSchema.check(z19.mac());
         } else if (format === "cidr") {
-          stringSchema = stringSchema.check(z17.cidrv4());
+          stringSchema = stringSchema.check(z19.cidrv4());
         } else if (format === "cidr-v6") {
-          stringSchema = stringSchema.check(z17.cidrv6());
+          stringSchema = stringSchema.check(z19.cidrv6());
         } else if (format === "base64") {
-          stringSchema = stringSchema.check(z17.base64());
+          stringSchema = stringSchema.check(z19.base64());
         } else if (format === "base64url") {
-          stringSchema = stringSchema.check(z17.base64url());
+          stringSchema = stringSchema.check(z19.base64url());
         } else if (format === "e164") {
-          stringSchema = stringSchema.check(z17.e164());
+          stringSchema = stringSchema.check(z19.e164());
         } else if (format === "jwt") {
-          stringSchema = stringSchema.check(z17.jwt());
+          stringSchema = stringSchema.check(z19.jwt());
         } else if (format === "emoji") {
-          stringSchema = stringSchema.check(z17.emoji());
+          stringSchema = stringSchema.check(z19.emoji());
         } else if (format === "nanoid") {
-          stringSchema = stringSchema.check(z17.nanoid());
+          stringSchema = stringSchema.check(z19.nanoid());
         } else if (format === "cuid") {
-          stringSchema = stringSchema.check(z17.cuid());
+          stringSchema = stringSchema.check(z19.cuid());
         } else if (format === "cuid2") {
-          stringSchema = stringSchema.check(z17.cuid2());
+          stringSchema = stringSchema.check(z19.cuid2());
         } else if (format === "ulid") {
-          stringSchema = stringSchema.check(z17.ulid());
+          stringSchema = stringSchema.check(z19.ulid());
         } else if (format === "xid") {
-          stringSchema = stringSchema.check(z17.xid());
+          stringSchema = stringSchema.check(z19.xid());
         } else if (format === "ksuid") {
-          stringSchema = stringSchema.check(z17.ksuid());
+          stringSchema = stringSchema.check(z19.ksuid());
         }
       }
       if (typeof schema.minLength === "number") {
@@ -26556,7 +26958,7 @@ function convertBaseSchema(schema, ctx) {
     }
     case "number":
     case "integer": {
-      let numberSchema = type === "integer" ? z17.number().int() : z17.number();
+      let numberSchema = type === "integer" ? z19.number().int() : z19.number();
       if (typeof schema.minimum === "number") {
         numberSchema = numberSchema.min(schema.minimum);
       }
@@ -26580,11 +26982,11 @@ function convertBaseSchema(schema, ctx) {
       break;
     }
     case "boolean": {
-      zodSchema2 = z17.boolean();
+      zodSchema2 = z19.boolean();
       break;
     }
     case "null": {
-      zodSchema2 = z17.null();
+      zodSchema2 = z19.null();
       break;
     }
     case "object": {
@@ -26597,14 +26999,14 @@ function convertBaseSchema(schema, ctx) {
       }
       if (schema.propertyNames) {
         const keySchema = convertSchema(schema.propertyNames, ctx);
-        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z17.any();
+        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z19.any();
         if (Object.keys(shape).length === 0) {
-          zodSchema2 = z17.record(keySchema, valueSchema);
+          zodSchema2 = z19.record(keySchema, valueSchema);
           break;
         }
-        const objectSchema2 = z17.object(shape).passthrough();
-        const recordSchema = z17.looseRecord(keySchema, valueSchema);
-        zodSchema2 = z17.intersection(objectSchema2, recordSchema);
+        const objectSchema2 = z19.object(shape).passthrough();
+        const recordSchema = z19.looseRecord(keySchema, valueSchema);
+        zodSchema2 = z19.intersection(objectSchema2, recordSchema);
         break;
       }
       if (schema.patternProperties) {
@@ -26613,28 +27015,28 @@ function convertBaseSchema(schema, ctx) {
         const looseRecords = [];
         for (const pattern of patternKeys) {
           const patternValue = convertSchema(patternProps[pattern], ctx);
-          const keySchema = z17.string().regex(new RegExp(pattern));
-          looseRecords.push(z17.looseRecord(keySchema, patternValue));
+          const keySchema = z19.string().regex(new RegExp(pattern));
+          looseRecords.push(z19.looseRecord(keySchema, patternValue));
         }
         const schemasToIntersect = [];
         if (Object.keys(shape).length > 0) {
-          schemasToIntersect.push(z17.object(shape).passthrough());
+          schemasToIntersect.push(z19.object(shape).passthrough());
         }
         schemasToIntersect.push(...looseRecords);
         if (schemasToIntersect.length === 0) {
-          zodSchema2 = z17.object({}).passthrough();
+          zodSchema2 = z19.object({}).passthrough();
         } else if (schemasToIntersect.length === 1) {
           zodSchema2 = schemasToIntersect[0];
         } else {
-          let result = z17.intersection(schemasToIntersect[0], schemasToIntersect[1]);
+          let result = z19.intersection(schemasToIntersect[0], schemasToIntersect[1]);
           for (let i = 2; i < schemasToIntersect.length; i++) {
-            result = z17.intersection(result, schemasToIntersect[i]);
+            result = z19.intersection(result, schemasToIntersect[i]);
           }
           zodSchema2 = result;
         }
         break;
       }
-      const objectSchema = z17.object(shape);
+      const objectSchema = z19.object(shape);
       if (schema.additionalProperties === false) {
         zodSchema2 = objectSchema.strict();
       } else if (typeof schema.additionalProperties === "object") {
@@ -26651,33 +27053,33 @@ function convertBaseSchema(schema, ctx) {
         const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
         const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : void 0;
         if (rest) {
-          zodSchema2 = z17.tuple(tupleItems).rest(rest);
+          zodSchema2 = z19.tuple(tupleItems).rest(rest);
         } else {
-          zodSchema2 = z17.tuple(tupleItems);
+          zodSchema2 = z19.tuple(tupleItems);
         }
         if (typeof schema.minItems === "number") {
-          zodSchema2 = zodSchema2.check(z17.minLength(schema.minItems));
+          zodSchema2 = zodSchema2.check(z19.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema2 = zodSchema2.check(z17.maxLength(schema.maxItems));
+          zodSchema2 = zodSchema2.check(z19.maxLength(schema.maxItems));
         }
       } else if (Array.isArray(items)) {
         const tupleItems = items.map((item) => convertSchema(item, ctx));
         const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx) : void 0;
         if (rest) {
-          zodSchema2 = z17.tuple(tupleItems).rest(rest);
+          zodSchema2 = z19.tuple(tupleItems).rest(rest);
         } else {
-          zodSchema2 = z17.tuple(tupleItems);
+          zodSchema2 = z19.tuple(tupleItems);
         }
         if (typeof schema.minItems === "number") {
-          zodSchema2 = zodSchema2.check(z17.minLength(schema.minItems));
+          zodSchema2 = zodSchema2.check(z19.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema2 = zodSchema2.check(z17.maxLength(schema.maxItems));
+          zodSchema2 = zodSchema2.check(z19.maxLength(schema.maxItems));
         }
       } else if (items !== void 0) {
         const element = convertSchema(items, ctx);
-        let arraySchema = z17.array(element);
+        let arraySchema = z19.array(element);
         if (typeof schema.minItems === "number") {
           arraySchema = arraySchema.min(schema.minItems);
         }
@@ -26686,7 +27088,7 @@ function convertBaseSchema(schema, ctx) {
         }
         zodSchema2 = arraySchema;
       } else {
-        zodSchema2 = z17.array(z17.any());
+        zodSchema2 = z19.array(z19.any());
       }
       break;
     }
@@ -26703,37 +27105,37 @@ function convertBaseSchema(schema, ctx) {
 }
 function convertSchema(schema, ctx) {
   if (typeof schema === "boolean") {
-    return schema ? z17.any() : z17.never();
+    return schema ? z19.any() : z19.never();
   }
   let baseSchema = convertBaseSchema(schema, ctx);
   const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
   if (schema.anyOf && Array.isArray(schema.anyOf)) {
     const options = schema.anyOf.map((s) => convertSchema(s, ctx));
-    const anyOfUnion = z17.union(options);
-    baseSchema = hasExplicitType ? z17.intersection(baseSchema, anyOfUnion) : anyOfUnion;
+    const anyOfUnion = z19.union(options);
+    baseSchema = hasExplicitType ? z19.intersection(baseSchema, anyOfUnion) : anyOfUnion;
   }
   if (schema.oneOf && Array.isArray(schema.oneOf)) {
     const options = schema.oneOf.map((s) => convertSchema(s, ctx));
-    const oneOfUnion = z17.xor(options);
-    baseSchema = hasExplicitType ? z17.intersection(baseSchema, oneOfUnion) : oneOfUnion;
+    const oneOfUnion = z19.xor(options);
+    baseSchema = hasExplicitType ? z19.intersection(baseSchema, oneOfUnion) : oneOfUnion;
   }
   if (schema.allOf && Array.isArray(schema.allOf)) {
     if (schema.allOf.length === 0) {
-      baseSchema = hasExplicitType ? baseSchema : z17.any();
+      baseSchema = hasExplicitType ? baseSchema : z19.any();
     } else {
       let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
       const startIdx = hasExplicitType ? 0 : 1;
       for (let i = startIdx; i < schema.allOf.length; i++) {
-        result = z17.intersection(result, convertSchema(schema.allOf[i], ctx));
+        result = z19.intersection(result, convertSchema(schema.allOf[i], ctx));
       }
       baseSchema = result;
     }
   }
   if (schema.nullable === true && ctx.version === "openapi-3.0") {
-    baseSchema = z17.nullable(baseSchema);
+    baseSchema = z19.nullable(baseSchema);
   }
   if (schema.readOnly === true) {
-    baseSchema = z17.readonly(baseSchema);
+    baseSchema = z19.readonly(baseSchema);
   }
   const extraMeta = {};
   const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
@@ -26760,7 +27162,7 @@ function convertSchema(schema, ctx) {
 }
 function fromJSONSchema(schema, params) {
   if (typeof schema === "boolean") {
-    return schema ? z17.any() : z17.never();
+    return schema ? z19.any() : z19.never();
   }
   const version2 = detectVersion(schema, params?.defaultTarget);
   const defs = schema.$defs || schema.definitions || {};
@@ -26774,14 +27176,14 @@ function fromJSONSchema(schema, params) {
   };
   return convertSchema(schema, ctx);
 }
-var z17, RECOGNIZED_KEYS;
+var z19, RECOGNIZED_KEYS;
 var init_from_json_schema = __esm({
   "node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/from-json-schema.js"() {
     init_registries();
     init_checks2();
     init_iso();
     init_schemas2();
-    z17 = {
+    z19 = {
       ...schemas_exports2,
       ...checks_exports2,
       iso: iso_exports