zelari-code 2.5.0 → 2.6.0

package/dist/cli/main.bundled.js

@@ -3288,10 +3288,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path64) {
-  if (!path64)
+function getElementAtPath(obj, path65) {
+  if (!path65)
     return obj;
-  return path64.reduce((acc, key) => acc?.[key], obj);
+  return path65.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -3619,11 +3619,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path64, issues) {
+function prefixIssues(path65, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path64);
+    iss.path.unshift(path65);
     return iss;
   });
 }
@@ -3841,16 +3841,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path64 = []) => {
+  const processError = (error52, path65 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path64, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path65, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path64, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path65, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path64, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path65, ...issue2.path]);
       } else {
-        const fullpath = [...path64, ...issue2.path];
+        const fullpath = [...path65, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -3877,17 +3877,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path64 = []) => {
+  const processError = (error52, path65 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path64, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path65, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path64, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path65, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path64, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path65, ...issue2.path]);
       } else {
-        const fullpath = [...path64, ...issue2.path];
+        const fullpath = [...path65, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -3919,8 +3919,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path64 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path64) {
+  const path65 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path65) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -17423,13 +17423,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path64 = ref.slice(1).split("/").filter(Boolean);
-  if (path64.length === 0) {
+  const path65 = ref.slice(1).split("/").filter(Boolean);
+  if (path65.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path64[0] === defsKey) {
-    const key = path64[1];
+  if (path65[0] === defsKey) {
+    const key = path65[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -19765,11 +19765,11 @@ var init_tools = __esm({
           if (!ctx.addDocument)
             return "Knowledge vault tool not available.";
           const title = args["title"] || "New Document";
-          const path64 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
+          const path65 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
           const content = args["content"] || "";
           const tags = args["tags"] || [];
           ctx.addDocument({
-            path: path64,
+            path: path65,
             title,
             content,
             format: "markdown",
@@ -19778,7 +19778,7 @@ var init_tools = __esm({
             workspaceId: ctx.workspaceId
           });
           ctx.addActivity("vault", "created document", title);
-          return `Document "${title}" created at "${path64}".`;
+          return `Document "${title}" created at "${path65}".`;
         }
       }
     ];
@@ -22177,6 +22177,19 @@ var init_AgentHarness = __esm({
        * via Promise.all (chunked by ZELARI_MAX_PARALLEL_TOOLS, default 6); write/
        * execute tools run one-at-a-time in order.
        */
+      /**
+       * v2.6 Phase 3 resource seam: consult the host-owned pre-dispatch gate.
+       * Degrade-and-stop — a throwing gate NEVER blocks a tool call.
+       */
+      checkToolCallGate(toolName, args) {
+        if (!this.config.toolCallGate)
+          return { allowed: true };
+        try {
+          return this.config.toolCallGate(toolName, args) ?? { allowed: true };
+        } catch {
+          return { allowed: true };
+        }
+      }
       async executePendingTools(pending, maxToolCalls) {
         const out = new Array(pending.length);
         const maxParallel = Math.max(1, Number.parseInt(process.env.ZELARI_MAX_PARALLEL_TOOLS ?? "6", 10) || 6);
@@ -22189,6 +22202,14 @@ var init_AgentHarness = __esm({
               durationMs: 0
             };
           }
+          const gate = this.checkToolCallGate(p3.toolName, p3.args);
+          if (!gate.allowed) {
+            return {
+              content: `[resource-gate] ${gate.reason ?? "denied by resource policy"} Prioritize verification/repair actions (test, typecheck, build, read failures) or finalize honestly.`,
+              isError: true,
+              durationMs: 0
+            };
+          }
           const callKey = hashToolCall(p3.toolName, p3.args);
           const nextCount = (this.toolCallCounts.get(callKey) ?? 0) + 1;
           this.toolCallCounts.set(callKey, nextCount);
@@ -22708,6 +22729,21 @@ ${cached2}`
                   });
                   this.emit(startEv);
                   yield startEv;
+                  const gate = this.checkToolCallGate(tt.name, tt.args);
+                  if (!gate.allowed) {
+                    const denied = `[resource-gate] ${gate.reason ?? "denied by resource policy"} Prioritize verification/repair actions (test, typecheck, build, read failures) or finalize honestly.`;
+                    const denyEv = createBrainEvent("tool_execution_end", this.sessionId, {
+                      toolCallId,
+                      result: denied,
+                      isError: true,
+                      durationMs: 0
+                    });
+                    this.emit(denyEv);
+                    yield denyEv;
+                    turnToolResults.push({ toolCallId, content: denied });
+                    executedAny = true;
+                    continue;
+                  }
                   let resultStr = "";
                   let isError = false;
                   const startMs = Date.now();
@@ -24238,11 +24274,11 @@ var init_synthesisAudit = __esm({
 import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
 import { join as join2 } from "node:path";
 function loadNfrSpec(zelariRoot) {
-  const path64 = join2(zelariRoot, "nfr-spec.json");
-  if (!existsSync7(path64))
+  const path65 = join2(zelariRoot, "nfr-spec.json");
+  if (!existsSync7(path65))
     return null;
   try {
-    const raw = JSON.parse(readFileSync7(path64, "utf8"));
+    const raw = JSON.parse(readFileSync7(path65, "utf8"));
     if (raw.version !== 1 || !Array.isArray(raw.targets))
       return null;
     return raw;
@@ -26548,9 +26584,9 @@ var init_types4 = __esm({
 import { readFileSync as readFileSync12 } from "node:fs";
 import { join as join8 } from "node:path";
 function readLessonsDeduped(zelariRoot) {
-  const path64 = join8(zelariRoot, LESSONS_FILE);
+  const path65 = join8(zelariRoot, LESSONS_FILE);
   try {
-    const raw = readFileSync12(path64, "utf8");
+    const raw = readFileSync12(path65, "utf8");
     const byId = /* @__PURE__ */ new Map();
     for (const line of raw.split(/\r?\n/)) {
       if (!line.trim())
@@ -26651,8 +26687,8 @@ function keywordsFrom(check2, signature) {
   return [.../* @__PURE__ */ new Set([...fromId, ...words])].slice(0, 12);
 }
 function writeLesson(zelariRoot, lesson) {
-  const path64 = join9(zelariRoot, LESSONS_FILE);
-  appendFileSync(path64, `${JSON.stringify(lesson)}
+  const path65 = join9(zelariRoot, LESSONS_FILE);
+  appendFileSync(path65, `${JSON.stringify(lesson)}
 `, "utf8");
 }
 function findSimilar(lessons, signature) {
@@ -27266,9 +27302,9 @@ function findCycle(nodes) {
     if (color.get(start) !== WHITE)
       continue;
     const stack = [[start, 0]];
-    const path64 = [];
+    const path65 = [];
     color.set(start, GRAY);
-    path64.push(start);
+    path65.push(start);
     while (stack.length > 0) {
       const top = stack[stack.length - 1];
       const [id, idx] = top;
@@ -27281,17 +27317,17 @@ function findCycle(nodes) {
           continue;
         const c = color.get(dep);
         if (c === GRAY) {
-          const at = path64.indexOf(dep);
-          return [...path64.slice(at), dep];
+          const at = path65.indexOf(dep);
+          return [...path65.slice(at), dep];
         }
         if (c === WHITE) {
           color.set(dep, GRAY);
-          path64.push(dep);
+          path65.push(dep);
           stack.push([dep, 0]);
         }
       } else {
         color.set(id, BLACK);
-        path64.pop();
+        path65.pop();
         stack.pop();
       }
     }
@@ -28211,8 +28247,8 @@ var init_runner = __esm({
           failed: [...this.tentaclesById.values()].filter((r) => r.status === "error"),
           pending: []
         };
-        const path64 = await this.host.saveSnapshot(snapshot, ".zelari/kraken/snapshots");
-        this.host.log(`checkpoint: ${label ?? "auto"} \u2192 ${path64}`);
+        const path65 = await this.host.saveSnapshot(snapshot, ".zelari/kraken/snapshots");
+        this.host.log(`checkpoint: ${label ?? "auto"} \u2192 ${path65}`);
         return snapshot;
       }
       callLog(msg, data) {
@@ -28300,6 +28336,10 @@ var init_types8 = __esm({
       "session.resumed",
       "session.ended",
       "session.forked",
+      // 2.6 Track A (harness manifest): canonical harness fingerprint recorded
+      // once at session start / manifest change. State-only (never model-surface):
+      // data = {manifest, manifestHash}. Schema review per ADR-0021.
+      "session.harness_manifest",
       "user.message",
       "assistant.message",
       "tool.call",
@@ -28310,6 +28350,11 @@ var init_types8 = __esm({
       "session.compacted",
       "task.created",
       "task.updated",
+      // 2.6 Track A (doc §14): first-class task contract. Append-only,
+      // monotone versioning (task.contract_updated supersedes, never rewrites).
+      // State-only: compaction projects it into CompactionStateSnapshot.
+      "task.contract",
+      "task.contract_updated",
       "kraken.task",
       "council.member",
       "mission.phase",
@@ -28322,6 +28367,12 @@ var init_types8 = __esm({
       // the session-log anchor EvidenceRef.seq points at (command output, fs
       // observation, digest). Not model-surface. Schema review per ADR-0021.
       "verification.evidence",
+      // 2.6 Track B (resource-aware execution, doc §9-§12): host-owned resource
+      // state. `resource.snapshot` is model-surface with LATEST-ONLY projection
+      // (doc §10.2 — see modelSurface.ts); limit/reserve events are state-only.
+      "resource.snapshot",
+      "resource.limit_reached",
+      "resource.reserve_entered",
       "note"
     ];
     SessionEventEnvelopeSchema = external_exports.object({
@@ -28479,9 +28530,13 @@ function buildCompactionStateSnapshot(events, toSeq) {
     ...typeof lastMissionAdvice?.data.recommendation === "string" ? { recommendation: lastMissionAdvice.data.recommendation } : {},
     ...stringsOf(lastMissionAdvice?.data.blockers).length > 0 ? { blockers: stringsOf(lastMissionAdvice?.data.blockers) } : {}
   } : void 0;
+  const latestContractEvent = [...scoped].reverse().find((event) => event.kind === "task.contract" || event.kind === "task.contract_updated");
+  const contractRaw = latestContractEvent && typeof latestContractEvent.data.contract === "object" ? latestContractEvent.data.contract : void 0;
+  const contractConstraints = Array.isArray(contractRaw?.constraints) ? contractRaw.constraints.filter((c) => c.source === "user" && c.required === true && typeof c.text === "string").map((c) => String(c.text)) : void 0;
+  const contractCriteria = Array.isArray(contractRaw?.acceptanceCriteria) ? contractRaw.acceptanceCriteria.filter((c) => typeof c.id === "string").map((c) => ({ id: String(c.id), required: c.required === true })) : void 0;
   return {
     version: 1,
-    activeCriteria,
+    activeCriteria: contractCriteria ?? activeCriteria,
     unresolvedIssues,
     ...latestVerification ? {
       latestVerification: {
@@ -28492,7 +28547,7 @@ function buildCompactionStateSnapshot(events, toSeq) {
     } : {},
     retainedEvidenceRefs: evidenceFromResults(results),
     affectedFiles: [...affectedFiles].slice(0, 64),
-    userConstraints: [...userConstraints].slice(-12),
+    userConstraints: contractConstraints ?? [...userConstraints].slice(-12),
     ...missionState ? { missionState } : {}
   };
 }
@@ -28630,13 +28685,45 @@ var init_compaction = __esm({
 function isModelSurfaceEvent(event) {
   return MODEL_SURFACE_KINDS.has(event.kind);
 }
+function latestSurfaceSeqByKind(events) {
+  const latest = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (LATEST_ONLY_SURFACE_KINDS.has(e.kind) && !isSeqShadowed(e.seq, coveringCompactions(events))) {
+      latest.set(e.kind, e.seq);
+    }
+  }
+  return latest;
+}
 function asString(value) {
   return typeof value === "string" ? value : void 0;
 }
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function formatResourceSnapshot(data) {
+  const used = asNumber(data.toolCallsUsed) ?? 0;
+  const remaining = asNumber(data.toolCallsRemaining) ?? 0;
+  const lines = [
+    "RESOURCE STATUS",
+    `Tool calls: ${used} / ${used + remaining}`,
+    `Remaining: ${remaining}`
+  ];
+  const wall = asNumber(data.wallMsRemaining);
+  if (wall !== void 0)
+    lines.push(`Wall clock remaining: ${Math.max(0, Math.round(wall / 1e3))}s`);
+  lines.push(`Verification reserve: ${asNumber(data.verificationReserve) ?? 0}`);
+  lines.push(`Repair reserve: ${asNumber(data.repairReserve) ?? 0}`);
+  if (typeof data.stage === "string")
+    lines.push(`Stage: ${data.stage}`);
+  if (typeof data.pressure === "string")
+    lines.push(`Pressure: ${data.pressure}`);
+  return lines.join("\n");
+}
 function deriveMessages(events, options = {}) {
   const coverings = coveringCompactions(events);
   const orderedCoverings = [...coverings].sort((a, b) => a.fromSeq - b.fromSeq || a.seq - b.seq);
   const compactBySeq = new Map(coverings.map((c) => [c.seq, c]));
+  const latestOfKind = latestSurfaceSeqByKind(events);
   const messages = [];
   let nextCheckpoint = 0;
   const pushCheckpoint = (compact) => {
@@ -28663,6 +28750,8 @@ function deriveMessages(events, options = {}) {
       continue;
     if (!isModelSurfaceEvent(e))
       continue;
+    if (LATEST_ONLY_SURFACE_KINDS.has(e.kind) && latestOfKind.get(e.kind) !== e.seq)
+      continue;
     const d = e.data;
     switch (e.kind) {
       case "user.message":
@@ -28703,6 +28792,13 @@ function deriveMessages(events, options = {}) {
           seq: e.seq
         });
         break;
+      case "resource.snapshot":
+        messages.push({
+          role: "system",
+          content: formatResourceSnapshot(d),
+          seq: e.seq
+        });
+        break;
     }
   }
   pushDueCheckpoints(Number.POSITIVE_INFINITY);
@@ -28729,7 +28825,7 @@ function pairToolCalls(events) {
   }
   return ordered;
 }
-var MODEL_SURFACE_KINDS;
+var MODEL_SURFACE_KINDS, LATEST_ONLY_SURFACE_KINDS;
 var init_modelSurface = __esm({
   "packages/core/dist/session/modelSurface.js"() {
     "use strict";
@@ -28739,8 +28835,11 @@ var init_modelSurface = __esm({
       "assistant.message",
       "tool.call",
       "tool.result",
-      "session.compacted"
+      "session.compacted",
+      // 2.6: budget awareness for the model (latest-only projection below).
+      "resource.snapshot"
     ]);
+    LATEST_ONLY_SURFACE_KINDS = /* @__PURE__ */ new Set(["resource.snapshot"]);
   }
 });
 
@@ -29493,6 +29592,60 @@ function pushCompactionViolations(events, knownSeq, pairs, violations) {
     }
   }
 }
+function validateResourceAndContractEvents(events) {
+  const violations = [];
+  let lastToolCallsUsed = -1;
+  for (const e of events) {
+    if (e.kind === "resource.snapshot") {
+      const used = e.data.toolCallsUsed;
+      const remaining = e.data.toolCallsRemaining;
+      if (typeof used !== "number" || typeof remaining !== "number" || used < 0 || remaining < 0) {
+        violations.push({ code: "RESOURCE_SNAPSHOT_INVALID", seq: e.seq, message: "snapshot must carry non-negative toolCallsUsed/Remaining" });
+        continue;
+      }
+      if (used < lastToolCallsUsed) {
+        violations.push({ code: "RESOURCE_USED_MONOTONIC", seq: e.seq, message: `toolCallsUsed went ${lastToolCallsUsed} -> ${used}` });
+      }
+      lastToolCallsUsed = used;
+      const limit = typeof e.data.toolCallsLimit === "number" ? e.data.toolCallsLimit : used + remaining;
+      if (used + remaining !== limit) {
+        violations.push({ code: "RESOURCE_REMAINING_COHERENT", seq: e.seq, message: `used(${used}) + remaining(${remaining}) != limit(${limit})` });
+      }
+      for (const key of ["verificationReserve", "repairReserve"]) {
+        const v = e.data[key];
+        if (typeof v === "number" && v < 0) {
+          violations.push({ code: "RESERVE_NEGATIVE", seq: e.seq, message: `${key} is negative (${v})` });
+        }
+      }
+    }
+    if (e.kind === "session.harness_manifest") {
+      if (typeof e.data.manifestHash !== "string" || !e.data.manifest) {
+        violations.push({ code: "MANIFEST_PAYLOAD_INVALID", seq: e.seq, message: "session.harness_manifest needs {manifest, manifestHash}" });
+      }
+    }
+  }
+  let lastVersion = 0;
+  for (const e of events) {
+    if (e.kind !== "task.contract" && e.kind !== "task.contract_updated")
+      continue;
+    const contract = e.data.contract;
+    const version2 = contract && typeof contract === "object" ? contract.version : void 0;
+    if (typeof version2 !== "number" || version2 < 1) {
+      violations.push({ code: "TASK_CONTRACT_VERSION_MONOTONIC", seq: e.seq, message: "contract payload must carry a positive version" });
+      continue;
+    }
+    if (version2 <= lastVersion) {
+      violations.push({ code: "TASK_CONTRACT_VERSION_MONOTONIC", seq: e.seq, message: `version ${version2} did not increase past ${lastVersion}` });
+    }
+    lastVersion = version2;
+    const source = contract && typeof contract === "object" ? contract.source : void 0;
+    const userSeq = source && typeof source === "object" ? source.userSeq : void 0;
+    if (typeof userSeq !== "number" || userSeq < 1) {
+      violations.push({ code: "TASK_CONTRACT_SOURCE_INVALID", seq: e.seq, message: "contract.source.userSeq must be a positive event seq" });
+    }
+  }
+  return violations;
+}
 var init_invariants = __esm({
   "packages/core/dist/session/invariants.js"() {
     "use strict";
@@ -29500,6 +29653,122 @@ var init_invariants = __esm({
   }
 });
 
+// packages/core/dist/session/taskContract.js
+function applyTaskContractUpdate(contract, update) {
+  if (update.goal !== void 0 && update.goal !== contract.goal) {
+    if (update.nextUserSeq === void 0) {
+      throw new TaskContractConflictError("agent-derived update may not rewrite the goal");
+    }
+  }
+  const constraints = contract.constraints.filter((c) => {
+    if (!update.removeConstraintIds?.includes(c.id))
+      return true;
+    if (c.source === "user" && c.required) {
+      throw new TaskContractConflictError(`required user constraint "${c.id}" cannot be removed`);
+    }
+    return false;
+  });
+  const criteria = contract.acceptanceCriteria.filter((c) => {
+    if (!update.removeCriterionIds?.includes(c.id))
+      return true;
+    if (c.source === "user" && c.required) {
+      throw new TaskContractConflictError(`required user criterion "${c.id}" cannot be removed`);
+    }
+    return false;
+  });
+  for (const add of update.addConstraints ?? []) {
+    if (constraints.some((c) => c.id === add.id) || (update.addConstraints ?? []).filter((x) => x.id === add.id).length > 1) {
+      throw new TaskContractConflictError(`duplicate constraint id "${add.id}"`);
+    }
+  }
+  for (const add of update.addCriteria ?? []) {
+    if (criteria.some((c) => c.id === add.id) || (update.addCriteria ?? []).filter((x) => x.id === add.id).length > 1) {
+      throw new TaskContractConflictError(`duplicate criterion id "${add.id}"`);
+    }
+  }
+  return TaskContractSchema.parse({
+    version: contract.version + 1,
+    goal: update.goal ?? contract.goal,
+    constraints: [...constraints, ...update.addConstraints ?? []],
+    acceptanceCriteria: [...criteria, ...update.addCriteria ?? []],
+    source: {
+      userSeq: update.nextUserSeq ?? contract.source.userSeq
+    }
+  });
+}
+function contractToCompactionFields(contract) {
+  return {
+    goal: contract.goal,
+    userConstraints: contract.constraints.filter((c) => c.source === "user" && c.required).map((c) => c.text),
+    activeCriteria: contract.acceptanceCriteria.map((c) => ({ id: c.id, required: c.required }))
+  };
+}
+function deriveInitialContract(userSeq, text) {
+  const lines = text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  const stripped = lines.map((l) => l.replace(/^[-*]\s+/, ""));
+  const constraintLines = stripped.filter((l) => /^(do not|don't|never|no |non |without changing|keep)/i.test(l));
+  const criteriaLines = stripped.filter((l) => /^\[?\s*[x ]?\s*\]?\s*/.test(l) === false ? /^(acceptance|verify|test)[:\s]/i.test(l) : true).map((l) => l.replace(/^\[?\s*[x ]?\s*\]?\s*/, "").replace(/^(acceptance|verify|test)[:\s]+/i, ""));
+  return TaskContractSchema.parse({
+    version: 1,
+    goal: lines[0] ?? text.slice(0, 200),
+    constraints: constraintLines.map((t, i) => ({
+      id: `uc-${i + 1}`,
+      text: t,
+      source: "user",
+      required: true
+    })),
+    acceptanceCriteria: criteriaLines.map((t, i) => ({
+      id: `ac-${i + 1}`,
+      text: t,
+      source: "user",
+      required: true
+    })),
+    source: { userSeq }
+  });
+}
+var TaskConstraintSchema, TaskCriterionSchema, TaskContractSchema, TaskContractConflictError;
+var init_taskContract = __esm({
+  "packages/core/dist/session/taskContract.js"() {
+    "use strict";
+    init_zod();
+    TaskConstraintSchema = external_exports.object({
+      id: external_exports.string().min(1),
+      text: external_exports.string().min(1),
+      source: external_exports.enum(["user", "agent-derived"]),
+      required: external_exports.boolean()
+    });
+    TaskCriterionSchema = external_exports.object({
+      id: external_exports.string().min(1),
+      text: external_exports.string().min(1),
+      source: external_exports.enum(["user", "agent-derived"]),
+      required: external_exports.boolean(),
+      verificationHint: external_exports.object({
+        kind: external_exports.enum(["command", "tool", "semantic", "manual"]),
+        value: external_exports.string().optional()
+      }).optional()
+    });
+    TaskContractSchema = external_exports.object({
+      version: external_exports.number().int().positive(),
+      goal: external_exports.string().min(1),
+      constraints: external_exports.array(TaskConstraintSchema),
+      acceptanceCriteria: external_exports.array(TaskCriterionSchema),
+      source: external_exports.object({
+        /** Seq of the user.message the contract was extracted from. */
+        userSeq: external_exports.number().int().positive()
+      })
+    });
+    TaskContractConflictError = class extends Error {
+      reason;
+      code = "TASK_CONTRACT_CONFLICT";
+      constructor(reason) {
+        super(`task contract update rejected: ${reason}`);
+        this.reason = reason;
+        this.name = "TaskContractConflictError";
+      }
+    };
+  }
+});
+
 // packages/core/dist/session/index.js
 var init_session = __esm({
   "packages/core/dist/session/index.js"() {
@@ -29515,6 +29784,7 @@ var init_session = __esm({
     init_exportSession();
     init_invariants();
     init_recovery();
+    init_taskContract();
   }
 });
 
@@ -29850,11 +30120,15 @@ function toolManifestHash(tools) {
   const manifest = [...tools].sort().join(",");
   return createHash3("sha256").update(manifest).digest("hex");
 }
+function profileHash(profile) {
+  return createHash3("sha256").update(stableStringify(profile)).digest("hex");
+}
 var ProfileSchema, MINIMAL_TOOLS, MINIMAL_V1, KRAKEN_V1, COUNCIL_V1, MISSION_V1, BUILT_IN_PROFILES, UnknownProfileError;
 var init_profiles = __esm({
   "packages/core/dist/runtime/profiles.js"() {
     "use strict";
     init_zod();
+    init_requestSnapshot();
     ProfileSchema = external_exports.object({
       /** `<name>/v<N>` — immutable once published. */
       id: external_exports.string().regex(/^[a-z0-9-]+\/v\d+$/, "profile id must be <name>/v<N>"),
@@ -29926,6 +30200,99 @@ var init_profiles = __esm({
   }
 });
 
+// packages/core/dist/runtime/harnessManifest.js
+function hashHarnessManifest(manifest) {
+  return sha256Hex(stableStringify(manifest));
+}
+function harnessInputHash(value) {
+  return sha256Hex(stableStringify(value));
+}
+function collectPaths2(base, a, b, out, depth = 0) {
+  if (depth > 6)
+    return;
+  if (stableStringify(a) === stableStringify(b))
+    return;
+  const objA = a && typeof a === "object" && !Array.isArray(a) ? a : null;
+  const objB = b && typeof b === "object" && !Array.isArray(b) ? b : null;
+  if (objA && objB) {
+    for (const key of [.../* @__PURE__ */ new Set([...Object.keys(objA), ...Object.keys(objB)])].sort()) {
+      collectPaths2(base ? `${base}.${key}` : key, objA[key], objB[key], out, depth + 1);
+    }
+    return;
+  }
+  out.push(base);
+}
+function diffHarnessManifest(oldManifest, newManifest) {
+  const changed = [];
+  collectPaths2("", oldManifest, newManifest, changed);
+  return { changed: changed.sort() };
+}
+function classifyHarnessChanges(diff) {
+  const byField = {};
+  for (const field of diff.changed) {
+    const hit = FIELD_CLASSES.find((m) => field === m.prefix || field.startsWith(m.prefix + "."));
+    byField[field] = hit ? hit.cls : "cosmetic";
+  }
+  const order = { behavioral: 3, structural: 2, cosmetic: 1 };
+  const overall = Object.values(byField).reduce((acc, cls) => order[cls] > order[acc] ? cls : acc, "cosmetic");
+  return { overall, byField };
+}
+var HARNESS_MANIFEST_SCHEMA_VERSION, HarnessPromptsSchema, HarnessManifestV1Schema, FIELD_CLASSES;
+var init_harnessManifest = __esm({
+  "packages/core/dist/runtime/harnessManifest.js"() {
+    "use strict";
+    init_zod();
+    init_requestSnapshot();
+    HARNESS_MANIFEST_SCHEMA_VERSION = 1;
+    HarnessPromptsSchema = external_exports.object({
+      kraken: external_exports.string().min(1).optional(),
+      gauntlet: external_exports.string().min(1).optional(),
+      council: external_exports.string().min(1).optional(),
+      mission: external_exports.string().min(1).optional()
+    });
+    HarnessManifestV1Schema = external_exports.object({
+      schemaVersion: external_exports.literal(HARNESS_MANIFEST_SCHEMA_VERSION),
+      profile: external_exports.object({
+        id: external_exports.string().min(1),
+        /** WorkPhase of the session that recorded the manifest. */
+        phase: external_exports.enum(["plan", "build"]),
+        /** Hash of the full profile (see profileHash in profiles.ts). */
+        hash: external_exports.string().min(1)
+      }),
+      prompts: HarnessPromptsSchema,
+      capabilities: external_exports.object({
+        toolManifestHash: external_exports.string().min(1),
+        skillManifestHash: external_exports.string().min(1)
+      }),
+      policies: external_exports.object({
+        routingHash: external_exports.string().min(1),
+        verificationHash: external_exports.string().min(1),
+        completionPolicyHash: external_exports.string().min(1),
+        compactionHash: external_exports.string().min(1),
+        /** Behavioural since 2.6 Track B: budget policy shapes execution. */
+        resourcePolicyHash: external_exports.string().min(1)
+      }),
+      runtime: external_exports.object({
+        coreVersion: external_exports.string().min(1),
+        cliVersion: external_exports.string().min(1)
+      })
+    });
+    FIELD_CLASSES = [
+      { prefix: "prompts", cls: "behavioral" },
+      { prefix: "capabilities.toolManifestHash", cls: "behavioral" },
+      { prefix: "capabilities.skillManifestHash", cls: "behavioral" },
+      { prefix: "policies.routingHash", cls: "behavioral" },
+      { prefix: "policies.verificationHash", cls: "behavioral" },
+      { prefix: "policies.completionPolicyHash", cls: "structural" },
+      { prefix: "policies.compactionHash", cls: "behavioral" },
+      { prefix: "policies.resourcePolicyHash", cls: "behavioral" },
+      { prefix: "profile", cls: "structural" },
+      { prefix: "runtime", cls: "structural" },
+      { prefix: "schemaVersion", cls: "structural" }
+    ];
+  }
+});
+
 // packages/core/dist/experimental.js
 function isExperimentalEnabled(flag, env = process.env) {
   const raw = env.ZELARI_EXPERIMENTAL;
@@ -30008,6 +30375,155 @@ var init_executionContext = __esm({
   }
 });
 
+// packages/core/dist/runtime/resourcePolicy.js
+import { createHash as createHash4 } from "node:crypto";
+function defaultResourcePolicy(profileId) {
+  return PROFILE_RESOURCE_POLICIES[profileId] ?? PROFILE_RESOURCE_POLICIES["kraken/v1"];
+}
+function resourcePolicyHash(policy) {
+  return createHash4("sha256").update(stableStringify(ResourcePolicySchema.parse(policy))).digest("hex");
+}
+var BudgetPressureSchema, ResourceStageSchema, PressureThresholdsSchema, DEFAULT_PRESSURE_THRESHOLDS, ResourcePolicySchema, PROFILE_RESOURCE_POLICIES;
+var init_resourcePolicy = __esm({
+  "packages/core/dist/runtime/resourcePolicy.js"() {
+    "use strict";
+    init_zod();
+    init_requestSnapshot();
+    BudgetPressureSchema = external_exports.enum(["ample", "normal", "constrained", "critical"]);
+    ResourceStageSchema = external_exports.enum(["explore", "implement", "verify", "repair"]);
+    PressureThresholdsSchema = external_exports.object({
+      /** remaining/usable >= ample → ample. */
+      ample: external_exports.number().min(0).max(1),
+      /** remaining/usable >= constrained → normal; below → constrained. */
+      constrained: external_exports.number().min(0).max(1),
+      /** remaining/usable < critical → critical. */
+      critical: external_exports.number().min(0).max(1)
+    });
+    DEFAULT_PRESSURE_THRESHOLDS = Object.freeze({
+      ample: 0.5,
+      constrained: 0.25,
+      critical: 0.1
+    });
+    ResourcePolicySchema = external_exports.object({
+      maxToolCalls: external_exports.number().int().positive(),
+      reserve: external_exports.object({
+        /** Protected: tool budget the non-verification loop may not consume (§11.4). */
+        verification: external_exports.number().int().min(0),
+        /** Advisory-only by default (§11.4). */
+        repair: external_exports.number().int().min(0)
+      }),
+      wallClockMs: external_exports.number().int().positive().optional(),
+      /** Soft token ceiling (advisory telemetry, not enforced). */
+      softMaxTokens: external_exports.number().int().positive().optional(),
+      pressure: PressureThresholdsSchema.default(DEFAULT_PRESSURE_THRESHOLDS)
+    });
+    PROFILE_RESOURCE_POLICIES = Object.freeze({
+      "minimal/v1": {
+        maxToolCalls: 25,
+        reserve: { verification: 4, repair: 3 },
+        pressure: DEFAULT_PRESSURE_THRESHOLDS
+      },
+      "kraken/v1": {
+        maxToolCalls: 40,
+        reserve: { verification: 6, repair: 4 },
+        wallClockMs: 9e5,
+        pressure: DEFAULT_PRESSURE_THRESHOLDS
+      },
+      "council/v1": {
+        maxToolCalls: 30,
+        reserve: { verification: 4, repair: 2 },
+        pressure: DEFAULT_PRESSURE_THRESHOLDS
+      },
+      "mission/v1": {
+        maxToolCalls: 60,
+        reserve: { verification: 8, repair: 6 },
+        wallClockMs: 18e5,
+        pressure: DEFAULT_PRESSURE_THRESHOLDS
+      }
+    });
+  }
+});
+
+// packages/core/dist/runtime/resourceBudget.js
+function computeBudget(policy, usage, stage = "explore") {
+  const used = Math.max(0, Math.min(usage.toolCallsUsed, policy.maxToolCalls));
+  return {
+    toolCalls: {
+      limit: policy.maxToolCalls,
+      used,
+      remaining: policy.maxToolCalls - used
+    },
+    wallTime: {
+      limitMs: policy.wallClockMs,
+      elapsedMs: Math.max(0, usage.elapsedMs ?? 0),
+      remainingMs: policy.wallClockMs === void 0 ? void 0 : Math.max(0, policy.wallClockMs - (usage.elapsedMs ?? 0))
+    },
+    tokens: usage.tokensUsed === void 0 && policy.softMaxTokens === void 0 ? void 0 : {
+      softLimit: policy.softMaxTokens,
+      used: usage.tokensUsed ?? 0,
+      remaining: policy.softMaxTokens === void 0 ? void 0 : Math.max(0, policy.softMaxTokens - (usage.tokensUsed ?? 0))
+    },
+    reserve: {
+      verification: Math.max(0, policy.reserve.verification),
+      repair: Math.max(0, policy.reserve.repair)
+    },
+    stage
+  };
+}
+function usageFromLedger(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  let toolCallsUsed = 0;
+  let wallMs = 0;
+  let tokensUsed = 0;
+  for (const e of entries) {
+    if (seen.has(e.seq))
+      continue;
+    seen.add(e.seq);
+    toolCallsUsed += e.delta.toolCalls ?? 0;
+    wallMs += e.delta.wallMs ?? 0;
+    tokensUsed += e.delta.tokens ?? 0;
+  }
+  return { toolCallsUsed: Math.max(0, toolCallsUsed), wallMs: Math.max(0, wallMs), tokensUsed: Math.max(0, tokensUsed) };
+}
+function budgetPressure(budget, policy) {
+  const usable = Math.max(0, budget.toolCalls.remaining - budget.reserve.verification);
+  const capacity = Math.max(1, budget.toolCalls.limit - budget.reserve.verification);
+  const ratio = usable / capacity;
+  const t = policy.pressure;
+  if (ratio >= t.ample)
+    return "ample";
+  if (ratio >= t.constrained)
+    return "normal";
+  if (ratio >= t.critical)
+    return "constrained";
+  return "critical";
+}
+function isVerificationReserveProtected(budget) {
+  return budget.toolCalls.remaining <= budget.reserve.verification;
+}
+function canSpendOutsideReserve(budget, calls) {
+  return budget.toolCalls.remaining - budget.reserve.verification >= calls;
+}
+function ledgerDeltaFor(reason, calls = 1) {
+  switch (reason) {
+    case "tool-call":
+      return { toolCalls: calls };
+    case "model-turn":
+    case "verification":
+    case "repair":
+      return { toolCalls: calls };
+    case "timeout":
+      return {};
+    case "reservation":
+      return {};
+  }
+}
+var init_resourceBudget = __esm({
+  "packages/core/dist/runtime/resourceBudget.js"() {
+    "use strict";
+  }
+});
+
 // packages/core/dist/runtime/index.js
 var init_runtime2 = __esm({
   "packages/core/dist/runtime/index.js"() {
@@ -30017,7 +30533,10 @@ var init_runtime2 = __esm({
     init_memoryProviders();
     init_worktreeWorkspace();
     init_profiles();
+    init_harnessManifest();
     init_executionContext();
+    init_resourcePolicy();
+    init_resourceBudget();
   }
 });
 
@@ -30194,9 +30713,9 @@ var init_scopeDiscipline = __esm({
 });
 
 // packages/core/dist/verification/engine.js
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 function defaultSha256(input) {
-  return createHash4("sha256").update(input).digest("hex");
+  return createHash5("sha256").update(input).digest("hex");
 }
 function tail(text, max = 400) {
   return text.length > max ? `\u2026${text.slice(text.length - max)}` : text;
@@ -30358,12 +30877,12 @@ var init_engine = __esm({
        * content digest) and the returned ref carries the event seq when the
        * emitter resolved one.
        */
-      async fsEvidence(observation, path64, sha256, content, extra = {}) {
+      async fsEvidence(observation, path65, sha256, content, extra = {}) {
         const digest = sha256 && content !== void 0 ? sha256(content) : void 0;
-        const seq = await this.emitEvidence({ observation, path: path64, ...extra, ...digest ? { digest } : {} });
+        const seq = await this.emitEvidence({ observation, path: path65, ...extra, ...digest ? { digest } : {} });
         return {
           tier: "fs-observation",
-          ref: path64,
+          ref: path65,
           capturedAt: Date.now(),
           ...digest ? { digest } : {},
           ...seq !== void 0 ? { seq } : {}
@@ -30682,6 +31201,23 @@ function verificationCostRatio(verificationMs, totalMs) {
     return null;
   return verificationMs / totalMs;
 }
+function costPerVerifiedSolve(samples) {
+  const solved = samples.filter((s) => s.verified === true);
+  const totalCostUsd = samples.reduce((sum, s) => sum + s.modelCostUsd, 0);
+  const totalWallMs = samples.reduce((sum, s) => sum + s.wallMs, 0);
+  const totalToolCalls = samples.reduce((sum, s) => sum + s.toolCalls, 0);
+  const n = solved.length;
+  return {
+    verifiedSolves: n,
+    totalCostUsd: round(totalCostUsd),
+    costPerVerifiedSolve: n > 0 ? round(totalCostUsd / n) : null,
+    wallMsPerVerifiedSolve: n > 0 ? Math.round(totalWallMs / n) : null,
+    toolCallsPerVerifiedSolve: n > 0 ? round(totalToolCalls / n) : null
+  };
+}
+function round(v) {
+  return Math.round(v * 1e6) / 1e6;
+}
 var init_metrics = __esm({
   "packages/core/dist/verification/metrics.js"() {
     "use strict";
@@ -30890,6 +31426,44 @@ var init_verifier = __esm({
   }
 });
 
+// packages/core/dist/verification/resourceReserveGate.js
+function evaluateResourceReserveGate(input) {
+  const { evaluation, budget } = input;
+  if (evaluation.verdict === "PASS") {
+    return {
+      verdict: "PASS",
+      deterministicVerdict: "PASS",
+      resourceExhausted: false,
+      evidenceAffordable: true,
+      summary: evaluation.summary
+    };
+  }
+  const spendable = Math.max(0, budget.toolCalls.remaining - budget.reserve.verification);
+  const affordable = spendable + budget.reserve.verification > 0 && budget.toolCalls.remaining > 0;
+  if (affordable) {
+    return {
+      verdict: evaluation.verdict,
+      deterministicVerdict: evaluation.verdict,
+      resourceExhausted: false,
+      evidenceAffordable: true,
+      summary: evaluation.summary
+    };
+  }
+  const summary = `${evaluation.summary} \xB7 resource-exhausted: ${budget.toolCalls.used}/${budget.toolCalls.limit} tool calls used, no budget left for required evidence \u2014 BLOCKED, not a false done`;
+  return {
+    verdict: "BLOCKED",
+    deterministicVerdict: evaluation.verdict,
+    resourceExhausted: true,
+    evidenceAffordable: false,
+    summary
+  };
+}
+var init_resourceReserveGate = __esm({
+  "packages/core/dist/verification/resourceReserveGate.js"() {
+    "use strict";
+  }
+});
+
 // packages/core/dist/verification/index.js
 var init_verification2 = __esm({
   "packages/core/dist/verification/index.js"() {
@@ -30902,6 +31476,7 @@ var init_verification2 = __esm({
     init_metrics();
     init_verifier();
     init_scopeDiscipline();
+    init_resourceReserveGate();
   }
 });
 
@@ -31060,6 +31635,7 @@ __export(dist_exports, {
   BENNETTS_RAZOR_SHORT: () => BENNETTS_RAZOR_SHORT,
   BUILT_IN_PROFILES: () => BUILT_IN_PROFILES,
   BonConfigSchema: () => BonConfigSchema,
+  BudgetPressureSchema: () => BudgetPressureSchema,
   CLARIFICATION_PROTOCOL_MODULE: () => CLARIFICATION_PROTOCOL_MODULE,
   CODING_CATEGORY: () => CODING_CATEGORY,
   CODING_PRACTICES_MODULE: () => CODING_PRACTICES_MODULE,
@@ -31074,6 +31650,7 @@ __export(dist_exports, {
   DEFAULT_MAX_TENTACLES: () => DEFAULT_MAX_TENTACLES,
   DEFAULT_NFR_SPEC: () => DEFAULT_NFR_SPEC,
   DEFAULT_PLAN_TIMEOUT_MS: () => DEFAULT_PLAN_TIMEOUT_MS,
+  DEFAULT_PRESSURE_THRESHOLDS: () => DEFAULT_PRESSURE_THRESHOLDS,
   DEFAULT_VERIFIER_CONFIG: () => DEFAULT_VERIFIER_CONFIG,
   DEGRADED_RUN_BANNER: () => DEGRADED_RUN_BANNER,
   DESIGN_PHASE_MODE_BANNER: () => DESIGN_PHASE_MODE_BANNER,
@@ -31090,6 +31667,9 @@ __export(dist_exports, {
   FileAbsentCheckSchema: () => FileAbsentCheckSchema,
   FileContainsCheckSchema: () => FileContainsCheckSchema,
   FileExistsCheckSchema: () => FileExistsCheckSchema,
+  HARNESS_MANIFEST_SCHEMA_VERSION: () => HARNESS_MANIFEST_SCHEMA_VERSION,
+  HarnessManifestV1Schema: () => HarnessManifestV1Schema,
+  HarnessPromptsSchema: () => HarnessPromptsSchema,
   IMPLEMENTATION_ADVISOR_BANNER: () => IMPLEMENTATION_ADVISOR_BANNER,
   IMPLEMENTATION_IMPLEMENTER_BANNER: () => IMPLEMENTATION_IMPLEMENTER_BANNER,
   IMPLEMENTATION_MODE_BANNER: () => IMPLEMENTATION_MODE_BANNER,
@@ -31099,6 +31679,7 @@ __export(dist_exports, {
   KRAKEN_SELECTION_PLAYBOOK_MODULE: () => KRAKEN_SELECTION_PLAYBOOK_MODULE,
   KRAKEN_V1: () => KRAKEN_V1,
   LANGUAGE_POLICY_MODULE_TYPE: () => LANGUAGE_POLICY_MODULE_TYPE,
+  LATEST_ONLY_SURFACE_KINDS: () => LATEST_ONLY_SURFACE_KINDS,
   LAYOUT_MOTION_PROPS: () => LAYOUT_MOTION_PROPS,
   LESSONS_FILE: () => LESSONS_FILE,
   LifecycleHookRunner: () => LifecycleHookRunner,
@@ -31123,12 +31704,16 @@ __export(dist_exports, {
   NoneCheckSchema: () => NoneCheckSchema,
   NoopSubagentProvider: () => NoopSubagentProvider,
   OUTPUT_QUALITY_DIRECTIVE: () => OUTPUT_QUALITY_DIRECTIVE,
+  PROFILE_RESOURCE_POLICIES: () => PROFILE_RESOURCE_POLICIES,
   PROMPT_MODULES: () => PROMPT_MODULES,
   PROPRIETARY_REFUSAL_TEXT: () => PROPRIETARY_REFUSAL_TEXT,
   PROPRIETARY_SECRECY_MARKER: () => PROPRIETARY_SECRECY_MARKER,
   PROPRIETARY_SECRECY_MODULE: () => PROPRIETARY_SECRECY_MODULE,
   PlanError: () => PlanError,
+  PressureThresholdsSchema: () => PressureThresholdsSchema,
   ProfileSchema: () => ProfileSchema,
+  ResourcePolicySchema: () => ResourcePolicySchema,
+  ResourceStageSchema: () => ResourceStageSchema,
   SESSION_EVENT_KINDS: () => SESSION_EVENT_KINDS,
   SESSION_EXPORT_FORMAT: () => SESSION_EXPORT_FORMAT,
   SESSION_EXPORT_VERSION: () => SESSION_EXPORT_VERSION,
@@ -31152,6 +31737,10 @@ __export(dist_exports, {
   TOOL_DEFINITIONS: () => TOOL_DEFINITIONS,
   TOOL_USE_PROTOCOL_DIRECTIVE: () => TOOL_USE_PROTOCOL_DIRECTIVE,
   TURN_COMPLETION_MODULE: () => TURN_COMPLETION_MODULE,
+  TaskConstraintSchema: () => TaskConstraintSchema,
+  TaskContractConflictError: () => TaskContractConflictError,
+  TaskContractSchema: () => TaskContractSchema,
+  TaskCriterionSchema: () => TaskCriterionSchema,
   UnknownMemberError: () => UnknownMemberError,
   UnknownProfileError: () => UnknownProfileError,
   VAULT_TOOL_DEFINITIONS: () => VAULT_TOOL_DEFINITIONS,
@@ -31173,8 +31762,10 @@ __export(dist_exports, {
   applyInlineJsAutofix: () => applyInlineJsAutofix,
   applyMotionAutofix: () => applyMotionAutofix,
   applyRetryIfMissing: () => applyRetryIfMissing,
+  applyTaskContractUpdate: () => applyTaskContractUpdate,
   auditDegradedBanner: () => auditDegradedBanner,
   auditSynthesisTiers: () => auditSynthesisTiers,
+  budgetPressure: () => budgetPressure,
   buildCompactionStateSnapshot: () => buildCompactionStateSnapshot,
   buildCouncilCompletion: () => buildCouncilCompletion,
   buildCustomParameters: () => buildCustomParameters,
@@ -31192,12 +31783,14 @@ __export(dist_exports, {
   buildSystemPrompt: () => buildSystemPrompt,
   buildSystemPromptSplit: () => buildSystemPromptSplit,
   canRunParallel: () => canRunParallel,
+  canSpendOutsideReserve: () => canSpendOutsideReserve,
   canonicalTools: () => canonicalTools,
   captureFailure: () => captureFailure,
   checkImplementationCompletion: () => checkImplementationCompletion,
   checkImplementationDelivery: () => checkImplementationDelivery,
   checkMemberToolEmissionSets: () => checkMemberToolEmissionSets,
   checkMemberToolEmissions: () => checkMemberToolEmissions,
+  classifyHarnessChanges: () => classifyHarnessChanges,
   classifyInterruptedTools: () => classifyInterruptedTools,
   classifyMission: () => classifyMission,
   classifyTaskScope: () => classifyTaskScope,
@@ -31209,7 +31802,10 @@ __export(dist_exports, {
   compareReplayPrefix: () => compareReplayPrefix,
   computeAgentSkills: () => computeAgentSkills,
   computeAgentTools: () => computeAgentTools,
+  computeBudget: () => computeBudget,
   computeFalseDoneRate: () => computeFalseDoneRate,
+  contractToCompactionFields: () => contractToCompactionFields,
+  costPerVerifiedSolve: () => costPerVerifiedSolve,
   councilModeBanner: () => councilModeBanner,
   councilTierFromSize: () => councilTierFromSize,
   countByStatus: () => countByStatus,
@@ -31221,6 +31817,8 @@ __export(dist_exports, {
   createGraph: () => createGraph,
   createRoutedRequestSnapshot: () => createRoutedRequestSnapshot,
   defaultPersonaParse: () => defaultPersonaParse,
+  defaultResourcePolicy: () => defaultResourcePolicy,
+  deriveInitialContract: () => deriveInitialContract,
   deriveMessages: () => deriveMessages,
   deriveMissionState: () => deriveMissionState,
   derivedToAgentMessages: () => derivedToAgentMessages,
@@ -31228,11 +31826,13 @@ __export(dist_exports, {
   detectAssistantTextLoopWindow: () => detectAssistantTextLoopWindow,
   detectDegradedRun: () => detectDegradedRun,
   detectResponseLanguage: () => detectResponseLanguage,
+  diffHarnessManifest: () => diffHarnessManifest,
   disjointScopeSets: () => disjointScopeSets,
   emptyContextGrowthStats: () => emptyContextGrowthStats,
   enforceDesignPhaseToolEmissions: () => enforceDesignPhaseToolEmissions,
   evaluateCompletion: () => evaluateCompletion,
   evaluateMissionContinuation: () => evaluateMissionContinuation,
+  evaluateResourceReserveGate: () => evaluateResourceReserveGate,
   executeTool: () => executeTool,
   exportSession: () => exportSession,
   exportSessionJson: () => exportSessionJson,
@@ -31249,6 +31849,7 @@ __export(dist_exports, {
   forkSession: () => forkSession,
   formatCompactionStateSnapshot: () => formatCompactionStateSnapshot,
   formatLessonsForContext: () => formatLessonsForContext,
+  formatResourceSnapshot: () => formatResourceSnapshot,
   getAgent: () => getAgent,
   getAllTools: () => getAllTools,
   getAvailableTools: () => getAvailableTools,
@@ -31265,7 +31866,9 @@ __export(dist_exports, {
   getSkillMetadata: () => getSkillMetadata,
   getSkillsByCategory: () => getSkillsByCategory,
   getToolDescriptions: () => getToolDescriptions,
+  harnessInputHash: () => harnessInputHash,
   hasInteractiveClarification: () => hasInteractiveClarification,
+  hashHarnessManifest: () => hashHarnessManifest,
   hashToolCall: () => hashToolCall,
   hookMatches: () => hookMatches,
   interruptedEventData: () => interruptedEventData,
@@ -31299,10 +31902,13 @@ __export(dist_exports, {
   isSettled: () => isSettled,
   isStatusTheaterUnit: () => isStatusTheaterUnit,
   isValidTool: () => isValidTool,
+  isVerificationReserveProtected: () => isVerificationReserveProtected,
   isVerifyToolCheckSkipped: () => isVerifyToolCheckSkipped,
   jaccardSimilarity: () => jaccardSimilarity,
   jsonBytes: () => jsonBytes,
   lastVerificationRun: () => lastVerificationRun,
+  latestSurfaceSeqByKind: () => latestSurfaceSeqByKind,
+  ledgerDeltaFor: () => ledgerDeltaFor,
   lineageOf: () => lineageOf,
   lintSynthesisHonesty: () => lintSynthesisHonesty,
   listCodingSkills: () => listCodingSkills,
@@ -31331,6 +31937,7 @@ __export(dist_exports, {
   parseVerifyVerdict: () => parseVerifyVerdict,
   pathsOverlap: () => pathsOverlap,
   pickWeakest: () => pickWeakest,
+  profileHash: () => profileHash,
   promoteMember: () => promoteMember,
   rankByWeakness: () => rankByWeakness,
   readLessonsDeduped: () => readLessonsDeduped,
@@ -31357,6 +31964,7 @@ __export(dist_exports, {
   resolveSessionsDir: () => resolveSessionsDir,
   resolveSkillDependencies: () => resolveSkillDependencies,
   resolveVerifyRetryTool: () => resolveVerifyRetryTool,
+  resourcePolicyHash: () => resourcePolicyHash,
   restrictImplementationWrites: () => restrictImplementationWrites,
   resumeSession: () => resumeSession,
   retrySafetyForSideEffect: () => retrySafetyForSideEffect,
@@ -31394,9 +32002,11 @@ __export(dist_exports, {
   topoLevels: () => topoLevels,
   unregisterCustomTool: () => unregisterCustomTool,
   unregisterSkill: () => unregisterSkill,
+  usageFromLedger: () => usageFromLedger,
   utf8Bytes: () => utf8Bytes,
   validateCodingSkillRequires: () => validateCodingSkillRequires,
   validateGraph: () => validateGraph,
+  validateResourceAndContractEvents: () => validateResourceAndContractEvents,
   validateSessionTrace: () => validateSessionTrace,
   verificationCostRatio: () => verificationCostRatio,
   verifiedSolveRate: () => verifiedSolveRate,
@@ -31695,6 +32305,189 @@ var init_sessionManager = __esm({
   }
 });
 
+// src/cli/budget/resourceLedger.ts
+function rebuildLedgerFromEvents(events) {
+  const ledger = new ResourceLedger();
+  for (const e of events) {
+    if (e.kind === "tool.call") {
+      ledger.record("tool-call", 1);
+    } else if (e.kind === "verification.run") {
+      ledger.record("verification", 0);
+    }
+  }
+  return ledger;
+}
+var ResourceLedger;
+var init_resourceLedger = __esm({
+  "src/cli/budget/resourceLedger.ts"() {
+    "use strict";
+    init_dist();
+    init_dist();
+    ResourceLedger = class _ResourceLedger {
+      entries = [];
+      nextSeq = 1;
+      static fromEntries(entries) {
+        const ledger = new _ResourceLedger();
+        ledger.entries = [...entries];
+        ledger.nextSeq = entries.reduce((m, e) => Math.max(m, e.seq), 0) + 1;
+        return ledger;
+      }
+      /** Record one spend. Returns the entry (host call sites only). */
+      record(reason, calls = 1) {
+        const entry = { seq: this.nextSeq++, reason, delta: ledgerDeltaFor(reason, calls) };
+        this.entries.push(entry);
+        return entry;
+      }
+      snapshot() {
+        return [...this.entries];
+      }
+      /** Replace state (BudgetRuntime resume path); host call sites only. */
+      resetTo(entries) {
+        this.entries = [...entries];
+        this.nextSeq = entries.reduce((m, e) => Math.max(m, e.seq), 0) + 1;
+      }
+      usage() {
+        return usageFromLedger(this.entries);
+      }
+      /** Current budget projection under the given policy. Pure over the ledger. */
+      budget(policy, stage = "implement") {
+        const usage = this.usage();
+        return computeBudget(policy, { toolCallsUsed: usage.toolCallsUsed, elapsedMs: usage.wallMs, tokensUsed: usage.tokensUsed }, stage);
+      }
+      pressure(policy) {
+        return budgetPressure(this.budget(policy), policy);
+      }
+    };
+  }
+});
+
+// src/cli/budget/resourceSnapshot.ts
+function buildResourceSnapshot(budget, policy) {
+  return {
+    toolCallsLimit: budget.toolCalls.limit,
+    toolCallsUsed: budget.toolCalls.used,
+    toolCallsRemaining: budget.toolCalls.remaining,
+    ...budget.wallTime.remainingMs !== void 0 ? { wallMsRemaining: budget.wallTime.remainingMs } : {},
+    verificationReserve: budget.reserve.verification,
+    repairReserve: budget.reserve.repair,
+    stage: budget.stage,
+    pressure: budgetPressure(budget, policy),
+    reserveProtected: isVerificationReserveProtected(budget)
+  };
+}
+function shouldEmitSnapshot(previous, next) {
+  if (!previous) return true;
+  if (previous.stage !== next.stage) return true;
+  if (previous.pressure !== next.pressure) return true;
+  if (previous.reserveProtected !== next.reserveProtected) return true;
+  if (previous.toolCallsUsed !== next.toolCallsUsed) return true;
+  return false;
+}
+var init_resourceSnapshot = __esm({
+  "src/cli/budget/resourceSnapshot.ts"() {
+    "use strict";
+    init_dist();
+  }
+});
+
+// src/cli/budget/budgetRuntime.ts
+function resolveResourceEnforcement(env = process.env) {
+  return env.ZELARI_RESOURCE_ENFORCEMENT === "protected" ? "protected" : "advisory";
+}
+var DEFAULT_ESSENTIAL_TOOLS, ADVISORY_NOTICE, PROTECTED_DENIAL, BudgetRuntime;
+var init_budgetRuntime = __esm({
+  "src/cli/budget/budgetRuntime.ts"() {
+    "use strict";
+    init_dist();
+    init_resourceLedger();
+    init_resourceSnapshot();
+    DEFAULT_ESSENTIAL_TOOLS = [
+      "bash",
+      "read_file",
+      "edit_file",
+      "write_file",
+      "apply_diff",
+      "grep_content",
+      "list_files",
+      "show_diff"
+    ];
+    ADVISORY_NOTICE = "Resource advisory: verification reserve reached. Prioritize test/typecheck/build/diff and targeted repair; avoid broad exploration or delegation.";
+    PROTECTED_DENIAL = "Resource protected: remaining tool calls are reserved for verification and targeted repair. Run the required checks (test/typecheck/build), read the failure, apply a minimal fix, retest \u2014 or report BLOCKED with the evidence you have.";
+    BudgetRuntime = class {
+      policy;
+      enforcement;
+      ledger;
+      essential;
+      stage;
+      lastEmitted;
+      constructor(profileId, opts = {}) {
+        this.policy = opts.policy ?? defaultResourcePolicy(profileId);
+        this.enforcement = opts.enforcement ?? "advisory";
+        this.essential = new Set(opts.essentialTools ?? DEFAULT_ESSENTIAL_TOOLS);
+        this.stage = opts.stage ?? "implement";
+        this.ledger = new ResourceLedger();
+      }
+      /**
+       * Count one tool call; returns the snapshot to emit when §10.4 says so
+       * (first sight, stage/pressure change, reserve crossing, any usage delta).
+       */
+      noteToolCall() {
+        this.ledger.record("tool-call");
+        return this.emitIfDue();
+      }
+      /** §10.4 verification start: stage change (and a zero-cost ledger mark). */
+      noteVerificationStart() {
+        this.ledger.record("verification", 0);
+        return this.setStage("verify");
+      }
+      /** §10.4 repair start. */
+      noteRepairStart() {
+        return this.setStage("repair");
+      }
+      /** Stage transition; emits when the stage actually changes. */
+      setStage(stage) {
+        if (stage === this.stage) return null;
+        this.stage = stage;
+        return this.emitIfDue();
+      }
+      /** Current projection without emitting. */
+      current() {
+        return buildResourceSnapshot(this.ledger.budget(this.policy, this.stage), this.policy);
+      }
+      /** §11.3 gate — advisory mode never blocks; protected mode guards the zone. */
+      gateToolCall(toolName) {
+        const snapshot = this.current();
+        if (!snapshot.reserveProtected) return { allowed: true, advisory: false, snapshot };
+        if (this.enforcement === "advisory") {
+          return { allowed: true, advisory: true, reason: ADVISORY_NOTICE, snapshot };
+        }
+        if (this.essential.has(toolName)) {
+          return { allowed: true, advisory: true, reason: ADVISORY_NOTICE, snapshot };
+        }
+        return { allowed: false, advisory: false, reason: PROTECTED_DENIAL, snapshot };
+      }
+      /** Resume path (§9.5): rebuild usage from the session log, no emission. */
+      adoptLedgerFromEvents(events) {
+        const rebuilt = rebuildLedgerFromEvents(events);
+        this.ledger.resetTo(rebuilt.snapshot());
+        this.lastEmitted = void 0;
+      }
+      /** Latest emitted snapshot (what the model surface shows), if any. */
+      latestEmitted() {
+        return this.lastEmitted;
+      }
+      emitIfDue() {
+        const next = this.current();
+        if (shouldEmitSnapshot(this.lastEmitted, next)) {
+          this.lastEmitted = next;
+          return next;
+        }
+        return null;
+      }
+    };
+  }
+});
+
 // src/cli/sessionSpine.ts
 import path21 from "node:path";
 function spineEnabled() {
@@ -31776,6 +32569,14 @@ function mapBrainEventToSpine(ev) {
 }
 async function wrapSessionWriter(inner, sessionId2, options = {}) {
   const spine = await SessionSpineMirror.adopt(sessionId2, options);
+  if (spine.status === "active") {
+    const profile = options.extraStarted?.profile;
+    spine.attachBudgetRuntime(
+      new BudgetRuntime(typeof profile === "string" ? profile : "kraken/v1", {
+        enforcement: resolveResourceEnforcement()
+      })
+    );
+  }
   return new SpineMirroringWriter(inner, spine.status === "active" ? spine : null);
 }
 var MAX_STREAM_BUFFERS, SessionSpineMirror, SpineMirroringWriter;
@@ -31785,6 +32586,7 @@ var init_sessionSpine = __esm({
     init_session();
     init_session();
     init_verification2();
+    init_budgetRuntime();
     MAX_STREAM_BUFFERS = 32;
     SessionSpineMirror = class _SessionSpineMirror {
       constructor(sessionId2, options) {
@@ -31796,6 +32598,10 @@ var init_sessionSpine = __esm({
       chain = Promise.resolve(null);
       streamBuffers = /* @__PURE__ */ new Map();
       warned = false;
+      /** Host-owned budget runtime (attached via attachBudgetRuntime). */
+      budgetRuntime = null;
+      /** 2.6 Track A: set once a task.contract has been seeded (or the log had one). */
+      contractSeeded = false;
       status = "disabled";
       /** Seq the log continued from when adopting an existing session. */
       resumedFromSeq;
@@ -31812,6 +32618,9 @@ var init_sessionSpine = __esm({
           const sessionDir = path21.join(mirror.sessionsDir, sessionId2);
           const report = await readSessionLog(path21.join(sessionDir, "events.jsonl"));
           const existed = report.events.length > 0 || report.issues.length > 0;
+          if (report.events.some((e) => e.kind === "task.contract" || e.kind === "user.message")) {
+            mirror.contractSeeded = true;
+          }
           const lastSeq = report.events[report.events.length - 1]?.seq ?? 0;
           mirror.writer = await SessionLogWriter.open(sessionDir, sessionId2, lastSeq + 1, {
             now: options.now
@@ -31828,6 +32637,16 @@ var init_sessionSpine = __esm({
               ...options.extraStarted
             }
           });
+          if (options.harnessManifest) {
+            await mirror.append({
+              kind: "session.harness_manifest",
+              actor: ACTOR_SYSTEM,
+              data: {
+                manifest: options.harnessManifest.manifest,
+                manifestHash: options.harnessManifest.manifestHash
+              }
+            });
+          }
           mirror.status = "active";
         } catch (err) {
           if (err instanceof SessionLogLockedError) {
@@ -31842,7 +32661,8 @@ var init_sessionSpine = __esm({
       }
       /** Log the user prompt — the P1 gap the 1.x log never closed. */
       userMessage(text) {
-        void this.append({ kind: "user.message", actor: ACTOR_USER, data: { text } });
+        const seqP = this.append({ kind: "user.message", actor: ACTOR_USER, data: { text } });
+        void seqP;
       }
       /**
        * Log an assistant message outside the streaming path — legacy
@@ -31857,6 +32677,45 @@ var init_sessionSpine = __esm({
         });
       }
       /** Await all pending appends (import → derive read-back needs this). */
+      /**
+       * Record the canonical harness manifest (2.6 Track A, doc section 6.5): one
+       * state-only event at session start / manifest change. Degrade-and-stop
+       * like every other mirror method - the spine never breaks the loop.
+       */
+      harnessManifest(manifest, manifestHash) {
+        void this.append({
+          kind: "session.harness_manifest",
+          actor: ACTOR_SYSTEM,
+          data: { manifest, manifestHash }
+        });
+      }
+      /**
+       * Attach the host-owned budget runtime (2.6 Track B, Phase 2/3). From here
+       * on every `tool.call` that lands on the spine is counted and — at §10.4
+       * frequency — a `resource.snapshot` event is appended right after it.
+       * Degrade-and-stop discipline applies: budget wiring never breaks a turn.
+       */
+      attachBudgetRuntime(runtime) {
+        this.budgetRuntime = runtime;
+      }
+      /** Latest emitted resource snapshot (the model-visible one), or null. */
+      latestResourceSnapshot() {
+        return this.budgetRuntime?.latestEmitted() ?? null;
+      }
+      /**
+       * §11.3 pre-dispatch gate for hosts that enforce the protected zone
+       * (Phase 3): delegates to the attached runtime, never throws. Null when
+       * no runtime is attached (hosts treat as "no budget info, allow").
+       */
+      gateResourceToolCall(toolName) {
+        const gate = this.budgetRuntime?.gateToolCall(toolName);
+        if (!gate) return null;
+        return { allowed: gate.allowed, ...gate.reason ? { reason: gate.reason } : {} };
+      }
+      /** Count a landed tool.call; returns the snapshot due (§10.4), if any. */
+      onToolCallBudget() {
+        return this.budgetRuntime?.noteToolCall() ?? null;
+      }
       async flush() {
         await this.chain;
       }
@@ -31961,7 +32820,31 @@ var init_sessionSpine = __esm({
       }
       append(input) {
         if (!this.writer || this.status === "closed") return Promise.resolve(null);
-        this.chain = this.chain.then(() => this.writer.append(input)).then((envelope) => envelope.seq).catch((err) => {
+        const dueSnapshot = input.kind === "tool.call" ? this.onToolCallBudget() : null;
+        const dueContract = input.kind === "user.message" && process.env.ZELARI_TASK_CONTRACT === "1" && !this.contractSeeded ? (this.contractSeeded = true, input.data?.text) : null;
+        let seq = this.chain.then(() => this.writer.append(input)).then((envelope) => envelope.seq);
+        if (dueSnapshot) {
+          seq = seq.then(
+            (s) => this.writer.append({ kind: "resource.snapshot", actor: ACTOR_SYSTEM, data: { ...dueSnapshot } }).then(() => s)
+          );
+        }
+        if (dueContract) {
+          seq = seq.then(async (s) => {
+            try {
+              const contract = deriveInitialContract(s ?? 1, dueContract);
+              if (contract) {
+                await this.writer.append({
+                  kind: "task.contract",
+                  actor: ACTOR_SYSTEM,
+                  data: { contract, kind: "task.contract" }
+                });
+              }
+            } catch {
+            }
+            return s;
+          });
+        }
+        this.chain = seq.catch((err) => {
           this.status = "degraded";
           this.writer = null;
           this.warnOnce(err);
@@ -33576,7 +34459,7 @@ var init_resolveStream = __esm({
 });
 
 // packages/core/dist/core/tools/toolOutputSpill.js
-import { createHash as createHash5, randomBytes as randomBytes2 } from "node:crypto";
+import { createHash as createHash6, randomBytes as randomBytes2 } from "node:crypto";
 import { existsSync as existsSync13, mkdirSync as mkdirSync7, writeFileSync as writeFileSync11 } from "node:fs";
 import { homedir as homedir3, tmpdir } from "node:os";
 import { join as join11 } from "node:path";
@@ -33606,14 +34489,14 @@ function spillToolOutput(fullText, meta3) {
     if (!existsSync13(dir)) {
       mkdirSync7(dir, { recursive: true });
     }
-    const hash3 = createHash5("sha256").update(fullText).digest("hex").slice(0, 12);
+    const hash3 = createHash6("sha256").update(fullText).digest("hex").slice(0, 12);
     const stamp = Date.now().toString(36);
     const rnd = randomBytes2(3).toString("hex");
     const safeTool = (meta3?.toolName ?? "tool").replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 32);
     const file2 = `${stamp}-${safeTool}-${hash3}-${rnd}.txt`;
-    const path64 = join11(dir, file2);
-    writeFileSync11(path64, fullText, "utf8");
-    return path64;
+    const path65 = join11(dir, file2);
+    writeFileSync11(path65, fullText, "utf8");
+    return path65;
   } catch {
     return null;
   }
@@ -33659,10 +34542,10 @@ function truncateToolResult(text, capOrOpts = TOOL_RESULT_LINE_CAP) {
 ${tail2}`;
   }
   if (doSpill) {
-    const path64 = spillToolOutput(text, { toolName: opts.toolName });
-    if (path64) {
+    const path65 = spillToolOutput(text, { toolName: opts.toolName });
+    if (path65) {
       const spillNote = `
-\u2026 [full output spilled to: ${path64} \u2014 re-read with read_file if you need the complete text] \u2026`;
+\u2026 [full output spilled to: ${path65} \u2014 re-read with read_file if you need the complete text] \u2026`;
       if (preview.includes("] \u2026\n")) {
         preview = preview.replace("] \u2026\n", `] \u2026${spillNote}
 `);
@@ -36078,7 +36961,7 @@ import {
 } from "node:fs";
 import { join as join13, basename } from "node:path";
 import { homedir as homedir5 } from "node:os";
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 function resolveWorkspaceRoot(projectRoot = process.cwd()) {
   const candidates = [
     join13(projectRoot, ".zelari"),
@@ -36094,7 +36977,7 @@ function resolveWorkspaceRoot(projectRoot = process.cwd()) {
   return candidates[0];
 }
 function hashProject(projectPath) {
-  return createHash6("sha1").update(realpathSync(projectPath)).digest("hex").slice(0, 12);
+  return createHash7("sha1").update(realpathSync(projectPath)).digest("hex").slice(0, 12);
 }
 function isWritableDir(dir) {
   try {
@@ -36408,28 +37291,28 @@ var init_storage = __esm({
     VALID_SCALARS = /^(true|false|null|~)$/i;
     Storage = class {
       /** Read a Markdown file with frontmatter. Throws if not found. */
-      read(path64) {
-        if (!existsSync19(path64)) {
-          throw new Error(`File not found: ${path64}`);
+      read(path65) {
+        if (!existsSync19(path65)) {
+          throw new Error(`File not found: ${path65}`);
         }
-        const md = readFileSync16(path64, "utf8");
+        const md = readFileSync16(path65, "utf8");
         return parseFrontmatter(md);
       }
       /** Read a Markdown file; returns null if not found. */
-      readIfExists(path64) {
-        if (!existsSync19(path64)) return null;
-        return this.read(path64);
+      readIfExists(path65) {
+        if (!existsSync19(path65)) return null;
+        return this.read(path65);
       }
       /**
        * Write a Markdown file atomically (tmp + rename). Creates parent dirs.
        * The meta object is serialized as YAML frontmatter; body as Markdown.
        */
-      write(path64, meta3, body) {
-        mkdirSync11(dirname2(path64), { recursive: true });
-        const tmp = path64 + ".tmp-" + process.pid;
+      write(path65, meta3, body) {
+        mkdirSync11(dirname2(path65), { recursive: true });
+        const tmp = path65 + ".tmp-" + process.pid;
         const md = serializeFrontmatter(meta3, body);
         writeFileSync13(tmp, md, "utf8");
-        renameSync2(tmp, path64);
+        renameSync2(tmp, path65);
       }
       /** List all .md files in a directory (non-recursive). */
       listMarkdown(dir) {
@@ -36491,8 +37374,8 @@ function nextPlanTaskId(store6) {
   return `t${store6.counter}`;
 }
 function writePlanTaskArtifact(rootDir, task) {
-  const path64 = join15(rootDir, "plan-tasks", `${task.id}.md`);
-  mkdirSync12(dirname3(path64), { recursive: true });
+  const path65 = join15(rootDir, "plan-tasks", `${task.id}.md`);
+  mkdirSync12(dirname3(path65), { recursive: true });
   const meta3 = {
     kind: "task",
     id: task.id,
@@ -36513,7 +37396,7 @@ function writePlanTaskArtifact(rootDir, task) {
     task.notes?.trim() ? task.notes.trim() : "_(no notes)_",
     ""
   ].filter((l) => l !== null).join("\n");
-  new Storage().write(path64, meta3, body);
+  new Storage().write(path65, meta3, body);
 }
 function loadHandle(rootDir) {
   const jsonPath = join15(rootDir, "plan.json");
@@ -36912,7 +37795,7 @@ var init_inspectTypecheckSafety = __esm({
 
 // src/cli/tools/inspectCommand.ts
 import { spawn as spawn7 } from "node:child_process";
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 import { existsSync as existsSync21, promises as fs17 } from "node:fs";
 import os8 from "node:os";
 import path30 from "node:path";
@@ -36999,7 +37882,7 @@ function buildInspectCommand(op, ctx) {
     }
     case "typecheck": {
       const project = path30.resolve(ctx.cwd, op.project ?? "tsconfig.json");
-      const hash3 = createHash7("sha256").update(project).digest("hex").slice(0, 16);
+      const hash3 = createHash8("sha256").update(project).digest("hex").slice(0, 16);
       const tsBuildInfoFile = path30.join(os8.tmpdir(), "zelari-inspect", `${hash3}.tsbuildinfo`);
       return {
         ok: true,
@@ -38438,9 +39321,9 @@ var init_store2 = __esm({
 import { promises as fs18, existsSync as existsSync22, readFileSync as readFileSync19 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
 import path33 from "node:path";
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 function getIndexPath(root) {
-  const hash3 = createHash8("sha1").update(path33.resolve(root)).digest("hex").slice(0, 16);
+  const hash3 = createHash9("sha1").update(path33.resolve(root)).digest("hex").slice(0, 16);
   return process.env.ZELARI_SEMANTIC_FILE ?? path33.join(homedir6(), ".tmp", "zelari-code", "semantic", `${hash3}.json`);
 }
 async function collectSourceFiles(root, maxFiles = 1500) {
@@ -39071,21 +39954,21 @@ function normalizeAuth(auth) {
   return "agent";
 }
 function readSecrets() {
-  const path64 = getSshSecretsPath();
-  if (!existsSync23(path64)) return {};
+  const path65 = getSshSecretsPath();
+  if (!existsSync23(path65)) return {};
   try {
-    return JSON.parse(readFileSync20(path64, "utf8"));
+    return JSON.parse(readFileSync20(path65, "utf8"));
   } catch {
     return {};
   }
 }
 function writeSecrets(data) {
-  const path64 = getSshSecretsPath();
-  mkdirSync13(dirname4(path64), { recursive: true });
-  writeFileSync15(path64, `${JSON.stringify(data, null, 2)}
+  const path65 = getSshSecretsPath();
+  mkdirSync13(dirname4(path65), { recursive: true });
+  writeFileSync15(path65, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   try {
-    chmodSync(path64, 384);
+    chmodSync(path65, 384);
   } catch {
   }
 }
@@ -39114,10 +39997,10 @@ function deleteSshPassword(id) {
   writeSecrets({ passwords });
 }
 function readStore2() {
-  const path64 = getSshTargetsPath();
-  if (!existsSync23(path64)) return [];
+  const path65 = getSshTargetsPath();
+  if (!existsSync23(path65)) return [];
   try {
-    const parsed = JSON.parse(readFileSync20(path64, "utf8"));
+    const parsed = JSON.parse(readFileSync20(path65, "utf8"));
     const list = Array.isArray(parsed.targets) ? parsed.targets : [];
     return list.filter(
       (t) => t && typeof t.id === "string" && typeof t.host === "string" && typeof t.user === "string"
@@ -39132,11 +40015,11 @@ function readStore2() {
   }
 }
 function writeStore2(targets) {
-  const path64 = getSshTargetsPath();
-  mkdirSync13(dirname4(path64), { recursive: true });
+  const path65 = getSshTargetsPath();
+  mkdirSync13(dirname4(path65), { recursive: true });
   const clean = targets.map(({ hasPassword: _hp, ...t }) => t);
   writeFileSync15(
-    path64,
+    path65,
     `${JSON.stringify({ targets: clean }, null, 2)}
 `,
     "utf8"
@@ -39382,11 +40265,11 @@ function formatSshTargetsForPrompt() {
   ];
   for (const t of targets) {
     const tags = t.tags?.length ? ` tags=[${t.tags.join(",")}]` : "";
-    const path64 = t.defaultRemotePath ? ` remotePath=${t.defaultRemotePath}` : "";
+    const path65 = t.defaultRemotePath ? ` remotePath=${t.defaultRemotePath}` : "";
     const allow = t.allowedCommands?.length ? ` allowed=${t.allowedCommands.join("|")}` : " allowed=status-only";
     const auth = t.auth === "password" ? " auth=password" : t.auth === "keyPath" ? " auth=key" : " auth=agent";
     lines.push(
-      `- id=${t.id} name=${t.name} ${t.user}@${t.host}:${t.port ?? 22}${auth}${path64}${tags}${allow}`
+      `- id=${t.id} name=${t.name} ${t.user}@${t.host}:${t.port ?? 22}${auth}${path65}${tags}${allow}`
     );
   }
   return lines.join("\n");
@@ -40064,7 +40947,7 @@ var init_lifecycleHooks = __esm({
 });
 
 // src/cli/toolResultCache.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 import { promises as fs20 } from "node:fs";
 import path39 from "node:path";
 function isToolCacheEnabled() {
@@ -40077,7 +40960,7 @@ function resolveToolCacheTtlMs() {
   return Number.isFinite(n) && n >= 0 ? n : TOOL_CACHE_DEFAULT_TTL_MS;
 }
 function hashKey(parts) {
-  return createHash9("sha256").update(JSON.stringify(parts), "utf8").digest("hex");
+  return createHash10("sha256").update(JSON.stringify(parts), "utf8").digest("hex");
 }
 function resultBytes(result) {
   try {
@@ -40832,7 +41715,7 @@ var init_toolRegistry = __esm({
 });
 
 // src/cli/state/fileStateStore.ts
-import { createHash as createHash11, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash12, randomUUID as randomUUID2 } from "node:crypto";
 import { promises as fs21 } from "node:fs";
 import * as path41 from "node:path";
 function shortId() {
@@ -40884,7 +41767,7 @@ async function getStateStore(projectRoot, env = process.env) {
   }
 }
 function hashStablePrompt(stable) {
-  return createHash11("sha256").update(stable, "utf8").digest("hex").slice(0, 16);
+  return createHash12("sha256").update(stable, "utf8").digest("hex").slice(0, 16);
 }
 var DEFAULT_MATERIALIZE_CHARS, FileDurableStateStore, NoopDurableStateStore;
 var init_fileStateStore = __esm({
@@ -41188,7 +42071,7 @@ function extractiveHistorySummary(dropped, opts) {
       if (m.toolCalls) {
         for (const tc of m.toolCalls) {
           tools.set(tc.name, (tools.get(tc.name) ?? 0) + 1);
-          collectPaths2(tc.args, files);
+          collectPaths3(tc.args, files);
         }
       }
     } else if (m.role === "tool") {
@@ -41248,7 +42131,7 @@ function oneLine(s, max) {
   if (t.length <= max) return t;
   return `${t.slice(0, max - 1)}\u2026`;
 }
-function collectPaths2(args, out) {
+function collectPaths3(args, out) {
   if (!args || typeof args !== "object") return;
   const obj = args;
   for (const key of ["path", "file", "filepath", "filePath", "target", "cwd"]) {
@@ -42241,6 +43124,7 @@ __export(headlessSpine_exports, {
   seedHeadlessModelHistory: () => seedHeadlessModelHistory,
   sessionStartedEvent: () => sessionStartedEvent
 });
+import path42 from "node:path";
 function sessionStartedEvent(handle) {
   return {
     type: "session_started",
@@ -42272,6 +43156,14 @@ async function openHeadlessSpine(opts) {
   };
   const spine = await SessionSpineMirror.adopt(opts.sessionId, mirrorOpts);
   if (spine.status === "active") {
+    const budget = new BudgetRuntime(profileId, { enforcement: resolveResourceEnforcement() });
+    if (spine.resumedFromSeq !== void 0 && spine.resumedFromSeq > 0) {
+      const prior = await readSessionLog(
+        path42.join(spine.sessionsDir, opts.sessionId, "events.jsonl")
+      ).catch(() => null);
+      if (prior) budget.adoptLedgerFromEvents(prior.events);
+    }
+    spine.attachBudgetRuntime(budget);
     spine.note("headless.profile", { profile: profileId, mode: opts.mode ?? "kraken" });
   }
   return {
@@ -42286,6 +43178,9 @@ async function openHeadlessSpine(opts) {
     userMessage(text) {
       spine.userMessage(text);
     },
+    gateResourceToolCall(toolName) {
+      return spine.gateResourceToolCall(toolName);
+    },
     verificationRun(payload) {
       spine.verificationRun(payload);
     },
@@ -42402,8 +43297,10 @@ var init_headlessSpine = __esm({
     init_dist();
     init_session();
     init_mission2();
+    init_session();
     init_runtime2();
     init_sessionSpine();
+    init_budgetRuntime();
     init_headless();
   }
 });
@@ -43329,8 +44226,8 @@ function readPlan(ctx) {
     } catch {
     }
   }
-  const path64 = workspaceFile(ctx.rootDir, "plan");
-  const doc = ctx.storage.readIfExists(path64);
+  const path65 = workspaceFile(ctx.rootDir, "plan");
+  const doc = ctx.storage.readIfExists(path65);
   if (!doc) return { phases: [], tasks: [], milestones: [] };
   const meta3 = doc.meta;
   return {
@@ -43508,7 +44405,7 @@ function addMilestoneRecord(ctx, summary, input) {
     dueDate: input.dueDate,
     targetVersion: version2
   });
-  const path64 = join25(ctx.rootDir, "milestones", `${id}.md`);
+  const path65 = join25(ctx.rootDir, "milestones", `${id}.md`);
   const meta3 = {
     kind: "milestone",
     id,
@@ -43525,7 +44422,7 @@ function addMilestoneRecord(ctx, summary, input) {
     `Target version: ${version2}`,
     ""
   ].join("\n");
-  ctx.storage.write(path64, meta3, body);
+  ctx.storage.write(path65, meta3, body);
   return { id, created: true };
 }
 function readPlanSummary(ctx) {
@@ -43729,7 +44626,7 @@ function addIdeaStub(ctx) {
         const tags = args["tags"] ?? [];
         const category = args["category"] ?? "General";
         const id = `${nextAdrId(ctx)}-${slugify3(title)}`;
-        const path64 = workspaceArtifact(ctx.rootDir, "decisions", id);
+        const path65 = workspaceArtifact(ctx.rootDir, "decisions", id);
         const meta3 = {
           kind: "adr",
           status: "proposed",
@@ -43755,7 +44652,7 @@ function addIdeaStub(ctx) {
           ...consequences.map((c) => `- ${c}`),
           ""
         ].join("\n");
-        ctx.storage.write(path64, meta3, body);
+        ctx.storage.write(path65, meta3, body);
         return `ADR ${id} created: "${title}". Status: proposed. Promote to accepted via /update ADR or manual edit.`;
       });
     }
@@ -43837,14 +44734,14 @@ function createDocumentStub(ctx) {
           ctx.storage.write(risksPath, riskMeta, content);
           return `Document "${title}" created at risks.md (workspace root).`;
         }
-        const path64 = workspaceArtifact(ctx.rootDir, "docs", slug);
+        const path65 = workspaceArtifact(ctx.rootDir, "docs", slug);
         const meta3 = {
           kind: "doc",
           id: slug,
           date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
           tags
         };
-        ctx.storage.write(path64, meta3, content);
+        ctx.storage.write(path65, meta3, content);
         return `Document "${title}" created at docs/${slug}.md.`;
       });
     }
@@ -44065,15 +44962,15 @@ __export(updater_exports, {
 import { createRequire as createRequire2 } from "node:module";
 import { spawn as spawn12 } from "node:child_process";
 import { existsSync as existsSync32 } from "node:fs";
-import path42 from "node:path";
+import path43 from "node:path";
 import { fileURLToPath } from "node:url";
 function resolveBundledNpmCli(execPath = process.execPath) {
-  const dir = path42.dirname(execPath);
+  const dir = path43.dirname(execPath);
   const candidates = [
     // Windows: C:\...\node.exe → C:\...\node_modules\npm\bin\npm-cli.js
-    path42.join(dir, "node_modules", "npm", "bin", "npm-cli.js"),
+    path43.join(dir, "node_modules", "npm", "bin", "npm-cli.js"),
     // POSIX: <prefix>/bin/node → <prefix>/lib/node_modules/npm/bin/npm-cli.js
-    path42.join(dir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")
+    path43.join(dir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")
   ];
   for (const candidate of candidates) {
     try {
@@ -44090,7 +44987,7 @@ function looksLikeBrokenShim(exitCode, output) {
 }
 function getCurrentVersion() {
   try {
-    const pkgPath = path42.resolve(__dirname2, "..", "..", "package.json");
+    const pkgPath = path43.resolve(__dirname2, "..", "..", "package.json");
     const pkg = require2(pkgPath);
     return pkg.version;
   } catch {
@@ -44213,7 +45110,7 @@ var init_updater = __esm({
     "use strict";
     init_cmdline();
     require2 = createRequire2(import.meta.url);
-    __dirname2 = path42.dirname(fileURLToPath(import.meta.url));
+    __dirname2 = path43.dirname(fileURLToPath(import.meta.url));
     REGISTRY_URL = "https://registry.npmjs.org/zelari-code/latest";
   }
 });
@@ -44401,10 +45298,10 @@ function getUserMcpPath() {
 function getProjectMcpPath(projectRoot) {
   return join26(projectRoot, ".zelari", "mcp.json");
 }
-function readFile3(path64) {
-  if (!existsSync33(path64)) return {};
+function readFile3(path65) {
+  if (!existsSync33(path65)) return {};
   try {
-    const parsed = JSON.parse(readFileSync28(path64, "utf8"));
+    const parsed = JSON.parse(readFileSync28(path65, "utf8"));
     const out = {};
     for (const [name, cfg] of Object.entries(parsed.mcpServers ?? {})) {
       if (!cfg || typeof cfg.command !== "string" || !cfg.command.trim()) continue;
@@ -44420,10 +45317,10 @@ function readFile3(path64) {
     return {};
   }
 }
-function writeFile(path64, servers) {
-  mkdirSync16(dirname7(path64), { recursive: true });
+function writeFile(path65, servers) {
+  mkdirSync16(dirname7(path65), { recursive: true });
   const body = { mcpServers: servers };
-  writeFileSync18(path64, `${JSON.stringify(body, null, 2)}
+  writeFileSync18(path65, `${JSON.stringify(body, null, 2)}
 `, "utf8");
 }
 function listMcpServers(projectRoot) {
@@ -44456,9 +45353,9 @@ function upsertMcpServer(opts) {
   if (!opts.config.command?.trim()) {
     return { ok: false, error: "command is required" };
   }
-  let path64;
+  let path65;
   if (opts.scope === "user") {
-    path64 = getUserMcpPath();
+    path65 = getUserMcpPath();
   } else {
     const root = opts.projectRoot?.trim();
     if (!root) {
@@ -44467,30 +45364,30 @@ function upsertMcpServer(opts) {
         error: "projectRoot required for project scope (Open Folder first)"
       };
     }
-    path64 = getProjectMcpPath(root);
+    path65 = getProjectMcpPath(root);
   }
-  const current = readFile3(path64);
+  const current = readFile3(path65);
   current[name] = {
     command: opts.config.command.trim(),
     args: opts.config.args,
     env: opts.config.env,
     enabled: opts.config.enabled !== false
   };
-  writeFile(path64, current);
-  return { ok: true, path: path64 };
+  writeFile(path65, current);
+  return { ok: true, path: path65 };
 }
 function removeMcpServer(opts) {
-  const path64 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
-  if (!path64) {
+  const path65 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
+  if (!path65) {
     return { ok: false, error: "projectRoot required for project scope" };
   }
-  const current = readFile3(path64);
+  const current = readFile3(path65);
   if (!(opts.name in current)) {
-    return { ok: false, error: `Server "${opts.name}" not found in ${path64}` };
+    return { ok: false, error: `Server "${opts.name}" not found in ${path65}` };
   }
   delete current[opts.name];
-  writeFile(path64, current);
-  return { ok: true, path: path64 };
+  writeFile(path65, current);
+  return { ok: true, path: path65 };
 }
 var init_mcpConfigIo = __esm({
   "src/cli/mcp/mcpConfigIo.ts"() {
@@ -44887,14 +45784,14 @@ __export(agentsMd_exports, {
   updateAgentsMd: () => updateAgentsMd
 });
 import { existsSync as existsSync35, readFileSync as readFileSync30, writeFileSync as writeFileSync19 } from "node:fs";
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 import { join as join28 } from "node:path";
 import { readFile as readFile4 } from "node:fs/promises";
 async function readPackageJson2(projectRoot) {
-  const path64 = join28(projectRoot, "package.json");
-  if (!existsSync35(path64)) return null;
+  const path65 = join28(projectRoot, "package.json");
+  if (!existsSync35(path65)) return null;
   try {
-    return JSON.parse(await readFile4(path64, "utf8"));
+    return JSON.parse(await readFile4(path65, "utf8"));
   } catch {
     return null;
   }
@@ -44976,9 +45873,9 @@ async function genBuild(ctx) {
   ].join("\n");
 }
 async function genOpenQuestions(ctx) {
-  const path64 = join28(ctx.rootDir, "risks.md");
-  if (!existsSync35(path64)) return "_No open questions._";
-  const content = readFileSync30(path64, "utf8");
+  const path65 = join28(ctx.rootDir, "risks.md");
+  if (!existsSync35(path65)) return "_No open questions._";
+  const content = readFileSync30(path65, "utf8");
   const lines = content.split("\n");
   const questions = [];
   let currentTitle = "";
@@ -45102,7 +45999,7 @@ async function updateAgentsMd(ctx, projectRoot) {
   return { changed: true, sections: changedSections };
 }
 function hash2(s) {
-  return createHash12("sha256").update(s).digest("hex").slice(0, 16);
+  return createHash13("sha256").update(s).digest("hex").slice(0, 16);
 }
 var AUTO_SECTIONS, MARKER_OPEN, MARKER_CLOSE, GENERATORS;
 var init_agentsMd = __esm({
@@ -45252,9 +46149,9 @@ function versionKey(value) {
 function firstString2(v) {
   return typeof v === "string" && v.trim().length > 0 ? v : null;
 }
-function readFileSyncSafe(path64) {
+function readFileSyncSafe(path65) {
   try {
-    return readFileSync31(path64, "utf8");
+    return readFileSync31(path65, "utf8");
   } catch {
     return null;
   }
@@ -45717,8 +46614,8 @@ async function runPostCouncilHook(ctx, options) {
           sources: scope.sources
         } : void 0
       });
-      const path64 = writeCouncilCompletion(ctx.rootDir, completion);
-      completionHook = { ran: true, path: path64, completion };
+      const path65 = writeCouncilCompletion(ctx.rootDir, completion);
+      completionHook = { ran: true, path: path65, completion };
     } catch (err) {
       completionHook = {
         ran: true,
@@ -45763,7 +46660,7 @@ import {
   writeFileSync as writeFileSync21,
   mkdirSync as mkdirSync17
 } from "node:fs";
-import path43 from "node:path";
+import path44 from "node:path";
 import os10 from "node:os";
 var FeedbackStore;
 var init_councilFeedback = __esm({
@@ -45774,7 +46671,7 @@ var init_councilFeedback = __esm({
       now;
       entries = [];
       constructor(options = {}) {
-        this.file = options.file ?? (process.env.ANATHEMA_COUNCIL_FEEDBACK_FILE ?? path43.join(os10.homedir(), ".tmp", "zelari-code", "council-feedback.json"));
+        this.file = options.file ?? (process.env.ANATHEMA_COUNCIL_FEEDBACK_FILE ?? path44.join(os10.homedir(), ".tmp", "zelari-code", "council-feedback.json"));
         this.now = options.now ?? Date.now;
         this.load();
       }
@@ -45880,7 +46777,7 @@ var init_councilFeedback = __esm({
         }
       }
       save() {
-        mkdirSync17(path43.dirname(this.file), { recursive: true });
+        mkdirSync17(path44.dirname(this.file), { recursive: true });
         writeFileSync21(
           this.file,
           JSON.stringify({ entries: this.entries }, null, 2),
@@ -45948,7 +46845,7 @@ import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
 import { mkdtempSync, rmSync as rmSync2 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import path44 from "node:path";
+import path45 from "node:path";
 import { randomUUID as randomUUID3 } from "node:crypto";
 async function git3(cwd, args, env) {
   const { stdout } = await execFileAsync2("git", ["-C", cwd, ...args], {
@@ -45968,8 +46865,8 @@ async function isGitRepo(cwd) {
   return await gitSafe(cwd, ["rev-parse", "--is-inside-work-tree"]) === "true";
 }
 async function withTempIndex(fn) {
-  const dir = mkdtempSync(path44.join(tmpdir2(), "zelari-ckpt-"));
-  const indexFile = path44.join(dir, "index");
+  const dir = mkdtempSync(path45.join(tmpdir2(), "zelari-ckpt-"));
+  const indexFile = path45.join(dir, "index");
   try {
     return await fn(indexFile);
   } finally {
@@ -46060,7 +46957,7 @@ async function restoreCheckpoint(cwd, id) {
     const deleted = [];
     for (const rel2 of added) {
       try {
-        rmSync2(path44.join(cwd, rel2), { force: true });
+        rmSync2(path45.join(cwd, rel2), { force: true });
         deleted.push(rel2);
       } catch {
       }
@@ -46161,7 +47058,7 @@ __export(fileBackend_exports, {
 });
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { promises as fs23 } from "node:fs";
-import * as path45 from "node:path";
+import * as path46 from "node:path";
 function tokenize(text) {
   return text.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((t) => t.length >= 3);
 }
@@ -46205,8 +47102,8 @@ var init_fileBackend = __esm({
       logPath = "";
       memoryDir = "";
       async init(projectRoot) {
-        this.memoryDir = path45.join(projectRoot, ".zelari", "memory");
-        this.logPath = path45.join(this.memoryDir, "log.jsonl");
+        this.memoryDir = path46.join(projectRoot, ".zelari", "memory");
+        this.logPath = path46.join(this.memoryDir, "log.jsonl");
         await fs23.mkdir(this.memoryDir, { recursive: true });
       }
       async add(content, metadata = {}, graph) {
@@ -46279,12 +47176,12 @@ var init_fileBackend = __esm({
 
 // src/cli/traceStore.ts
 import { promises as fs24 } from "node:fs";
-import * as path46 from "node:path";
+import * as path47 from "node:path";
 function traceDir(projectRoot) {
-  return path46.join(projectRoot, ".zelari", "trace");
+  return path47.join(projectRoot, ".zelari", "trace");
 }
 function tracePath(projectRoot, missionId) {
-  return path46.join(traceDir(projectRoot), `${missionId}.json`);
+  return path47.join(traceDir(projectRoot), `${missionId}.json`);
 }
 async function saveTrace(projectRoot, missionId, entries) {
   const dir = traceDir(projectRoot);
@@ -46319,7 +47216,7 @@ __export(zelariMission_exports, {
 });
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { promises as fs25 } from "node:fs";
-import * as path47 from "node:path";
+import * as path48 from "node:path";
 function resolveMaxIterations(env = process.env) {
   const raw = env.ZELARI_MISSION_MAX_ITER;
   const n = raw ? Number.parseInt(raw, 10) : DEFAULT_MAX_ITER;
@@ -46347,10 +47244,10 @@ function isMissionAutoStart(env = process.env) {
   return env.ZELARI_MISSION_AUTO === "1";
 }
 async function writeMissionState(projectRoot, state3) {
-  const dir = path47.join(projectRoot, ".zelari");
+  const dir = path48.join(projectRoot, ".zelari");
   await fs25.mkdir(dir, { recursive: true });
   await fs25.writeFile(
-    path47.join(dir, "mission-state.json"),
+    path48.join(dir, "mission-state.json"),
     JSON.stringify(state3, null, 2) + "\n",
     "utf8"
   );
@@ -46972,7 +47869,7 @@ function safeSocketPath(socketPath) {
   return socketPath.trim();
 }
 function startPermissionBroker(socketPath, handlers, opts) {
-  const path64 = safeSocketPath(socketPath);
+  const path65 = safeSocketPath(socketPath);
   const requestTimeoutMs = opts?.requestTimeoutMs ?? PERMISSION_BROKER_DEFAULT_TIMEOUT_MS;
   const sockets = /* @__PURE__ */ new Set();
   const server = createServer2((socket) => {
@@ -47072,10 +47969,10 @@ function startPermissionBroker(socketPath, handlers, opts) {
   return new Promise((resolve3, reject) => {
     const onError = (err) => reject(err);
     server.once("error", onError);
-    server.listen(path64, () => {
+    server.listen(path65, () => {
       server.removeListener("error", onError);
       resolve3({
-        socketPath: path64,
+        socketPath: path65,
         stop: () => new Promise((res) => {
           for (const s of sockets) s.destroy();
           sockets.clear();
@@ -47086,7 +47983,7 @@ function startPermissionBroker(socketPath, handlers, opts) {
             if (done) return;
             done = true;
             if (process.platform !== "win32") {
-              unlink(path64, () => res());
+              unlink(path65, () => res());
             } else {
               res();
             }
@@ -47099,11 +47996,11 @@ function startPermissionBroker(socketPath, handlers, opts) {
   });
 }
 function requestBrokerAsk(socketPath, ask, opts) {
-  const path64 = safeSocketPath(socketPath);
+  const path65 = safeSocketPath(socketPath);
   const requestTimeoutMs = opts?.requestTimeoutMs ?? PERMISSION_BROKER_DEFAULT_TIMEOUT_MS;
   const connectTimeoutMs = opts?.connectTimeoutMs ?? PERMISSION_BROKER_DEFAULT_CONNECT_TIMEOUT_MS;
   return new Promise((resolve3, reject) => {
-    const socket = connect(path64);
+    const socket = connect(path65);
     let buffer = "";
     let settled = false;
     const settle = (fn) => {
@@ -47118,7 +48015,7 @@ function requestBrokerAsk(socketPath, ask, opts) {
       settle(
         () => reject(
           new Error(
-            `permission broker unavailable at "${path64}" (connect timed out after ${connectTimeoutMs}ms)`
+            `permission broker unavailable at "${path65}" (connect timed out after ${connectTimeoutMs}ms)`
           )
         )
       );
@@ -47851,9 +48748,9 @@ __export(graphMemory_exports, {
   toGraphSnapshot: () => toGraphSnapshot
 });
 import { promises as fs26 } from "node:fs";
-import path49 from "node:path";
+import path50 from "node:path";
 function snapshotPath(cwd) {
-  return path49.join(cwd, SNAPSHOT_DIR, SNAPSHOT_FILE);
+  return path50.join(cwd, SNAPSHOT_DIR, SNAPSHOT_FILE);
 }
 function toGraphSnapshot(graph, opts) {
   const unresolved = (opts.unresolvedFindings ?? []).map((u) => ({
@@ -47880,7 +48777,7 @@ async function saveGraphSnapshot(cwd, snapshot) {
   try {
     await fs26.access(cwd);
     const file2 = snapshotPath(cwd);
-    await fs26.mkdir(path49.dirname(file2), { recursive: true });
+    await fs26.mkdir(path50.dirname(file2), { recursive: true });
     await fs26.writeFile(file2, JSON.stringify(snapshot, null, 2) + "\n", "utf8");
   } catch {
   }
@@ -47947,7 +48844,7 @@ var SNAPSHOT_DIR, SNAPSHOT_FILE, MAX_SNAPSHOT_FINDINGS_CHARS;
 var init_graphMemory = __esm({
   "src/cli/kraken/graphMemory.ts"() {
     "use strict";
-    SNAPSHOT_DIR = path49.join(".zelari", "kraken");
+    SNAPSHOT_DIR = path50.join(".zelari", "kraken");
     SNAPSHOT_FILE = "last-graph.json";
     MAX_SNAPSHOT_FINDINGS_CHARS = 400;
   }
@@ -47963,14 +48860,14 @@ var init_tentacle = __esm({
 
 // src/cli/kraken/workbench.ts
 import { promises as fs27 } from "node:fs";
-import path50 from "node:path";
+import path51 from "node:path";
 function isWorkbenchEnabled(env = process.env) {
   const v = (env.ZELARI_KRAKEN_WORKBENCH ?? "1").trim().toLowerCase();
   if (v === "0" || v === "false" || v === "no" || v === "off") return false;
   return true;
 }
 function workbenchPath(cwd, graphId) {
-  return path50.join(cwd, ".zelari", "radio", `workbench-${graphId}.md`);
+  return path51.join(cwd, ".zelari", "radio", `workbench-${graphId}.md`);
 }
 function countByStatus2(nodes) {
   const out = { pending: 0, running: 0, done: 0, error: 0, skipped: 0 };
@@ -48133,7 +49030,7 @@ var init_workbench = __esm({
         if (!this.enabled) return null;
         if (!this.dirty && this.lastWrite) return this.lastWrite;
         const out = workbenchPath(this.cwd, this.graphId);
-        await fs27.mkdir(path50.dirname(out), { recursive: true });
+        await fs27.mkdir(path51.dirname(out), { recursive: true });
         const body = this.render();
         const tmp = `${out}.${process.pid}.${Date.now()}.tmp`;
         await fs27.writeFile(tmp, body, "utf8");
@@ -48330,7 +49227,7 @@ __export(executor_exports, {
   thoroughnessForKind: () => thoroughnessForKind
 });
 import { existsSync as existsSync40 } from "node:fs";
-import path51 from "node:path";
+import path52 from "node:path";
 function resolveMaxParallel(env = process.env) {
   const raw = env.ZELARI_KRAKEN_MAX_PARALLEL;
   if (raw === void 0 || raw === "") return DEFAULT_MAX_PARALLEL;
@@ -48388,7 +49285,7 @@ function isWorldModelGateEnabled(cwd, env = process.env, checksExists = defaultC
 }
 function defaultChecksExists(cwd) {
   try {
-    return existsSync40(path51.join(cwd, ".zelari", "world", "checks.json"));
+    return existsSync40(path52.join(cwd, ".zelari", "world", "checks.json"));
   } catch {
     return false;
   }
@@ -49184,8 +50081,8 @@ ${upstream}` : node.prompt,
        * nodes that already exist, and the rewiring moves an existing edge forward
        * along the chain rather than back into it.
        */
-      spawnReworkPair(graph, writer, verify, findings, root, round) {
-        const reworkId = `rework-${root}-${round}`;
+      spawnReworkPair(graph, writer, verify, findings, root, round2) {
+        const reworkId = `rework-${root}-${round2}`;
         const reworkNode = {
           id: reworkId,
           kind: "fix",
@@ -49212,7 +50109,7 @@ ${findings || "(the reviewer reported FAIL without detail)"}`,
         const reVerifyNode = {
           id: reVerifyId,
           kind: "verify",
-          label: `verify: ${writer.label} (rework ${round})`,
+          label: `verify: ${writer.label} (rework ${round2})`,
           prompt: verify.prompt,
           deps: [reworkId],
           status: "pending",
@@ -49230,7 +50127,7 @@ ${findings || "(the reviewer reported FAIL without detail)"}`,
         this.radio("node_fix", {
           description: reworkNode.label,
           agent: "fix",
-          detail: `verify FAIL on "${writer.label}" \u2014 rework round ${round}/${this.maxReviewRounds}`,
+          detail: `verify FAIL on "${writer.label}" \u2014 rework round ${round2}/${this.maxReviewRounds}`,
           ok: false
         });
       }
@@ -49727,10 +50624,10 @@ var init_prereqChecks = __esm({
 
 // src/cli/plugins/prefs.ts
 import { existsSync as existsSync42, readFileSync as readFileSync35, writeFileSync as writeFileSync22, mkdirSync as mkdirSync18 } from "node:fs";
-import path54 from "node:path";
+import path55 from "node:path";
 import os11 from "node:os";
 function getPluginPrefsPath() {
-  return process.env.ZELARI_PLUGINS_PREFS_FILE ?? path54.join(os11.homedir(), ".tmp", "zelari-code", "plugins.json");
+  return process.env.ZELARI_PLUGINS_PREFS_FILE ?? path55.join(os11.homedir(), ".tmp", "zelari-code", "plugins.json");
 }
 function getPluginPrefs() {
   const file2 = getPluginPrefsPath();
@@ -49751,7 +50648,7 @@ function getPluginPrefs() {
 }
 function writePluginPrefs(prefs) {
   const file2 = getPluginPrefsPath();
-  mkdirSync18(path54.dirname(file2), { recursive: true });
+  mkdirSync18(path55.dirname(file2), { recursive: true });
   writeFileSync22(file2, JSON.stringify(prefs, null, 2), {
     encoding: "utf-8",
     mode: 384
@@ -49788,7 +50685,7 @@ __export(registry_exports, {
   isBinaryOnPath: () => isBinaryOnPath
 });
 import { existsSync as existsSync43 } from "node:fs";
-import path55 from "node:path";
+import path56 from "node:path";
 function detectLocalBin(bin) {
   return (cwd) => {
     try {
@@ -49806,7 +50703,7 @@ function isBinaryOnPath(bin, opts = {}) {
   const platform = opts.platform ?? process.platform;
   const exists = opts.exists ?? existsSync43;
   const pathEnv = opts.pathEnv ?? process.env.PATH ?? "";
-  const pathMod = platform === "win32" ? path55.win32 : path55.posix;
+  const pathMod = platform === "win32" ? path56.win32 : path56.posix;
   const sep2 = platform === "win32" ? ";" : ":";
   const dirs = pathEnv.split(sep2).filter((d) => d.length > 0);
   const candidates = [bin];
@@ -50753,6 +51650,7 @@ __export(policy_exports, {
   DEFAULT_MAX_ROUNDS: () => DEFAULT_MAX_ROUNDS,
   DEFAULT_WALL_MS: () => DEFAULT_WALL_MS,
   GAUNTLET_PARENT_BLOCKED_TOOLS: () => GAUNTLET_PARENT_BLOCKED_TOOLS,
+  budgetAwareGauntletGate: () => budgetAwareGauntletGate,
   isGauntletFlagOn: () => isGauntletFlagOn,
   resolveGauntletCaps: () => resolveGauntletCaps,
   shouldRunGauntletHostLoop: () => shouldRunGauntletHostLoop
@@ -50791,6 +51689,12 @@ function shouldRunGauntletHostLoop(opts) {
   const phase2 = opts.phase ?? "build";
   return phase2 !== "plan";
 }
+function budgetAwareGauntletGate(input) {
+  if (input.verdict === "PASS") return "proceed";
+  if (input.toolCallsRemaining <= input.verificationReserve) return "finalize-verify";
+  if (input.toolCallsRemaining <= 0) return "hold";
+  return "proceed";
+}
 var DEFAULT_MAX_PIECES, DEFAULT_MAX_ROUNDS, DEFAULT_MAX_PARALLEL2, DEFAULT_WALL_MS, GAUNTLET_PARENT_BLOCKED_TOOLS;
 var init_policy = __esm({
   "src/cli/gauntlet/policy.ts"() {
@@ -51169,9 +52073,9 @@ function builderUserPrompt(piece, gap, briefing) {
   parts.push("", "Return: files touched, what changed, residual risks.");
   return parts.join("\n");
 }
-function criticUserPrompt(piece, round, rand) {
+function criticUserPrompt(piece, round2, rand) {
   const parts = [
-    `Round ${round}. Inspect the current tree against this piece.`,
+    `Round ${round2}. Inspect the current tree against this piece.`,
     "Do not edit files. Do not take the builder's word \u2014 open files / run checks.",
     "",
     `## Piece: ${piece.label}`,
@@ -51285,9 +52189,9 @@ async function runGauntletLoop(args) {
     let winner;
     let rounds = 0;
     const i = Math.max(0, indexOf(piece));
-    for (let round = 1; round <= caps.maxRounds; round++) {
+    for (let round2 = 1; round2 <= caps.maxRounds; round2++) {
       if (stop()) break;
-      rounds = round;
+      rounds = round2;
       const phase2 = gap ? "repairing" : "building";
       emitProgress({
         phase: phase2,
@@ -51295,13 +52199,13 @@ async function runGauntletLoop(args) {
         pieceLabel: piece.label,
         pieceIndex: i,
         pieceCount: pieces.length,
-        round,
+        round: round2,
         maxRounds: caps.maxRounds
       });
       const built = await deps.runBuilder({
         piece,
         prompt: builderUserPrompt(piece, gap, deps.briefing),
-        round
+        round: round2
       });
       if (stop()) break;
       emitProgress({
@@ -51310,14 +52214,14 @@ async function runGauntletLoop(args) {
         pieceLabel: piece.label,
         pieceIndex: i,
         pieceCount: pieces.length,
-        round,
+        round: round2,
         maxRounds: caps.maxRounds
       });
       const criticized = await deps.runCritic({
         piece,
-        prompt: criticUserPrompt(piece, round),
+        prompt: criticUserPrompt(piece, round2),
         systemPrompt: GAUNTLET_CRITIC_SYSTEM,
-        round
+        round: round2
       });
       last = parseGauntletVerdict(criticized.result, {
         toolTraceCount: criticized.toolTraceCount ?? 0,
@@ -51331,7 +52235,7 @@ async function runGauntletLoop(args) {
         pieceLabel: piece.label,
         pieceIndex: i,
         pieceCount: pieces.length,
-        round,
+        round: round2,
         maxRounds: caps.maxRounds,
         verdict: last.kind,
         gap: last.gap,
@@ -51500,10 +52404,10 @@ async function runHeadlessGauntlet(opts, provider, model) {
         emit,
         briefing: workspace.slice(0, 1200),
         note: (text, data) => spine.note(text, data),
-        runBuilder: async ({ piece, prompt, round }) => {
+        runBuilder: async ({ piece, prompt, round: round2 }) => {
           emit({
             type: "log",
-            message: `[gauntlet] ${piece.id} round ${round}/${caps.maxRounds} builder`
+            message: `[gauntlet] ${piece.id} round ${round2}/${caps.maxRounds} builder`
           });
           const tent = await runTentacle({
             deps,
@@ -51513,7 +52417,7 @@ async function runHeadlessGauntlet(opts, provider, model) {
             sessionId: sessionId2,
             signal: abort.signal,
             args: {
-              description: `gauntlet-builder ${piece.id} r${round}`,
+              description: `gauntlet-builder ${piece.id} r${round2}`,
               prompt,
               ...piece.scope ? { scope: piece.scope } : {},
               ...piece.acceptance.length > 0 ? { acceptance: piece.acceptance } : {}
@@ -51526,10 +52430,10 @@ async function runHeadlessGauntlet(opts, provider, model) {
             toolTraceCount: tent.toolTrace?.length ?? 0
           };
         },
-        runCritic: async ({ piece, prompt, systemPrompt, round }) => {
+        runCritic: async ({ piece, prompt, systemPrompt, round: round2 }) => {
           emit({
             type: "log",
-            message: `[gauntlet] ${piece.id} round ${round}/${caps.maxRounds} critic`
+            message: `[gauntlet] ${piece.id} round ${round2}/${caps.maxRounds} critic`
           });
           const tent = await runTentacle({
             deps,
@@ -51540,7 +52444,7 @@ async function runHeadlessGauntlet(opts, provider, model) {
             signal: abort.signal,
             systemPromptOverride: systemPrompt,
             args: {
-              description: `gauntlet-critic ${piece.id} r${round}`,
+              description: `gauntlet-critic ${piece.id} r${round2}`,
               prompt,
               ...piece.scope ? { scope: piece.scope } : {},
               ...piece.acceptance.length > 0 ? { acceptance: piece.acceptance } : {}
@@ -51611,9 +52515,9 @@ __export(triggerLock_exports, {
   releaseLock: () => releaseLock
 });
 import { promises as fs35 } from "node:fs";
-import * as path60 from "node:path";
+import * as path61 from "node:path";
 function lockPath(projectRoot) {
-  return path60.join(projectRoot, ".zelari", "trigger.lock");
+  return path61.join(projectRoot, ".zelari", "trigger.lock");
 }
 function isPidAlive(pid) {
   try {
@@ -51626,7 +52530,7 @@ function isPidAlive(pid) {
 }
 async function acquireLock(projectRoot, now = () => /* @__PURE__ */ new Date()) {
   const lp = lockPath(projectRoot);
-  const dir = path60.dirname(lp);
+  const dir = path61.dirname(lp);
   await fs35.mkdir(dir, { recursive: true });
   try {
     const raw = await fs35.readFile(lp, "utf8");
@@ -52220,7 +53124,7 @@ function upsertSkill(opts) {
     }
     dir = getProjectSkillsDir(root);
   }
-  const path64 = skillFilePath(dir, name);
+  const path65 = skillFilePath(dir, name);
   const content = serializeSkillMd({
     name,
     description,
@@ -52229,13 +53133,13 @@ function upsertSkill(opts) {
     tools: opts.tools,
     cost: opts.cost
   });
-  const parsed = parseSkillMd(content, path64);
+  const parsed = parseSkillMd(content, path65);
   if (!parsed) {
     return { ok: false, error: "Generated SKILL.md failed validation" };
   }
-  mkdirSync21(dirname10(path64), { recursive: true });
-  writeFileSync24(path64, content, "utf8");
-  return { ok: true, path: path64 };
+  mkdirSync21(dirname10(path65), { recursive: true });
+  writeFileSync24(path65, content, "utf8");
+  return { ok: true, path: path65 };
 }
 function removeSkill(opts) {
   const name = opts.name.trim().toLowerCase();
@@ -52253,8 +53157,8 @@ function removeSkill(opts) {
     dir = getProjectSkillsDir(root);
   }
   const skillDir = join37(dir, name);
-  const path64 = skillFilePath(dir, name);
-  if (!existsSync48(path64) && !existsSync48(skillDir)) {
+  const path65 = skillFilePath(dir, name);
+  if (!existsSync48(path65) && !existsSync48(skillDir)) {
     return { ok: false, error: `Skill "${name}" not found in ${dir}` };
   }
   try {
@@ -52265,7 +53169,7 @@ function removeSkill(opts) {
       error: err instanceof Error ? err.message : String(err)
     };
   }
-  return { ok: true, path: path64 };
+  return { ok: true, path: path65 };
 }
 var NAME_RE, BUILTIN_SKILL_MODULES, builtinsLoaded;
 var init_skillConfigIo = __esm({
@@ -52566,7 +53470,7 @@ import {
 } from "node:fs";
 import { join as join38 } from "node:path";
 import { homedir as homedir13 } from "node:os";
-import { createHash as createHash13, randomBytes as randomBytes5, timingSafeEqual } from "node:crypto";
+import { createHash as createHash14, randomBytes as randomBytes5, timingSafeEqual } from "node:crypto";
 function getZelariHome() {
   return join38(homedir13(), ".zelari-code");
 }
@@ -52583,12 +53487,12 @@ function ensureHome() {
   }
 }
 function loadCompanionConfig() {
-  const path64 = getCompanionConfigPath();
-  if (!existsSync49(path64)) {
+  const path65 = getCompanionConfigPath();
+  if (!existsSync49(path65)) {
     return { projects: [] };
   }
   try {
-    const raw = JSON.parse(readFileSync39(path64, "utf8"));
+    const raw = JSON.parse(readFileSync39(path65, "utf8"));
     const projects = Array.isArray(raw.projects) ? raw.projects.filter(
       (p3) => p3 && typeof p3.path === "string" && p3.path.trim() && typeof (p3.id ?? p3.name) === "string"
     ).map((p3) => ({
@@ -52626,24 +53530,24 @@ function loadOrCreateToken(explicit) {
     return { token: explicit.trim(), created: false };
   }
   ensureHome();
-  const path64 = getCompanionTokenPath();
-  if (existsSync49(path64)) {
-    const t = readFileSync39(path64, "utf8").trim();
+  const path65 = getCompanionTokenPath();
+  if (existsSync49(path65)) {
+    const t = readFileSync39(path65, "utf8").trim();
     if (t) return { token: t, created: false };
   }
   const token = randomBytes5(24).toString("base64url");
-  writeFileSync25(path64, token + "\n", "utf8");
+  writeFileSync25(path65, token + "\n", "utf8");
   try {
     const fs37 = __require("node:fs");
-    fs37.chmodSync?.(path64, 384);
+    fs37.chmodSync?.(path65, 384);
   } catch {
   }
   return { token, created: true };
 }
 function tokenMatches(expected, provided) {
   if (!provided) return false;
-  const a = createHash13("sha256").update(expected).digest();
-  const b = createHash13("sha256").update(provided).digest();
+  const a = createHash14("sha256").update(expected).digest();
+  const b = createHash14("sha256").update(provided).digest();
   try {
     return timingSafeEqual(a, b);
   } catch {
@@ -52660,17 +53564,17 @@ function mergeProjects(cfg, extraPaths) {
     byId.set(p3.id, p3);
   }
   for (const raw of extraPaths) {
-    const path64 = raw.trim();
-    if (!path64) continue;
-    let id = slugFromPath(path64);
+    const path65 = raw.trim();
+    if (!path65) continue;
+    let id = slugFromPath(path65);
     let n = 2;
-    while (byId.has(id) && byId.get(id).path !== path64) {
-      id = `${slugFromPath(path64)}-${n++}`;
+    while (byId.has(id) && byId.get(id).path !== path65) {
+      id = `${slugFromPath(path65)}-${n++}`;
     }
     byId.set(id, {
       id,
-      name: slugFromPath(path64),
-      path: path64
+      name: slugFromPath(path65),
+      path: path65
     });
   }
   return [...byId.values()];
@@ -53047,9 +53951,9 @@ async function runCompanionServe(opts = {}) {
       return;
     }
     const url2 = parseUrl(req);
-    const path64 = url2.pathname.replace(/\/+$/, "") || "/";
+    const path65 = url2.pathname.replace(/\/+$/, "") || "/";
     try {
-      if (req.method === "GET" && (path64 === "/health" || path64 === "/v1/health")) {
+      if (req.method === "GET" && (path65 === "/health" || path65 === "/v1/health")) {
         sendJson2(res, 200, {
           ok: true,
           service: "zelari-companion",
@@ -53061,18 +53965,18 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (path64.startsWith("/v1")) {
+      if (path65.startsWith("/v1")) {
         if (!tokenMatches(token, getBearer(req))) {
           sendJson2(res, 401, { ok: false, error: "unauthorized" });
           return;
         }
       }
-      if (req.method === "GET" && path64 === "/v1/config") {
+      if (req.method === "GET" && path65 === "/v1/config") {
         const snap = buildDesktopConfigSnapshot();
         sendJson2(res, 200, { ok: true, ...snap });
         return;
       }
-      if (req.method === "GET" && path64 === "/v1/projects") {
+      if (req.method === "GET" && path65 === "/v1/projects") {
         sendJson2(res, 200, {
           ok: true,
           projects: projects.map((p3) => ({
@@ -53083,7 +53987,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "GET" && path64 === "/v1/runs") {
+      if (req.method === "GET" && path65 === "/v1/runs") {
         sendJson2(res, 200, {
           ok: true,
           active: runs.getActive(),
@@ -53101,7 +54005,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "POST" && path64 === "/v1/runs") {
+      if (req.method === "POST" && path65 === "/v1/runs") {
         const raw = await readBody(req);
         let body = {};
         try {
@@ -53148,7 +54052,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      const eventsMatch = /^\/v1\/runs\/([^/]+)\/events$/.exec(path64);
+      const eventsMatch = /^\/v1\/runs\/([^/]+)\/events$/.exec(path65);
       if (req.method === "GET" && eventsMatch) {
         const runId = eventsMatch[1];
         const run = runs.getRun(runId);
@@ -53213,7 +54117,7 @@ async function runCompanionServe(opts = {}) {
         }, 500);
         return;
       }
-      const cancelMatch = /^\/v1\/runs\/([^/]+)\/cancel$/.exec(path64);
+      const cancelMatch = /^\/v1\/runs\/([^/]+)\/cancel$/.exec(path65);
       if (req.method === "POST" && cancelMatch) {
         const runId = cancelMatch[1];
         const result = runs.cancel(runId);
@@ -53366,11 +54270,11 @@ import { execSync as execSync2 } from "node:child_process";
 import { existsSync as existsSync51, readFileSync as readFileSync40, readlinkSync, statSync as statSync10 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import path62 from "node:path";
+import path63 from "node:path";
 function findPackageRoot(start) {
   let dir = start;
   for (let i = 0; i < 6; i += 1) {
-    const candidate = path62.join(dir, "package.json");
+    const candidate = path63.join(dir, "package.json");
     if (existsSync51(candidate)) {
       try {
         const pkg = JSON.parse(readFileSync40(candidate, "utf8"));
@@ -53378,11 +54282,11 @@ function findPackageRoot(start) {
       } catch {
       }
     }
-    const parent = path62.dirname(dir);
+    const parent = path63.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path62.resolve(__dirname3, "..", "..", "..");
+  return path63.resolve(__dirname3, "..", "..", "..");
 }
 function tryExec(cmd) {
   try {
@@ -53396,7 +54300,7 @@ function tryExec(cmd) {
 }
 function readPackageJson3() {
   try {
-    const pkgPath = path62.join(packageRoot, "package.json");
+    const pkgPath = path63.join(packageRoot, "package.json");
     return JSON.parse(readFileSync40(pkgPath, "utf8"));
   } catch {
     return null;
@@ -53412,7 +54316,7 @@ function checkShim(pkgName) {
   }
   const isWin = process.platform === "win32";
   const shimName = isWin ? "zelari-code.cmd" : "zelari-code";
-  const shimPath = path62.join(prefix, shimName);
+  const shimPath = path63.join(prefix, shimName);
   if (!existsSync51(shimPath)) {
     return FAIL(
       `shim not found at ${shimPath}
@@ -53440,8 +54344,8 @@ function checkShim(pkgName) {
          fix:  npm install -g ${pkgName}@latest --force`
       );
     }
-    const resolved = path62.resolve(path62.dirname(shimPath), target);
-    const expected = path62.join(
+    const resolved = path63.resolve(path63.dirname(shimPath), target);
+    const expected = path63.join(
       prefix,
       "node_modules",
       pkgName,
@@ -53480,7 +54384,7 @@ function checkNode(pkg) {
   return OK(`node ${raw}`);
 }
 function checkBundle() {
-  const bundle = path62.join(packageRoot, "dist", "cli", "main.bundled.js");
+  const bundle = path63.join(packageRoot, "dist", "cli", "main.bundled.js");
   if (!existsSync51(bundle)) {
     return FAIL(
       `dist/cli/main.bundled.js missing at ${bundle}
@@ -53501,7 +54405,7 @@ function checkRuntimeDeps() {
   const missing = [];
   for (const dep of required2) {
     try {
-      const localReq = createRequire3(path62.join(packageRoot, "package.json"));
+      const localReq = createRequire3(path63.join(packageRoot, "package.json"));
       localReq.resolve(dep);
     } catch {
       missing.push(dep);
@@ -53701,7 +54605,7 @@ var init_doctor = __esm({
     init_metrics2();
     init_contextGrowthSummary();
     require3 = createRequire3(import.meta.url);
-    __dirname3 = path62.dirname(fileURLToPath2(import.meta.url));
+    __dirname3 = path63.dirname(fileURLToPath2(import.meta.url));
     packageRoot = findPackageRoot(__dirname3);
     OK = (message) => ({
       ok: true,
@@ -53885,15 +54789,15 @@ __export(inspect_exports, {
   collectInspectReport: () => collectInspectReport,
   runInspect: () => runInspect
 });
-import path63 from "node:path";
+import path64 from "node:path";
 import { existsSync as existsSync52, readFileSync as readFileSync41, readdirSync as readdirSync11 } from "node:fs";
 import { homedir as homedir14 } from "node:os";
 async function collectInspectReport(cwd = process.cwd()) {
   ensureBuiltinSkillsLoadedSync();
   const snap = listSkillsSnapshot(cwd);
   const mcp = listMcpServers(cwd);
-  const userMcpPath = path63.join(homedir14(), ".zelari-code", "mcp.json");
-  const projectMcpPath = path63.join(cwd, ".zelari", "mcp.json");
+  const userMcpPath = path64.join(homedir14(), ".zelari-code", "mcp.json");
+  const projectMcpPath = path64.join(cwd, ".zelari", "mcp.json");
   const globalHooks = globalHooksDir();
   const projectHooks = projectHooksDir(cwd);
   const projectTrusted = isFolderTrusted(cwd);
@@ -53921,9 +54825,9 @@ async function collectInspectReport(cwd = process.cwd()) {
     configSources: [
       { path: userMcpPath, exists: existsSync52(userMcpPath) },
       { path: projectMcpPath, exists: existsSync52(projectMcpPath) },
-      { path: path63.join(homedir14(), ".zelari-code", "provider.json"), exists: existsSync52(path63.join(homedir14(), ".zelari-code", "provider.json")) },
-      { path: path63.join(cwd, ".zelari", "AGENTS.md"), exists: existsSync52(path63.join(cwd, ".zelari", "AGENTS.md")) },
-      { path: path63.join(cwd, "AGENTS.md"), exists: existsSync52(path63.join(cwd, "AGENTS.md")) }
+      { path: path64.join(homedir14(), ".zelari-code", "provider.json"), exists: existsSync52(path64.join(homedir14(), ".zelari-code", "provider.json")) },
+      { path: path64.join(cwd, ".zelari", "AGENTS.md"), exists: existsSync52(path64.join(cwd, ".zelari", "AGENTS.md")) },
+      { path: path64.join(cwd, "AGENTS.md"), exists: existsSync52(path64.join(cwd, "AGENTS.md")) }
     ],
     skills: {
       total: snap.skills.length,
@@ -53963,8 +54867,8 @@ function listJsonFiles(dir) {
 }
 function findAgentsMd(cwd) {
   const candidates = [
-    path63.join(cwd, "AGENTS.md"),
-    path63.join(cwd, ".zelari", "AGENTS.md")
+    path64.join(cwd, "AGENTS.md"),
+    path64.join(cwd, ".zelari", "AGENTS.md")
   ];
   const found = [];
   for (const c of candidates) {
@@ -57239,7 +58143,7 @@ init_completionGate();
 // src/cli/kraken/verificationBridge.ts
 init_candidateRegistry();
 init_completionGate();
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 
 // src/cli/kraken/nativeVerification.ts
 init_runtime2();
@@ -57366,7 +58270,7 @@ function krakenResultsToContract(requiredChecks, results, now = Date.now()) {
   return { criteria, results: verifications };
 }
 function sha256Hex2(input) {
-  return createHash10("sha256").update(input).digest("hex");
+  return createHash11("sha256").update(input).digest("hex");
 }
 function matchNoteToToolTrace(note, trace) {
   const n = normalize5(note);
@@ -58013,10 +58917,14 @@ function compactEventPayload(budget, stateSnapshot, telemetry) {
 
 // src/cli/budget/modelContextBuilder.ts
 init_headlessSpine();
+init_session();
 function messageWasRecompacted(message, history2) {
   if (message.compactedFromSeq === void 0) return false;
   return !history2.some((candidate) => candidate.seq !== void 0 && candidate.seq === message.seq);
 }
+function resourceStatusMessage(payload) {
+  return { role: "system", content: formatResourceSnapshot(payload) };
+}
 async function sessionHistory(session) {
   if (!session || session.status !== "active") return null;
   const derived = await session.derivedPriorTurns();
@@ -58083,6 +58991,9 @@ async function buildModelContext(input) {
     };
     input.onCompactionMetric?.(compactionMetrics);
   }
+  if (input.resourceSnapshot) {
+    history2 = [...history2, resourceStatusMessage(input.resourceSnapshot)];
+  }
   if (requestSurface) {
     const measured = measureRequest({
       systemMessages: requestSurface.systemMessages,
@@ -58287,6 +59198,7 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
         const modelContext = await buildModelContext({
           fallbackHistory: historyForModel,
           session: writerRef.current?.spine ?? null,
+          resourceSnapshot: writerRef.current?.spine?.latestResourceSnapshot() ?? null,
           phase: workPhase,
           model: getActiveModel(),
           provider: envConfig?.providerId ?? (localCli || "local"),
@@ -58512,6 +59424,9 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
           })),
           toolRegistry,
           providerStream,
+          // 2.6 Phase 3: host-owned pre-dispatch resource gate via the spine
+          // mirror (doc section 11.3). Degrade-and-stop (null gate = allow).
+          toolCallGate: (name) => writerRef.current?.spine?.gateResourceToolCall(name) ?? { allowed: true },
           cwd,
           maxToolCallsPerTurn,
           maxToolLoopIterations,
@@ -60583,7 +61498,7 @@ init_sessionManager();
 // src/cli/gitOps.ts
 import { execFile as execFile4 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
-import path48 from "node:path";
+import path49 from "node:path";
 var execFileAsync3 = promisify3(execFile4);
 async function git4(cwd, args) {
   try {
@@ -60629,7 +61544,7 @@ async function undoWorkingChanges(opts = {}) {
   };
 }
 function defaultProjectRoot() {
-  return path48.resolve(__dirname, "..", "..", "..");
+  return path49.resolve(__dirname, "..", "..", "..");
 }
 
 // src/cli/slashHandlers/git.ts
@@ -61081,7 +61996,7 @@ import { promises as fs29 } from "node:fs";
 init_zod();
 init_taskTool();
 import { promises as fs28 } from "node:fs";
-import path52 from "node:path";
+import path53 from "node:path";
 import { randomBytes as randomBytes4 } from "node:crypto";
 var CsvFanoutArgsSchema = external_exports.object({
   csv_path: external_exports.string().min(1),
@@ -61175,8 +62090,8 @@ function resolveMaxConcurrency(env = process.env) {
 }
 async function runCsvFanout(args, deps, opts) {
   const start = Date.now();
-  const absCsv = path52.isAbsolute(args.csv_path) ? args.csv_path : path52.join(opts.parentCwd, args.csv_path);
-  const absOut = path52.isAbsolute(args.output_csv_path) ? args.output_csv_path : path52.join(opts.parentCwd, args.output_csv_path);
+  const absCsv = path53.isAbsolute(args.csv_path) ? args.csv_path : path53.join(opts.parentCwd, args.csv_path);
+  const absOut = path53.isAbsolute(args.output_csv_path) ? args.output_csv_path : path53.join(opts.parentCwd, args.output_csv_path);
   const { headers: headers2, rows } = await readCsv(absCsv);
   if (headers2.length === 0) {
     throw new Error(`kraken_csv_fanout: ${absCsv} is empty`);
@@ -61232,7 +62147,7 @@ async function runCsvFanout(args, deps, opts) {
         errored += 1;
         errors.push(`${row[args.id_column] ?? i}: ${res.error}`);
       }
-      await fs28.mkdir(path52.dirname(absOut), { recursive: true });
+      await fs28.mkdir(path53.dirname(absOut), { recursive: true });
       await queueWrite(serializeCsv(outHeaders, outputRecords));
     }
   }
@@ -61427,7 +62342,7 @@ function splitArgs(s) {
 // src/cli/slashHandlers/krakenWorkbench.ts
 init_messageHelpers();
 import { promises as fs30 } from "node:fs";
-import path53 from "node:path";
+import path54 from "node:path";
 
 // src/cli/kraken/workbenchView.ts
 var EMPTY = {
@@ -61544,14 +62459,14 @@ function formatWorkbenchForTerminal(p3) {
 
 // src/cli/slashHandlers/krakenWorkbench.ts
 async function handleKrakenWorkbench(ctx) {
-  const dir = path53.join(ctx.cwd, ".zelari", "radio");
+  const dir = path54.join(ctx.cwd, ".zelari", "radio");
   let latest = null;
   let latestMtime = 0;
   try {
     const files = await fs30.readdir(dir);
     for (const f of files) {
       if (!f.startsWith("workbench-") || !f.endsWith(".md")) continue;
-      const full = path53.join(dir, f);
+      const full = path54.join(dir, f);
       const stat = await fs30.stat(full);
       if (stat.mtimeMs > latestMtime) {
         latestMtime = stat.mtimeMs;
@@ -61568,10 +62483,10 @@ async function handleKrakenWorkbench(ctx) {
   const parsed = parseWorkbench(content);
   const rendered = formatWorkbenchForTerminal(parsed);
   if (!rendered.trim()) {
-    appendSystem(ctx.setMessages, `[kraken workbench] ${path53.basename(latest)}: (no nodes / no events yet)`);
+    appendSystem(ctx.setMessages, `[kraken workbench] ${path54.basename(latest)}: (no nodes / no events yet)`);
     return;
   }
-  appendSystem(ctx.setMessages, `[kraken workbench] ${path53.basename(latest)}:
+  appendSystem(ctx.setMessages, `[kraken workbench] ${path54.basename(latest)}:
 ${rendered}`);
 }
 
@@ -61878,15 +62793,15 @@ ${result.output.split("\n").slice(-8).join("\n")}` : "";
 // src/cli/slashHandlers/promoteMember.ts
 init_messageHelpers();
 import { promises as fs31 } from "node:fs";
-import path56 from "node:path";
+import path57 from "node:path";
 import os12 from "node:os";
 async function handlePromoteMember(ctx, memberId) {
   try {
     const { promoteMember: promoteMember2 } = await Promise.resolve().then(() => (init_council(), council_exports));
     const { skill, markdown } = promoteMember2(memberId);
-    const skillDir = process.env.ANATHEMA_SKILL_DIR ?? path56.join(os12.homedir(), ".tmp", "zelari-code", "skills");
+    const skillDir = process.env.ANATHEMA_SKILL_DIR ?? path57.join(os12.homedir(), ".tmp", "zelari-code", "skills");
     await fs31.mkdir(skillDir, { recursive: true });
-    const filePath = path56.join(skillDir, `${skill.id}.md`);
+    const filePath = path57.join(skillDir, `${skill.id}.md`);
     await fs31.writeFile(filePath, markdown, "utf8");
     appendSystem(
       ctx.setMessages,
@@ -61904,24 +62819,24 @@ async function handlePromoteMember(ctx, memberId) {
 
 // src/cli/branchManager.ts
 import { promises as fs32, existsSync as existsSync44, readFileSync as readFileSync36, writeFileSync as writeFileSync23, mkdirSync as mkdirSync19, statSync as statSync7, rmSync as rmSync3 } from "node:fs";
-import path57 from "node:path";
+import path58 from "node:path";
 import os13 from "node:os";
 var META_FILENAME = "meta.json";
 var SESSIONS_SUBDIR = "sessions";
 function getBranchesBaseDir() {
-  return process.env.ANATHEMA_BRANCHES_DIR ?? path57.join(os13.homedir(), ".tmp", "zelari-code", "branches");
+  return process.env.ANATHEMA_BRANCHES_DIR ?? path58.join(os13.homedir(), ".tmp", "zelari-code", "branches");
 }
 function getSessionsBaseDir() {
-  return process.env.ANATHEMA_SESSIONS_DIR ?? path57.join(os13.homedir(), ".tmp", "zelari-code", "sessions");
+  return process.env.ANATHEMA_SESSIONS_DIR ?? path58.join(os13.homedir(), ".tmp", "zelari-code", "sessions");
 }
 function branchPathFor(name, baseDir) {
-  return path57.join(baseDir, name);
+  return path58.join(baseDir, name);
 }
 function metaPathFor(name, baseDir) {
-  return path57.join(baseDir, name, META_FILENAME);
+  return path58.join(baseDir, name, META_FILENAME);
 }
 function sessionsPathFor(name, baseDir) {
-  return path57.join(baseDir, name, SESSIONS_SUBDIR);
+  return path58.join(baseDir, name, SESSIONS_SUBDIR);
 }
 function readBranchMeta(name, baseDir) {
   const metaPath = metaPathFor(name, baseDir);
@@ -61946,7 +62861,7 @@ function readBranchMeta(name, baseDir) {
 }
 function writeBranchMeta(name, baseDir, meta3) {
   const metaPath = metaPathFor(name, baseDir);
-  mkdirSync19(path57.dirname(metaPath), { recursive: true });
+  mkdirSync19(path58.dirname(metaPath), { recursive: true });
   writeFileSync23(metaPath, JSON.stringify(meta3, null, 2), "utf-8");
 }
 async function countSessions(name, baseDir) {
@@ -61997,14 +62912,14 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
   if (branchExists(name, baseDir)) {
     throw new BranchAlreadyExistsError(name);
   }
-  const sourcePath = path57.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
+  const sourcePath = path58.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
   if (!existsSync44(sourcePath)) {
     throw new SessionNotFoundError(`Source session "${fromSessionId}" not found at ${sourcePath}`);
   }
   const branchPath = branchPathFor(name, baseDir);
   const branchSessionsPath = sessionsPathFor(name, baseDir);
   mkdirSync19(branchSessionsPath, { recursive: true });
-  const destPath = path57.join(branchSessionsPath, `${fromSessionId}.jsonl`);
+  const destPath = path58.join(branchSessionsPath, `${fromSessionId}.jsonl`);
   await fs32.copyFile(sourcePath, destPath);
   const meta3 = {
     name,
@@ -62108,14 +63023,14 @@ async function handleBranchCheckout(ctx, branchName) {
 // src/cli/slashHandlers/workspace.ts
 init_messageHelpers();
 import { promises as fs33 } from "node:fs";
-import path58 from "node:path";
+import path59 from "node:path";
 async function handleWorkspaceShow(ctx, what) {
   try {
-    const zelari = path58.join(process.cwd(), ".zelari");
+    const zelari = path59.join(process.cwd(), ".zelari");
     let content;
     switch (what) {
       case "plan": {
-        const planPath = path58.join(zelari, "plan.md");
+        const planPath = path59.join(zelari, "plan.md");
         try {
           content = await fs33.readFile(planPath, "utf-8");
         } catch {
@@ -62124,7 +63039,7 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "decisions": {
-        const decisionsDir = path58.join(zelari, "decisions");
+        const decisionsDir = path59.join(zelari, "decisions");
         try {
           const files = (await fs33.readdir(decisionsDir)).filter((f) => f.endsWith(".md")).sort();
           if (files.length === 0) {
@@ -62134,7 +63049,7 @@ async function handleWorkspaceShow(ctx, what) {
 `];
             const { parseFrontmatter: parseFrontmatter2 } = await Promise.resolve().then(() => (init_storage(), storage_exports));
             for (const f of files) {
-              const raw = await fs33.readFile(path58.join(decisionsDir, f), "utf-8");
+              const raw = await fs33.readFile(path59.join(decisionsDir, f), "utf-8");
               const { meta: meta3, body } = parseFrontmatter2(raw);
               const title = meta3.title ?? body.split("\n")[0]?.replace(/^#\s*/, "").trim() ?? f;
               lines.push(`- **${f.replace(/\.md$/, "")}** [${meta3.status ?? "unknown"}] ${title}`);
@@ -62147,7 +63062,7 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "risks": {
-        const risksPath = path58.join(zelari, "risks.md");
+        const risksPath = path59.join(zelari, "risks.md");
         try {
           content = await fs33.readFile(risksPath, "utf-8");
         } catch {
@@ -62156,7 +63071,7 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "agents": {
-        const agentsPath = path58.join(process.cwd(), "AGENTS.MD");
+        const agentsPath = path59.join(process.cwd(), "AGENTS.MD");
         try {
           content = await fs33.readFile(agentsPath, "utf-8");
         } catch {
@@ -62165,7 +63080,7 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "docs": {
-        const docsDir = path58.join(zelari, "docs");
+        const docsDir = path59.join(zelari, "docs");
         try {
           const files = (await fs33.readdir(docsDir)).filter((f) => f.endsWith(".md")).sort();
           content = files.length ? `# Docs (${files.length})
@@ -62207,7 +63122,7 @@ async function handleWorkspaceReset(ctx, force) {
     return;
   }
   try {
-    const target = path58.join(process.cwd(), ".zelari");
+    const target = path59.join(process.cwd(), ".zelari");
     await fs33.rm(target, { recursive: true, force: true });
     appendSystem(ctx.setMessages, "[workspace] .zelari/ removed");
   } catch (err) {
@@ -62219,7 +63134,7 @@ async function handleWorkspaceReset(ctx, force) {
 init_provider2();
 
 // src/cli/slashHandlers/skills.ts
-import path59 from "node:path";
+import path60 from "node:path";
 import os14 from "node:os";
 
 // src/cli/skillHistory.ts
@@ -62348,7 +63263,7 @@ function handleSkillPicker(ctx, skills, openPicker, fallbackMessage) {
   });
 }
 async function handleSkillStats(ctx, skillId) {
-  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path59.join(os14.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
+  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path60.join(os14.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
   try {
     const records = await readSkillHistory(historyFile);
     const stats = getSkillStats(records, skillId);
@@ -62364,7 +63279,7 @@ async function handleSkillCompare(ctx, ids, fallbackMessage) {
     appendSystem(ctx.setMessages, fallbackMessage ?? "[skill-compare] missing args");
     return;
   }
-  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path59.join(os14.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
+  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path60.join(os14.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
   try {
     const formatted = await compareSkillsFromFile(ids[0], ids[1], historyFile);
     appendSystem(ctx.setMessages, formatted);
@@ -63908,7 +64823,7 @@ function createStreamScrubber2() {
 init_taskTool();
 init_sessionTodos();
 import { promises as fs36 } from "node:fs";
-import path61 from "node:path";
+import path62 from "node:path";
 import { randomUUID as randomUUID6 } from "node:crypto";
 
 // src/cli/kraken/verifierLifecycle.ts
@@ -64165,7 +65080,7 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
   try {
     let preflightGraph;
     if (opts.runPlan && opts.runPlan.trim() !== "") {
-      const planPath = path61.join(cwd, ".zelari", "radio", `plan-${opts.runPlan}.json`);
+      const planPath = path62.join(cwd, ".zelari", "radio", `plan-${opts.runPlan}.json`);
       log(`loading pre-flight plan: ${planPath}`);
       let raw;
       try {
@@ -64205,8 +65120,8 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
     log(formatKrakenGraphAscii2(graph));
     if (opts.planOnly) {
       const planId = randomUUID6();
-      const planDir = path61.join(cwd, ".zelari", "radio");
-      const planPath = path61.join(planDir, `plan-${planId}.json`);
+      const planDir = path62.join(cwd, ".zelari", "radio");
+      const planPath = path62.join(planDir, `plan-${planId}.json`);
       await fs36.mkdir(planDir, { recursive: true });
       await fs36.writeFile(
         planPath,
@@ -64485,6 +65400,7 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
   const modelContext = await buildModelContext({
     fallbackHistory: seededHistory.history,
     session: spine.spine,
+    resourceSnapshot: spine.spine.latestResourceSnapshot(),
     phase: opts.phase ?? "build",
     model,
     provider,
@@ -64524,6 +65440,10 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
       tools,
       toolRegistry,
       providerStream,
+      // 2.6 Phase 3: host-owned pre-dispatch resource gate (doc section 11.3).
+      // Advisory by default; ZELARI_RESOURCE_ENFORCEMENT=protected enables the
+      // protected verification reserve. Degrade-and-stop (null gate = allow).
+      toolCallGate: (name) => spine.gateResourceToolCall(name) ?? { allowed: true },
       maxToolLoopIterations: maxToolLoop
     });
     let finalReason = "completed";
@@ -64765,7 +65685,7 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
       if (json2) {
         if (opts.exportSessionPath === "-") process.stdout.write(json2 + "\n");
         else {
-          await fs36.mkdir(path61.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+          await fs36.mkdir(path62.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
           await fs36.writeFile(opts.exportSessionPath, json2, "utf8");
         }
       }
@@ -64949,7 +65869,7 @@ async function runHeadlessCouncil(opts, provider, model, providerStream) {
       if (json2) {
         if (opts.exportSessionPath === "-") process.stdout.write(json2 + "\n");
         else {
-          await fs36.mkdir(path61.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+          await fs36.mkdir(path62.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
           await fs36.writeFile(opts.exportSessionPath, json2, "utf8");
         }
       }
@@ -65313,7 +66233,7 @@ ${ragContext}` : slicePrompt;
         if (json2) {
           if (opts.exportSessionPath === "-") process.stdout.write(json2 + "\n");
           else {
-            await fs36.mkdir(path61.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+            await fs36.mkdir(path62.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
             await fs36.writeFile(opts.exportSessionPath, json2, "utf8");
           }
         }
@@ -65515,8 +66435,8 @@ function normalizeDraft(raw, sourceUrl, provider, model) {
   let name = String(o.name ?? "").trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
   if (!name || !/^[a-z0-9][a-z0-9-]{0,63}$/.test(name)) {
     try {
-      const path64 = new URL(sourceUrl).pathname.split("/").filter(Boolean).pop()?.replace(/\.[a-z0-9]+$/i, "").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
-      name = path64 && /^[a-z0-9]/.test(path64) ? path64 : "imported-skill";
+      const path65 = new URL(sourceUrl).pathname.split("/").filter(Boolean).pop()?.replace(/\.[a-z0-9]+$/i, "").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+      name = path65 && /^[a-z0-9]/.test(path65) ? path65 : "imported-skill";
     } catch {
       name = "imported-skill";
     }