zelari-code 2.6.0 → 2.6.2

package/dist/cli/main.bundled.js

@@ -28340,6 +28340,9 @@ var init_types8 = __esm({
       // once at session start / manifest change. State-only (never model-surface):
       // data = {manifest, manifestHash}. Schema review per ADR-0021.
       "session.harness_manifest",
+      // 2.6.1 (closure plan §6): resume-time harness drift record. State-only:
+      // data = {originalManifestHash, currentManifestHash}. Non-blocking signal.
+      "session.harness_drift",
       "user.message",
       "assistant.message",
       "tool.call",
@@ -28370,9 +28373,12 @@ var init_types8 = __esm({
       // 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.epoch_started",
       "resource.snapshot",
       "resource.limit_reached",
       "resource.reserve_entered",
+      // 2.6.1 (closure plan §9): hard-limit overrun telemetry — state-only.
+      "resource.overrun",
       "note"
     ];
     SessionEventEnvelopeSchema = external_exports.object({
@@ -28703,11 +28709,19 @@ function asNumber(value) {
 function formatResourceSnapshot(data) {
   const used = asNumber(data.toolCallsUsed) ?? 0;
   const remaining = asNumber(data.toolCallsRemaining) ?? 0;
+  const limit = asNumber(data.toolCallsLimit) ?? used + remaining;
   const lines = [
     "RESOURCE STATUS",
-    `Tool calls: ${used} / ${used + remaining}`,
+    `Tool calls: ${used} / ${limit}`,
     `Remaining: ${remaining}`
   ];
+  const sessionUsed = asNumber(data.sessionToolCallsUsed);
+  if (sessionUsed !== void 0 && sessionUsed !== used) {
+    lines.push(`Session total: ${sessionUsed}`);
+  }
+  const overrun = asNumber(data.overrun);
+  if (overrun !== void 0 && overrun > 0)
+    lines.push(`Overrun: ${overrun}`);
   const wall = asNumber(data.wallMsRemaining);
   if (wall !== void 0)
     lines.push(`Wall clock remaining: ${Math.max(0, Math.round(wall / 1e3))}s`);
@@ -29595,7 +29609,24 @@ function pushCompactionViolations(events, knownSeq, pairs, violations) {
 function validateResourceAndContractEvents(events) {
   const violations = [];
   let lastToolCallsUsed = -1;
+  let lastEpoch = 0;
+  let activeEpoch = 0;
+  let lastSessionToolCallsUsed = -1;
   for (const e of events) {
+    if (e.kind === "resource.epoch_started") {
+      const epoch = e.data.epoch;
+      if (typeof epoch !== "number" || !Number.isInteger(epoch) || epoch <= lastEpoch) {
+        violations.push({
+          code: "RESOURCE_EPOCH_MONOTONIC",
+          seq: e.seq,
+          message: `resource epoch ${String(epoch)} did not increase past ${lastEpoch}`
+        });
+      } else {
+        lastEpoch = epoch;
+        activeEpoch = epoch;
+      }
+      lastToolCallsUsed = -1;
+    }
     if (e.kind === "resource.snapshot") {
       const used = e.data.toolCallsUsed;
       const remaining = e.data.toolCallsRemaining;
@@ -29607,9 +29638,41 @@ function validateResourceAndContractEvents(events) {
         violations.push({ code: "RESOURCE_USED_MONOTONIC", seq: e.seq, message: `toolCallsUsed went ${lastToolCallsUsed} -> ${used}` });
       }
       lastToolCallsUsed = used;
+      const epoch = e.data.epoch;
+      if (epoch !== void 0 && (typeof epoch !== "number" || !Number.isInteger(epoch) || epoch !== activeEpoch)) {
+        violations.push({
+          code: "RESOURCE_SNAPSHOT_EPOCH_MISMATCH",
+          seq: e.seq,
+          message: `snapshot epoch ${String(epoch)} does not match active epoch ${activeEpoch}`
+        });
+      }
+      const sessionUsed = e.data.sessionToolCallsUsed;
+      if (sessionUsed !== void 0) {
+        if (typeof sessionUsed !== "number" || !Number.isInteger(sessionUsed) || sessionUsed < used) {
+          violations.push({
+            code: "RESOURCE_SESSION_USAGE_INVALID",
+            seq: e.seq,
+            message: `sessionToolCallsUsed(${String(sessionUsed)}) must be an integer >= epoch used(${used})`
+          });
+        } else if (sessionUsed < lastSessionToolCallsUsed) {
+          violations.push({
+            code: "RESOURCE_SESSION_USAGE_MONOTONIC",
+            seq: e.seq,
+            message: `sessionToolCallsUsed went ${lastSessionToolCallsUsed} -> ${sessionUsed}`
+          });
+        }
+        if (typeof sessionUsed === "number")
+          lastSessionToolCallsUsed = sessionUsed;
+      }
       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})` });
+      if (remaining !== Math.max(0, limit - used)) {
+        violations.push({ code: "RESOURCE_REMAINING_COHERENT", seq: e.seq, message: `remaining(${remaining}) != max(0, limit(${limit}) - used(${used}))` });
+      }
+      const overrun = e.data.overrun;
+      if (overrun !== void 0) {
+        if (typeof overrun !== "number" || overrun < 0 || overrun !== Math.max(0, used - limit)) {
+          violations.push({ code: "RESOURCE_OVERRUN_COHERENT", seq: e.seq, message: `overrun(${String(overrun)}) != max(0, used(${used}) - limit(${limit}))` });
+        }
       }
       for (const key of ["verificationReserve", "repairReserve"]) {
         const v = e.data[key];
@@ -29706,27 +29769,53 @@ function contractToCompactionFields(contract) {
 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, ""));
+  const acceptanceCriteria = [];
+  const criterionLines = /* @__PURE__ */ new Set();
+  stripped.forEach((line, i) => {
+    const checkbox = CHECKBOX_CRITERION.exec(line);
+    if (checkbox) {
+      criterionLines.add(i);
+      acceptanceCriteria.push({
+        id: `ac-${acceptanceCriteria.length + 1}`,
+        text: checkbox[2].trim(),
+        source: "user",
+        required: true
+      });
+      return;
+    }
+    const keyword = KEYWORD_CRITERION.exec(line);
+    if (keyword) {
+      criterionLines.add(i);
+      const value = keyword[2].trim();
+      const lead = keyword[1].toLowerCase();
+      const hint = (lead === "verify" || lead === "test") && COMMAND_HINT.test(value) ? { kind: "command", value } : void 0;
+      acceptanceCriteria.push({
+        id: `ac-${acceptanceCriteria.length + 1}`,
+        text: value,
+        source: "user",
+        required: true,
+        ...hint ? { verificationHint: hint } : {}
+      });
+    }
+  });
+  const isConstraint = (i) => !criterionLines.has(i) && CONSTRAINT_LEAD.test(stripped[i] ?? "");
+  const constraints = stripped.map((text2, i) => ({ text: text2, i })).filter(({ i }) => isConstraint(i)).map(({ text: text2 }, i) => ({
+    id: `uc-${i + 1}`,
+    text: text2,
+    source: "user",
+    required: true
+  }));
+  const goalIdx = lines.findIndex((_, i) => !criterionLines.has(i) && !isConstraint(i));
+  const goal = goalIdx >= 0 ? lines[goalIdx] : lines[0] ?? text.slice(0, 200);
   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
-    })),
+    goal,
+    constraints,
+    acceptanceCriteria,
     source: { userSeq }
   });
 }
-var TaskConstraintSchema, TaskCriterionSchema, TaskContractSchema, TaskContractConflictError;
+var TaskConstraintSchema, TaskCriterionSchema, TaskContractSchema, TaskContractConflictError, CHECKBOX_CRITERION, KEYWORD_CRITERION, COMMAND_HINT, CONSTRAINT_LEAD;
 var init_taskContract = __esm({
   "packages/core/dist/session/taskContract.js"() {
     "use strict";
@@ -29766,6 +29855,10 @@ var init_taskContract = __esm({
         this.name = "TaskContractConflictError";
       }
     };
+    CHECKBOX_CRITERION = /^\[([ xX])\]\s*(.+)$/;
+    KEYWORD_CRITERION = /^(acceptance|criterion|criteria|verify|test|success)\s*[:#]\s*(.+)$/i;
+    COMMAND_HINT = /^(npm|pnpm|yarn|bun|npx|node|vitest|jest|tsc|eslint|prettier|git)\b/;
+    CONSTRAINT_LEAD = /^(do not|don't|never|no\s|non\s|without changing|keep|must not|avoid)\b/i;
   }
 });
 
@@ -30233,9 +30326,13 @@ function classifyHarnessChanges(diff) {
     const hit = FIELD_CLASSES.find((m) => field === m.prefix || field.startsWith(m.prefix + "."));
     byField[field] = hit ? hit.cls : "cosmetic";
   }
+  const changeSet = { structural: [], behavioral: [], cosmetic: [] };
+  for (const field of diff.changed) {
+    changeSet[byField[field]].push(field);
+  }
   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 };
+  return { overall, byField, changeSet };
 }
 var HARNESS_MANIFEST_SCHEMA_VERSION, HarnessPromptsSchema, HarnessManifestV1Schema, FIELD_CLASSES;
 var init_harnessManifest = __esm({
@@ -30446,12 +30543,14 @@ var init_resourcePolicy = __esm({
 
 // packages/core/dist/runtime/resourceBudget.js
 function computeBudget(policy, usage, stage = "explore") {
-  const used = Math.max(0, Math.min(usage.toolCallsUsed, policy.maxToolCalls));
+  const used = Math.max(0, usage.toolCallsUsed);
+  const overrun = Math.max(0, used - policy.maxToolCalls);
   return {
     toolCalls: {
       limit: policy.maxToolCalls,
       used,
-      remaining: policy.maxToolCalls - used
+      remaining: Math.max(0, policy.maxToolCalls - used),
+      overrun
     },
     wallTime: {
       limitMs: policy.wallClockMs,
@@ -31465,6 +31564,48 @@ var init_resourceReserveGate = __esm({
 });
 
 // packages/core/dist/verification/index.js
+var verification_exports = {};
+__export(verification_exports, {
+  BonConfigSchema: () => BonConfigSchema,
+  CommandCheckSchema: () => CommandCheckSchema,
+  CriterionSchema: () => CriterionSchema,
+  CriterionSourceSchema: () => CriterionSourceSchema,
+  DEFAULT_VERIFIER_CONFIG: () => DEFAULT_VERIFIER_CONFIG,
+  DETERMINISTIC_EVIDENCE_TIERS: () => DETERMINISTIC_EVIDENCE_TIERS,
+  DeterministicCheckSchema: () => DeterministicCheckSchema,
+  EVENT_BACKED_EVIDENCE_TIERS: () => EVENT_BACKED_EVIDENCE_TIERS,
+  EvidenceRefSchema: () => EvidenceRefSchema,
+  EvidenceTierSchema: () => EvidenceTierSchema,
+  FileAbsentCheckSchema: () => FileAbsentCheckSchema,
+  FileContainsCheckSchema: () => FileContainsCheckSchema,
+  FileExistsCheckSchema: () => FileExistsCheckSchema,
+  ModelSelectionSchema: () => ModelSelectionSchema,
+  NoneCheckSchema: () => NoneCheckSchema,
+  STRICT_ALL_POLICY: () => STRICT_ALL_POLICY,
+  STRICT_BUILD_POLICY: () => STRICT_BUILD_POLICY,
+  VerificationEngine: () => VerificationEngine,
+  VerificationResultSchema: () => VerificationResultSchema,
+  VerificationSourceSchema: () => VerificationSourceSchema,
+  VerificationStatusSchema: () => VerificationStatusSchema,
+  VerifierConfigSchema: () => VerifierConfigSchema,
+  VerifierService: () => VerifierService,
+  ZELARI_CODING_PACK_ID: () => ZELARI_CODING_PACK_ID,
+  analyzeScope: () => analyzeScope,
+  codingCriteriaPack: () => codingCriteriaPack,
+  computeFalseDoneRate: () => computeFalseDoneRate,
+  costPerVerifiedSolve: () => costPerVerifiedSolve,
+  evaluateCompletion: () => evaluateCompletion,
+  evaluateResourceReserveGate: () => evaluateResourceReserveGate,
+  isEventBackedEvidence: () => isEventBackedEvidence,
+  isGeneratedPath: () => isGeneratedPath,
+  lastVerificationRun: () => lastVerificationRun,
+  parseNameOnlyDiff: () => parseNameOnlyDiff,
+  parseVerificationRunPayload: () => parseVerificationRunPayload,
+  snapshotToCompletionEvaluation: () => snapshotToCompletionEvaluation,
+  strictBuildGate: () => strictBuildGate,
+  verificationCostRatio: () => verificationCostRatio,
+  verifiedSolveRate: () => verifiedSolveRate
+});
 var init_verification2 = __esm({
   "packages/core/dist/verification/index.js"() {
     "use strict";
@@ -31621,6 +31762,42 @@ var init_mission2 = __esm({
   }
 });
 
+// packages/core/dist/version.js
+var CORE_VERSION;
+var init_version = __esm({
+  "packages/core/dist/version.js"() {
+    "use strict";
+    CORE_VERSION = "2.6.2";
+  }
+});
+
+// packages/core/dist/runtime/fingerprints.js
+import { createHash as createHash6 } from "node:crypto";
+function toolFingerprintHash(tools) {
+  const canonical = [...tools].map((t) => ({
+    name: t.name,
+    ...t.description !== void 0 ? { description: t.description } : {},
+    ...t.inputSchema !== void 0 ? { inputSchema: t.inputSchema } : {},
+    ...t.outputContractVersion !== void 0 ? { outputContractVersion: t.outputContractVersion } : {},
+    ...t.capabilityFlags !== void 0 ? { capabilityFlags: [...t.capabilityFlags].sort() } : {}
+  })).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  return createHash6("sha256").update(stableStringify(canonical)).digest("hex");
+}
+function skillFingerprintHash(skills) {
+  const canonical = [...skills].map((s) => ({
+    id: s.id,
+    ...s.version !== void 0 ? { version: s.version } : {},
+    ...s.contentDigest !== void 0 ? { contentDigest: s.contentDigest } : {}
+  })).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  return createHash6("sha256").update(stableStringify(canonical)).digest("hex");
+}
+var init_fingerprints = __esm({
+  "packages/core/dist/runtime/fingerprints.js"() {
+    "use strict";
+    init_requestSnapshot();
+  }
+});
+
 // packages/core/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
@@ -31642,6 +31819,7 @@ __export(dist_exports, {
   CODING_SKILL_CATALOG: () => CODING_SKILL_CATALOG,
   COLLABORATION_DIRECTIVE: () => COLLABORATION_DIRECTIVE,
   COMPOSITOR_ONLY_PROPS: () => COMPOSITOR_ONLY_PROPS,
+  CORE_VERSION: () => CORE_VERSION,
   COUNCIL_V1: () => COUNCIL_V1,
   CommandCheckSchema: () => CommandCheckSchema,
   CriterionSchema: () => CriterionSchema,
@@ -31986,6 +32164,7 @@ __export(dist_exports, {
   shadowedSeqSet: () => shadowedSeqSet,
   shouldRetryMember: () => shouldRetryMember,
   sideEffectForTool: () => sideEffectForTool,
+  skillFingerprintHash: () => skillFingerprintHash,
   slugify: () => slugify2,
   snapshotToCompletionEvaluation: () => snapshotToCompletionEvaluation,
   specificityFromAssumptions: () => specificityFromAssumptions,
@@ -31997,6 +32176,7 @@ __export(dist_exports, {
   taskMatchesNfrKeywords: () => taskMatchesNfrKeywords,
   tierAtLeast: () => tierAtLeast,
   tokenizeForSignature: () => tokenizeForSignature,
+  toolFingerprintHash: () => toolFingerprintHash,
   toolManifestHash: () => toolManifestHash,
   toolMatches: () => toolMatches,
   topoLevels: () => topoLevels,
@@ -32035,6 +32215,8 @@ var init_dist = __esm({
     init_verification2();
     init_mission2();
     init_experimental();
+    init_version();
+    init_fingerprints();
   }
 });
 
@@ -32367,6 +32549,7 @@ function buildResourceSnapshot(budget, policy) {
     toolCallsLimit: budget.toolCalls.limit,
     toolCallsUsed: budget.toolCalls.used,
     toolCallsRemaining: budget.toolCalls.remaining,
+    overrun: budget.toolCalls.overrun,
     ...budget.wallTime.remainingMs !== void 0 ? { wallMsRemaining: budget.wallTime.remainingMs } : {},
     verificationReserve: budget.reserve.verification,
     repairReserve: budget.reserve.repair,
@@ -32375,6 +32558,13 @@ function buildResourceSnapshot(budget, policy) {
     reserveProtected: isVerificationReserveProtected(budget)
   };
 }
+function withResourceSnapshotContext(snapshot, context) {
+  return {
+    ...snapshot,
+    ...context.epoch !== void 0 ? { epoch: context.epoch } : {},
+    ...context.sessionToolCallsUsed !== void 0 ? { sessionToolCallsUsed: context.sessionToolCallsUsed } : {}
+  };
+}
 function shouldEmitSnapshot(previous, next) {
   if (!previous) return true;
   if (previous.stage !== next.stage) return true;
@@ -32394,7 +32584,29 @@ var init_resourceSnapshot = __esm({
 function resolveResourceEnforcement(env = process.env) {
   return env.ZELARI_RESOURCE_ENFORCEMENT === "protected" ? "protected" : "advisory";
 }
-var DEFAULT_ESSENTIAL_TOOLS, ADVISORY_NOTICE, PROTECTED_DENIAL, BudgetRuntime;
+function bashCommand(args) {
+  if (!args || typeof args !== "object") return "";
+  const rec = args;
+  for (const key of ["command", "cmd", "script"]) {
+    if (typeof rec[key] === "string") return rec[key];
+  }
+  return "";
+}
+function isVerificationEssential(toolName, args, _stage = "implement") {
+  if (toolName === "bash") {
+    const cmd = bashCommand(args);
+    if (!cmd) return false;
+    return ESSENTIAL_BASH.some((re) => re.test(cmd));
+  }
+  if (toolName === "grep_content") {
+    if (!args || typeof args !== "object") return true;
+    const rec = args;
+    const hasScope = typeof rec.path === "string" && rec.path !== "." && rec.path !== "./";
+    return hasScope || typeof rec.pattern === "string";
+  }
+  return DEFAULT_ESSENTIAL_TOOLS.includes(toolName);
+}
+var DEFAULT_ESSENTIAL_TOOLS, ADVISORY_NOTICE, PROTECTED_DENIAL, HARD_LIMIT_DENIAL, ESSENTIAL_BASH, BudgetRuntime;
 var init_budgetRuntime = __esm({
   "src/cli/budget/budgetRuntime.ts"() {
     "use strict";
@@ -32402,7 +32614,6 @@ var init_budgetRuntime = __esm({
     init_resourceLedger();
     init_resourceSnapshot();
     DEFAULT_ESSENTIAL_TOOLS = [
-      "bash",
       "read_file",
       "edit_file",
       "write_file",
@@ -32413,27 +32624,88 @@ var init_budgetRuntime = __esm({
     ];
     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.";
+    HARD_LIMIT_DENIAL = "Resource exhausted: this turn's execution budget (maxToolCalls) is spent. No further billable tool calls are allowed in this turn \u2014 summarize what was verified and report BLOCKED/resource-exhausted with the evidence already collected. A later user turn starts a fresh execution budget.";
+    ESSENTIAL_BASH = [
+      /\b(npm|pnpm|yarn|bun)\s+(run\s+)?(test|vitest|jest)\b/,
+      /\b(npm|pnpm|yarn|bun)\s+run\s+[\w:-]*(typecheck|lint|build)\b/,
+      /\bnpx\s+(vitest|tsc|typescript|eslint)\b/,
+      /\b(npx\s+)?tsc\b/,
+      /\bvitest\b/,
+      /\bjest\b/,
+      /\bnode\s+--run\b/,
+      /\bgit\s+(diff|status|log|show)\b/
+    ];
     BudgetRuntime = class {
       policy;
       enforcement;
       ledger;
       essential;
+      initialStage;
       stage;
+      epoch = 0;
+      executionBaseline = { toolCallsUsed: 0, wallMs: 0, tokensUsed: 0 };
       lastEmitted;
+      hardLimitAnnounced = false;
       constructor(profileId, opts = {}) {
-        this.policy = opts.policy ?? defaultResourcePolicy(profileId);
+        const basePolicy = opts.policy ?? defaultResourcePolicy(profileId);
+        const envCap = Number.parseInt(process.env.ZELARI_MAX_TOOL_CALLS ?? "", 10);
+        this.policy = Number.isFinite(envCap) && envCap >= 1 ? { ...basePolicy, maxToolCalls: envCap } : basePolicy;
         this.enforcement = opts.enforcement ?? "advisory";
         this.essential = new Set(opts.essentialTools ?? DEFAULT_ESSENTIAL_TOOLS);
-        this.stage = opts.stage ?? "implement";
+        this.initialStage = opts.stage ?? "implement";
+        this.stage = this.initialStage;
         this.ledger = new ResourceLedger();
       }
+      /**
+       * Start a fresh user-turn execution epoch. The durable ledger remains
+       * cumulative for telemetry; only the enforcement baseline moves forward.
+       */
+      beginTurn() {
+        this.executionBaseline = this.ledger.usage();
+        this.epoch += 1;
+        this.stage = this.initialStage;
+        this.hardLimitAnnounced = false;
+        this.lastEmitted = void 0;
+        const next = this.current();
+        this.lastEmitted = next;
+        return next;
+      }
+      /** Cumulative session telemetry (never reset by beginTurn). */
+      sessionUsage() {
+        return this.ledger.usage();
+      }
       /**
        * 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() {
+        return this.consumeToolCall().snapshot;
+      }
+      /**
+       * 2.6.1 (plan §9): count one tool call AND surface the hard-limit event
+       * due on this call — `resource.limit_reached` once at the crossing,
+       * `resource.overrun` for every call past the limit. The spine appends the
+       * event right after its tool.call.
+       */
+      consumeToolCall() {
         this.ledger.record("tool-call");
-        return this.emitIfDue();
+        const next = this.current();
+        let hardEvent = null;
+        const data = {
+          epoch: next.epoch,
+          used: next.toolCallsUsed,
+          limit: next.toolCallsLimit,
+          overrun: next.overrun,
+          sessionToolCallsUsed: next.sessionToolCallsUsed
+        };
+        if (!this.hardLimitAnnounced && next.toolCallsRemaining <= 0) {
+          this.hardLimitAnnounced = true;
+          hardEvent = { kind: "resource.limit_reached", data };
+        } else if (next.overrun > 0) {
+          hardEvent = { kind: "resource.overrun", data };
+        }
+        const snapshot = shouldEmitSnapshot(this.lastEmitted, next) ? (this.lastEmitted = next, next) : null;
+        return { snapshot, hardEvent };
       }
       /** §10.4 verification start: stage change (and a zero-cost ledger mark). */
       noteVerificationStart() {
@@ -32450,18 +32722,44 @@ var init_budgetRuntime = __esm({
         this.stage = stage;
         return this.emitIfDue();
       }
+      /** 2.6.1 (plan §14): canonical budget for the reserve gate. */
+      budgetSnapshot() {
+        const cumulative = this.ledger.usage();
+        return computeBudget(
+          this.policy,
+          {
+            toolCallsUsed: Math.max(0, cumulative.toolCallsUsed - this.executionBaseline.toolCallsUsed),
+            elapsedMs: Math.max(0, cumulative.wallMs - this.executionBaseline.wallMs),
+            tokensUsed: Math.max(0, cumulative.tokensUsed - this.executionBaseline.tokensUsed)
+          },
+          this.stage
+        );
+      }
       /** Current projection without emitting. */
       current() {
-        return buildResourceSnapshot(this.ledger.budget(this.policy, this.stage), this.policy);
+        const cumulative = this.ledger.usage();
+        return withResourceSnapshotContext(buildResourceSnapshot(this.budgetSnapshot(), this.policy), {
+          epoch: this.epoch,
+          sessionToolCallsUsed: cumulative.toolCallsUsed
+        });
       }
-      /** §11.3 gate — advisory mode never blocks; protected mode guards the zone. */
-      gateToolCall(toolName) {
+      /**
+       * §11.3 gate — argument-aware (2.6.1 §13). Hard limit denies first in BOTH
+       * modes; advisory mode never blocks inside the protected zone; protected
+       * mode guards the zone with isVerificationEssential(tool, args).
+       */
+      gateToolCall(toolNameOrInput) {
+        const input = typeof toolNameOrInput === "string" ? { toolName: toolNameOrInput } : toolNameOrInput;
         const snapshot = this.current();
+        if (snapshot.toolCallsRemaining <= 0) {
+          return { allowed: false, advisory: false, reason: HARD_LIMIT_DENIAL, snapshot, hardLimit: true };
+        }
         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)) {
+        const essential = input.toolName === "bash" || input.toolName === "grep_content" ? isVerificationEssential(input.toolName, input.args, input.stage ?? this.stage) : this.essential.has(input.toolName);
+        if (essential) {
           return { allowed: true, advisory: true, reason: ADVISORY_NOTICE, snapshot };
         }
         return { allowed: false, advisory: false, reason: PROTECTED_DENIAL, snapshot };
@@ -32470,7 +32768,26 @@ var init_budgetRuntime = __esm({
       adoptLedgerFromEvents(events) {
         const rebuilt = rebuildLedgerFromEvents(events);
         this.ledger.resetTo(rebuilt.snapshot());
+        let epochStart = -1;
+        let fallbackUserStart = -1;
+        let restoredEpoch = 0;
+        for (let i = 0; i < events.length; i++) {
+          const event = events[i];
+          if (event.kind === "user.message") fallbackUserStart = i;
+          if (event.kind === "resource.epoch_started") {
+            epochStart = i;
+            const value = event.data.epoch;
+            if (typeof value === "number" && Number.isInteger(value) && value > restoredEpoch) {
+              restoredEpoch = value;
+            }
+          }
+        }
+        const activeStart = epochStart >= 0 ? epochStart : fallbackUserStart;
+        this.executionBaseline = activeStart >= 0 ? rebuildLedgerFromEvents(events.slice(0, activeStart + 1)).usage() : { toolCallsUsed: 0, wallMs: 0, tokensUsed: 0 };
+        this.epoch = restoredEpoch;
         this.lastEmitted = void 0;
+        const now = this.current();
+        this.hardLimitAnnounced = now.toolCallsRemaining <= 0;
       }
       /** Latest emitted snapshot (what the model surface shows), if any. */
       latestEmitted() {
@@ -32488,8 +32805,293 @@ var init_budgetRuntime = __esm({
   }
 });
 
-// src/cli/sessionSpine.ts
+// src/cli/budget/restoreRuntime.ts
 import path21 from "node:path";
+async function restoreBudgetRuntimeFromSession(budget, sessionId2, baseDir) {
+  const eventsPath = path21.join(resolveSessionsDir({ baseDir }), sessionId2, "events.jsonl");
+  const report = await readSessionLog(eventsPath).catch(() => null);
+  if (!report || report.events.length === 0) return false;
+  budget.adoptLedgerFromEvents(report.events);
+  return true;
+}
+async function lastHarnessManifestHash(sessionId2, baseDir) {
+  const eventsPath = path21.join(resolveSessionsDir({ baseDir }), sessionId2, "events.jsonl");
+  const report = await readSessionLog(eventsPath).catch(() => null);
+  if (!report) return null;
+  for (let i = report.events.length - 1; i >= 0; i--) {
+    const e = report.events[i];
+    if (e.kind === "session.harness_manifest") {
+      const h = e.data.manifestHash;
+      return typeof h === "string" ? h : null;
+    }
+  }
+  return null;
+}
+var init_restoreRuntime = __esm({
+  "src/cli/budget/restoreRuntime.ts"() {
+    "use strict";
+    init_session();
+  }
+});
+
+// src/cli/utils/cmdline.ts
+function quoteCmdArg(arg) {
+  if (arg === "") return '""';
+  if (!/[\s"^&|<>()%!]/.test(arg)) return arg;
+  return `"${arg.replace(/"/g, '""')}"`;
+}
+function buildCmdLine(command, args) {
+  return [command, ...args].map(quoteCmdArg).join(" ");
+}
+var init_cmdline = __esm({
+  "src/cli/utils/cmdline.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/updater.ts
+var updater_exports = {};
+__export(updater_exports, {
+  REGISTRY_URL: () => REGISTRY_URL,
+  checkForUpdate: () => checkForUpdate,
+  compareSemver: () => compareSemver,
+  distTagForVersion: () => distTagForVersion,
+  fetchLatestVersion: () => fetchLatestVersion,
+  getCurrentVersion: () => getCurrentVersion,
+  looksLikeBrokenShim: () => looksLikeBrokenShim,
+  performUpdate: () => performUpdate,
+  registryUrlForTag: () => registryUrlForTag,
+  resolveBundledNpmCli: () => resolveBundledNpmCli
+});
+import { createRequire } from "node:module";
+import { spawn as spawn5 } from "node:child_process";
+import { existsSync as existsSync11 } from "node:fs";
+import path22 from "node:path";
+import { fileURLToPath } from "node:url";
+function resolveBundledNpmCli(execPath = process.execPath) {
+  const dir = path22.dirname(execPath);
+  const candidates = [
+    // Windows: C:\...\node.exe → C:\...\node_modules\npm\bin\npm-cli.js
+    path22.join(dir, "node_modules", "npm", "bin", "npm-cli.js"),
+    // POSIX: <prefix>/bin/node → <prefix>/lib/node_modules/npm/bin/npm-cli.js
+    path22.join(dir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")
+  ];
+  for (const candidate of candidates) {
+    try {
+      if (existsSync11(candidate)) return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function looksLikeBrokenShim(exitCode, output) {
+  if (exitCode === 127) return true;
+  const h = output.toLowerCase();
+  return h.includes("shim target not found") || h.includes("is not recognized");
+}
+function getCurrentVersion() {
+  try {
+    const pkgPath = path22.resolve(__dirname2, "..", "..", "package.json");
+    const pkg = require2(pkgPath);
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+function compareSemver(a, b) {
+  const parse3 = (v) => {
+    const m = v.match(/^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/);
+    if (!m) return [0, 0, 0, null];
+    return [Number(m[1]), Number(m[2]), Number(m[3]), m[4] ?? null];
+  };
+  const [a1, a2, a3, aPre] = parse3(a);
+  const [b1, b2, b3, bPre] = parse3(b);
+  if (a1 !== b1) return a1 < b1 ? -1 : 1;
+  if (a2 !== b2) return a2 < b2 ? -1 : 1;
+  if (a3 !== b3) return a3 < b3 ? -1 : 1;
+  if (aPre === bPre) return 0;
+  if (aPre === null) return 1;
+  if (bPre === null) return -1;
+  return aPre < bPre ? -1 : 1;
+}
+function distTagForVersion(version2) {
+  if (version2.includes("-alpha.")) return "alpha";
+  if (version2.includes("-beta.")) return "beta";
+  if (version2.includes("-next.")) return "next";
+  return "latest";
+}
+function registryUrlForTag(tag = distTagForVersion(getCurrentVersion())) {
+  return `https://registry.npmjs.org/zelari-code/${tag}`;
+}
+async function fetchLatestVersion(fetcher = fetch, registryUrl = REGISTRY_URL, timeoutMs2 = 5e3) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs2);
+    const response = await fetcher(registryUrl, { signal: controller.signal });
+    clearTimeout(timer);
+    if (!response.ok) {
+      return { error: `Registry responded ${response.status}` };
+    }
+    const data = await response.json();
+    if (!data.version || typeof data.version !== "string") {
+      return { error: "Registry response missing version field" };
+    }
+    return { version: data.version };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { error: message };
+  }
+}
+async function checkForUpdate(fetcher = fetch, registryUrl) {
+  const currentVersion = getCurrentVersion();
+  const url2 = registryUrl ?? registryUrlForTag();
+  const latest = await fetchLatestVersion(fetcher, url2);
+  if ("error" in latest) {
+    return {
+      currentVersion,
+      latestVersion: currentVersion,
+      updateAvailable: false,
+      error: latest.error
+    };
+  }
+  const cmp = compareSemver(currentVersion, latest.version);
+  return {
+    currentVersion,
+    latestVersion: latest.version,
+    updateAvailable: cmp < 0
+  };
+}
+async function performUpdate(packageName = "zelari-code", executor = spawn5, resolveNpmCli = resolveBundledNpmCli, channel) {
+  const tag = channel ?? distTagForVersion(getCurrentVersion());
+  const args = ["install", "-g", `${packageName}@${tag}`];
+  const primary = await runNpm(executor, args, "shim");
+  if (primary.ok) return primary;
+  const npmCli = resolveNpmCli();
+  if (npmCli && looksLikeBrokenShim(primary.exitCode, primary.output)) {
+    const fallback = await runNpm(executor, args, "bundled", npmCli);
+    return {
+      ...fallback,
+      output: `[update] npm shim failed (${primary.error ?? "exit " + primary.exitCode}); retried via bundled npm (${npmCli}).
+${fallback.output}`
+    };
+  }
+  return primary;
+}
+function runNpm(executor, args, mode, npmCliPath) {
+  return new Promise((resolve3) => {
+    let stdout = "";
+    let stderr = "";
+    const stdio = ["ignore", "pipe", "pipe"];
+    const child = mode === "bundled" && npmCliPath ? executor(process.execPath, [npmCliPath, ...args], { stdio }) : process.platform === "win32" ? executor(buildCmdLine("npm", args), { stdio, shell: true }) : executor("npm", args, { stdio });
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (err) => {
+      resolve3({
+        ok: false,
+        output: stdout + stderr,
+        error: err.message,
+        exitCode: null
+      });
+    });
+    child.on("close", (code) => {
+      const ok = code === 0;
+      resolve3({
+        ok,
+        output: stdout + stderr,
+        error: ok ? void 0 : `npm exited with code ${code}`,
+        exitCode: code
+      });
+    });
+  });
+}
+var require2, __dirname2, REGISTRY_URL;
+var init_updater = __esm({
+  "src/cli/updater.ts"() {
+    "use strict";
+    init_cmdline();
+    require2 = createRequire(import.meta.url);
+    __dirname2 = path22.dirname(fileURLToPath(import.meta.url));
+    REGISTRY_URL = "https://registry.npmjs.org/zelari-code/latest";
+  }
+});
+
+// src/cli/harnessManifest.ts
+function buildHarnessManifest(parts) {
+  const prompts = {};
+  for (const [role, text] of Object.entries(parts.prompts ?? {})) {
+    if (typeof text === "string" && text.length > 0) {
+      prompts[role] = harnessInputHash(text);
+    }
+  }
+  const manifest = HarnessManifestV1Schema.parse({
+    schemaVersion: 1,
+    profile: {
+      id: parts.profile.id,
+      phase: parts.phase,
+      hash: profileHash(parts.profile)
+    },
+    prompts,
+    capabilities: {
+      // 2.6.1 (plan §7): full fingerprints when specs are available.
+      toolManifestHash: parts.toolSpecs ? toolFingerprintHash(parts.toolSpecs) : toolManifestHash(parts.toolNames),
+      skillManifestHash: parts.skillSpecs ? skillFingerprintHash(parts.skillSpecs) : harnessInputHash([...parts.skillIds ?? []].sort())
+    },
+    policies: {
+      routingHash: harnessInputHash(parts.routing ?? { unset: true }),
+      verificationHash: harnessInputHash(parts.verification ?? { engine: "deterministic" }),
+      completionPolicyHash: harnessInputHash(parts.completionPolicy ?? { mode: "strict", required: "*" }),
+      compactionHash: harnessInputHash(parts.compaction ?? { version: 1 }),
+      resourcePolicyHash: harnessInputHash(parts.resourcePolicy ?? { unset: true })
+    },
+    runtime: {
+      // 2.6.1 (plan §7): canonical export — no more require.resolve.
+      coreVersion: parts.coreVersion ?? CORE_VERSION,
+      cliVersion: parts.cliVersion ?? getCurrentVersion()
+    }
+  });
+  return { manifest, manifestHash: hashHarnessManifest(manifest) };
+}
+var init_harnessManifest2 = __esm({
+  "src/cli/harnessManifest.ts"() {
+    "use strict";
+    init_dist();
+    init_dist();
+    init_updater();
+  }
+});
+
+// src/cli/kraken/taskContract.ts
+function latestTaskContract(events) {
+  let latest;
+  for (const e of events) {
+    if (e.kind !== "task.contract" && e.kind !== "task.contract_updated") continue;
+    const raw = e.data.contract;
+    if (raw && typeof raw === "object") {
+      const candidate = raw;
+      if (!latest || candidate.version > latest.version) latest = candidate;
+    }
+  }
+  return latest;
+}
+function updateTaskContract(contract, update) {
+  return applyTaskContractUpdate(contract, update);
+}
+function contractEventData(contract, updated) {
+  return { contract, kind: updated ? "task.contract_updated" : "task.contract" };
+}
+var init_taskContract2 = __esm({
+  "src/cli/kraken/taskContract.ts"() {
+    "use strict";
+    init_dist();
+  }
+});
+
+// src/cli/sessionSpine.ts
+import path23 from "node:path";
 function spineEnabled() {
   return process.env.ZELARI_SESSION_SPINE !== "0";
 }
@@ -32571,14 +33173,54 @@ 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()
-      })
+    const budget = new BudgetRuntime(typeof profile === "string" ? profile : "kraken/v1", {
+      enforcement: resolveResourceEnforcement()
+    });
+    if (spine.resumedFromSeq !== void 0 && spine.resumedFromSeq > 0) {
+      await restoreBudgetRuntimeFromSession(budget, sessionId2, options.baseDir);
+    }
+    spine.attachBudgetRuntime(budget);
+    await noteHarnessLifecycle(
+      spine,
+      sessionId2,
+      typeof profile === "string" ? profile : "kraken/v1",
+      budget,
+      options.baseDir,
+      options.extraStarted?.phase
     );
   }
   return new SpineMirroringWriter(inner, spine.status === "active" ? spine : null);
 }
+function taskContractsEnabled() {
+  return process.env.ZELARI_TASK_CONTRACT !== "0";
+}
+async function noteHarnessLifecycle(spine, sessionId2, profileId, budget, baseDir, phaseHint) {
+  try {
+    const profile = resolveProfile(profileId);
+    const { manifest, manifestHash } = buildHarnessManifest({
+      profile,
+      phase: phaseHint === "plan" ? "plan" : "build",
+      toolNames: profile.tools,
+      // plan §7/§8: the REAL session policy — never the {unset:true} marker.
+      resourcePolicy: budget.policy
+    });
+    if (spine.resumedFromSeq !== void 0 && spine.resumedFromSeq > 0) {
+      const original = await lastHarnessManifestHash(sessionId2, baseDir);
+      if (original === null) {
+        spine.harnessManifest(manifest, manifestHash);
+      } else if (original !== manifestHash) {
+        await spine.appendEvent({
+          kind: "session.harness_drift",
+          actor: ACTOR_SYSTEM,
+          data: { originalManifestHash: original, currentManifestHash: manifestHash }
+        });
+      }
+    } else {
+      spine.harnessManifest(manifest, manifestHash);
+    }
+  } catch {
+  }
+}
 var MAX_STREAM_BUFFERS, SessionSpineMirror, SpineMirroringWriter;
 var init_sessionSpine = __esm({
   "src/cli/sessionSpine.ts"() {
@@ -32587,6 +33229,10 @@ var init_sessionSpine = __esm({
     init_session();
     init_verification2();
     init_budgetRuntime();
+    init_restoreRuntime();
+    init_runtime2();
+    init_harnessManifest2();
+    init_taskContract2();
     MAX_STREAM_BUFFERS = 32;
     SessionSpineMirror = class _SessionSpineMirror {
       constructor(sessionId2, options) {
@@ -32600,6 +33246,8 @@ var init_sessionSpine = __esm({
       warned = false;
       /** Host-owned budget runtime (attached via attachBudgetRuntime). */
       budgetRuntime = null;
+      /** True after the host prepared an epoch but before its user.message lands. */
+      resourceTurnPrepared = false;
       /** 2.6 Track A: set once a task.contract has been seeded (or the log had one). */
       contractSeeded = false;
       status = "disabled";
@@ -32615,8 +33263,8 @@ var init_sessionSpine = __esm({
         const mirror = new _SessionSpineMirror(sessionId2, options);
         if (!spineEnabled()) return mirror;
         try {
-          const sessionDir = path21.join(mirror.sessionsDir, sessionId2);
-          const report = await readSessionLog(path21.join(sessionDir, "events.jsonl"));
+          const sessionDir = path23.join(mirror.sessionsDir, sessionId2);
+          const report = await readSessionLog(path23.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;
@@ -32660,8 +33308,16 @@ var init_sessionSpine = __esm({
         return mirror;
       }
       /** Log the user prompt — the P1 gap the 1.x log never closed. */
-      userMessage(text) {
-        const seqP = this.append({ kind: "user.message", actor: ACTOR_USER, data: { text } });
+      userMessage(text, options = {}) {
+        if (options.beginResourceTurn !== false) {
+          void this.beginResourceTurn();
+          this.resourceTurnPrepared = false;
+        }
+        const seqP = this.append({
+          kind: "user.message",
+          actor: ACTOR_USER,
+          data: { text, ...options.imported ? { imported: options.imported } : {} }
+        });
         void seqP;
       }
       /**
@@ -32697,24 +33353,77 @@ var init_sessionSpine = __esm({
        */
       attachBudgetRuntime(runtime) {
         this.budgetRuntime = runtime;
+        this.resourceTurnPrepared = false;
+      }
+      /**
+       * Prepare a fresh per-user-turn execution epoch before model context is
+       * derived. The cumulative ResourceLedger is retained; enforcement and the
+       * latest RESOURCE STATUS restart at 0 / policy.maxToolCalls.
+       */
+      beginResourceTurn() {
+        if (!this.budgetRuntime || this.resourceTurnPrepared) {
+          return this.chain.then(() => void 0);
+        }
+        const snapshot = this.budgetRuntime.beginTurn();
+        this.resourceTurnPrepared = true;
+        void this.append({
+          kind: "resource.epoch_started",
+          actor: ACTOR_SYSTEM,
+          data: {
+            epoch: snapshot.epoch,
+            kind: "turn",
+            sessionToolCallsUsed: snapshot.sessionToolCallsUsed
+          }
+        });
+        return this.append({
+          kind: "resource.snapshot",
+          actor: ACTOR_SYSTEM,
+          data: { ...snapshot }
+        }).then(() => void 0);
       }
       /** Latest emitted resource snapshot (the model-visible one), or null. */
       latestResourceSnapshot() {
         return this.budgetRuntime?.latestEmitted() ?? null;
       }
+      /**
+       * 2.6.1 (plan §8): session ResourcePolicy cap for hosts that need to derive
+       * per-turn limits — the policy stays the single authority. Null when no
+       * runtime is attached (hosts keep their own default).
+       */
+      /** Full budget shape for evaluateResourceReserveGate (plan §14). */
+      resourceBudgetSummary() {
+        return this.budgetRuntime?.budgetSnapshot() ?? null;
+      }
+      resourceBudgetLimit() {
+        const snap = this.budgetRuntime?.current();
+        return snap ? {
+          maxToolCalls: snap.toolCallsLimit,
+          remaining: snap.toolCallsRemaining,
+          verificationReserve: snap.verificationReserve
+        } : 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").
+       * 2.6.1 (plan §13): argument-aware — pass the tool args so `bash` is only
+       * essential when it is a test/typecheck/build/git-diff command.
        */
-      gateResourceToolCall(toolName) {
-        const gate = this.budgetRuntime?.gateToolCall(toolName);
+      gateResourceToolCall(toolName, args) {
+        const gate = this.budgetRuntime?.gateToolCall({ toolName, args });
         if (!gate) return null;
-        return { allowed: gate.allowed, ...gate.reason ? { reason: gate.reason } : {} };
+        return {
+          allowed: gate.allowed,
+          ...gate.reason ? { reason: gate.reason } : {},
+          ...gate.hardLimit ? { hardLimit: gate.hardLimit } : {}
+        };
       }
-      /** Count a landed tool.call; returns the snapshot due (§10.4), if any. */
+      /**
+       * Count a landed tool.call; returns the snapshot due (§10.4) plus the
+       * hard-limit event due on this call (2.6.1 plan §9), if any.
+       */
       onToolCallBudget() {
-        return this.budgetRuntime?.noteToolCall() ?? null;
+        return this.budgetRuntime?.consumeToolCall() ?? { snapshot: null, hardEvent: null };
       }
       async flush() {
         await this.chain;
@@ -32726,7 +33435,7 @@ var init_sessionSpine = __esm({
       async derivedPriorTurns() {
         if (this.status !== "active" && this.status !== "closed") return null;
         const report = await readSessionLog(
-          path21.join(this.sessionsDir, this.sessionId, "events.jsonl")
+          path23.join(this.sessionsDir, this.sessionId, "events.jsonl")
         ).catch(() => null);
         if (!report || report.events.length === 0) return null;
         return deriveMessages(report.events);
@@ -32736,7 +33445,7 @@ var init_sessionSpine = __esm({
         if (this.status !== "active" && this.status !== "closed") return null;
         await this.flush();
         const report = await readSessionLog(
-          path21.join(this.sessionsDir, this.sessionId, "events.jsonl")
+          path23.join(this.sessionsDir, this.sessionId, "events.jsonl")
         ).catch(() => null);
         if (!report || report.events.length === 0) return null;
         return buildCompactionStateSnapshot(report.events, toSeq);
@@ -32749,7 +33458,7 @@ var init_sessionSpine = __esm({
       async lastVerificationRun() {
         if (this.status !== "active" && this.status !== "closed") return null;
         const report = await readSessionLog(
-          path21.join(this.sessionsDir, this.sessionId, "events.jsonl")
+          path23.join(this.sessionsDir, this.sessionId, "events.jsonl")
         ).catch(() => null);
         if (!report) return null;
         return lastVerificationRun(report.events);
@@ -32820,10 +33529,18 @@ var init_sessionSpine = __esm({
       }
       append(input) {
         if (!this.writer || this.status === "closed") return Promise.resolve(null);
-        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;
+        const budgetEffect = input.kind === "tool.call" ? this.onToolCallBudget() : null;
+        const dueContract = input.kind === "user.message" && taskContractsEnabled() && !this.contractSeeded ? (this.contractSeeded = true, input.data?.text) : null;
+        const steerText = input.kind === "user.message" && taskContractsEnabled() && this.contractSeeded && !dueContract ? input.data?.text ?? null : null;
         let seq = this.chain.then(() => this.writer.append(input)).then((envelope) => envelope.seq);
-        if (dueSnapshot) {
+        if (budgetEffect?.hardEvent) {
+          const hard = budgetEffect.hardEvent;
+          seq = seq.then(
+            (s) => this.writer.append({ kind: hard.kind, actor: ACTOR_SYSTEM, data: { ...hard.data } }).then(() => s)
+          );
+        }
+        if (budgetEffect?.snapshot) {
+          const dueSnapshot = budgetEffect.snapshot;
           seq = seq.then(
             (s) => this.writer.append({ kind: "resource.snapshot", actor: ACTOR_SYSTEM, data: { ...dueSnapshot } }).then(() => s)
           );
@@ -32844,6 +33561,30 @@ var init_sessionSpine = __esm({
             return s;
           });
         }
+        if (steerText) {
+          seq = seq.then(async (s) => {
+            try {
+              const eventsPath = path23.join(this.sessionsDir, this.sessionId, "events.jsonl");
+              const report = await readSessionLog(eventsPath).catch(() => null);
+              if (!report || typeof s !== "number") return s;
+              const current = latestTaskContract(report.events);
+              if (!current) return s;
+              const updated = updateTaskContract(current, {
+                addConstraints: [{ id: `steer-${s}`, text: steerText, source: "user", required: false }],
+                nextUserSeq: s
+              });
+              if (updated.version !== current.version) {
+                await this.writer.append({
+                  kind: "task.contract_updated",
+                  actor: ACTOR_SYSTEM,
+                  data: contractEventData(updated, true)
+                });
+              }
+            } catch {
+            }
+            return s;
+          });
+        }
         this.chain = seq.catch((err) => {
           this.status = "degraded";
           this.writer = null;
@@ -33070,10 +33811,10 @@ var init_sessionSurface = __esm({
 });
 
 // src/cli/hooks/observationStore.ts
-import { existsSync as existsSync11, statSync as statSync2 } from "node:fs";
-import path22 from "node:path";
+import { existsSync as existsSync12, statSync as statSync2 } from "node:fs";
+import path24 from "node:path";
 function sessionFilePath(sessionId2, baseDir) {
-  return path22.join(baseDir ?? getSessionBaseDir(), `${sessionId2}.jsonl`);
+  return path24.join(baseDir ?? getSessionBaseDir(), `${sessionId2}.jsonl`);
 }
 function isToolEnd(e) {
   return e.type === "tool_execution_end";
@@ -33083,7 +33824,7 @@ function isToolStart(e) {
 }
 async function loadObservationIndex(sessionId2, baseDir) {
   const filePath = sessionFilePath(sessionId2, baseDir);
-  const exists = existsSync11(filePath);
+  const exists = existsSync12(filePath);
   let mtimeMs = 0;
   if (exists) {
     try {
@@ -33095,7 +33836,7 @@ async function loadObservationIndex(sessionId2, baseDir) {
   const hit = cache.get(sessionId2);
   if (hit && !exists) return hit;
   if (hit && hit.filePath === filePath && hit.mtimeMs === mtimeMs) return hit;
-  const events = existsSync11(filePath) ? await readSession(filePath) : [];
+  const events = existsSync12(filePath) ? await readSession(filePath) : [];
   const names = /* @__PURE__ */ new Map();
   const bySeq = /* @__PURE__ */ new Map();
   const byToolCallId = /* @__PURE__ */ new Map();
@@ -33192,8 +33933,8 @@ var init_observationStore = __esm({
 });
 
 // src/cli/metrics.ts
-import { promises as fs14, existsSync as existsSync12, statSync as statSync3, renameSync, appendFileSync as appendFileSync2, mkdirSync as mkdirSync6 } from "node:fs";
-import path23 from "node:path";
+import { promises as fs14, existsSync as existsSync13, statSync as statSync3, renameSync, appendFileSync as appendFileSync2, mkdirSync as mkdirSync6 } from "node:fs";
+import path25 from "node:path";
 import os6 from "node:os";
 async function readMetrics(file2) {
   let raw = "";
@@ -33242,8 +33983,8 @@ var init_metrics2 = __esm({
       file;
       writeQueue = Promise.resolve();
       constructor(file2) {
-        this.file = file2 ?? process.env.ANATHEMA_METRICS_FILE ?? path23.join(os6.homedir(), ".tmp", "zelari-code", "metrics.jsonl");
-        mkdirSync6(path23.dirname(this.file), { recursive: true });
+        this.file = file2 ?? process.env.ANATHEMA_METRICS_FILE ?? path25.join(os6.homedir(), ".tmp", "zelari-code", "metrics.jsonl");
+        mkdirSync6(path25.dirname(this.file), { recursive: true });
       }
       /** Metrics file path — doctor/summary readers use this. */
       get filePath() {
@@ -33278,7 +34019,7 @@ var init_metrics2 = __esm({
       }
       /** If the file is over the rotation threshold, rotate it. */
       maybeRotate() {
-        if (!existsSync12(this.file)) return;
+        if (!existsSync13(this.file)) return;
         try {
           const stat = statSync3(this.file);
           if (stat.size >= METRICS_ROTATE_BYTES) {
@@ -34459,8 +35200,8 @@ var init_resolveStream = __esm({
 });
 
 // packages/core/dist/core/tools/toolOutputSpill.js
-import { createHash as createHash6, randomBytes as randomBytes2 } from "node:crypto";
-import { existsSync as existsSync13, mkdirSync as mkdirSync7, writeFileSync as writeFileSync11 } from "node:fs";
+import { createHash as createHash7, randomBytes as randomBytes2 } from "node:crypto";
+import { existsSync as existsSync14, mkdirSync as mkdirSync7, writeFileSync as writeFileSync11 } from "node:fs";
 import { homedir as homedir3, tmpdir } from "node:os";
 import { join as join11 } from "node:path";
 function resolveToolOutputDir() {
@@ -34486,10 +35227,10 @@ function spillToolOutput(fullText, meta3) {
     return null;
   try {
     const dir = resolveToolOutputDir();
-    if (!existsSync13(dir)) {
+    if (!existsSync14(dir)) {
       mkdirSync7(dir, { recursive: true });
     }
-    const hash3 = createHash6("sha256").update(fullText).digest("hex").slice(0, 12);
+    const hash3 = createHash7("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);
@@ -34753,14 +35494,14 @@ var init_registry2 = __esm({
 });
 
 // src/cli/safety/sandboxPath.ts
-import path24 from "node:path";
+import path26 from "node:path";
 function resolveSandboxedPath(userPath, options = {}) {
   if (typeof userPath !== "string" || userPath.length === 0) {
     throw new SandboxViolationError("Empty path", userPath, "");
   }
-  const root = path24.resolve(options.root ?? process.cwd());
-  const resolved = path24.isAbsolute(userPath) ? path24.resolve(userPath) : path24.resolve(root, userPath);
-  const rootWithSep = root.endsWith(path24.sep) ? root : root + path24.sep;
+  const root = path26.resolve(options.root ?? process.cwd());
+  const resolved = path26.isAbsolute(userPath) ? path26.resolve(userPath) : path26.resolve(root, userPath);
+  const rootWithSep = root.endsWith(path26.sep) ? root : root + path26.sep;
   if (resolved !== root && !resolved.startsWith(rootWithSep)) {
     throw new SandboxViolationError(
       `Path escapes sandbox root: ${userPath} \u2192 ${resolved} (root: ${root})`,
@@ -34848,12 +35589,12 @@ __export(auditLogger_exports, {
   AuditLogger: () => AuditLogger
 });
 import { promises as fs15 } from "node:fs";
-import path25 from "node:path";
+import path27 from "node:path";
 import os7 from "node:os";
 function defaultAuditPath() {
   const override = process.env.ANATHEMA_AUDIT_LOG;
   if (override && override.trim().length > 0) return override;
-  return path25.join(os7.tmpdir(), "zelari-code", "audit.jsonl");
+  return path27.join(os7.tmpdir(), "zelari-code", "audit.jsonl");
 }
 function redactArgs(args) {
   const redacted = {};
@@ -34896,7 +35637,7 @@ var init_auditLogger = __esm({
       async append(entry) {
         const line = JSON.stringify(entry) + "\n";
         this.writeQueue = this.writeQueue.then(async () => {
-          await fs15.mkdir(path25.dirname(this.logPath), { recursive: true });
+          await fs15.mkdir(path27.dirname(this.logPath), { recursive: true });
           await fs15.appendFile(this.logPath, line, "utf-8");
         });
         return this.writeQueue;
@@ -34940,25 +35681,10 @@ var init_auditLogger = __esm({
   }
 });
 
-// src/cli/utils/cmdline.ts
-function quoteCmdArg(arg) {
-  if (arg === "") return '""';
-  if (!/[\s"^&|<>()%!]/.test(arg)) return arg;
-  return `"${arg.replace(/"/g, '""')}"`;
-}
-function buildCmdLine(command, args) {
-  return [command, ...args].map(quoteCmdArg).join(" ");
-}
-var init_cmdline = __esm({
-  "src/cli/utils/cmdline.ts"() {
-    "use strict";
-  }
-});
-
 // src/cli/diagnostics/engine.ts
-import { spawn as spawn5 } from "node:child_process";
-import { existsSync as existsSync14 } from "node:fs";
-import path26 from "node:path";
+import { spawn as spawn6 } from "node:child_process";
+import { existsSync as existsSync15 } from "node:fs";
+import path28 from "node:path";
 function parseEslintJson(stdout, _file2) {
   const json2 = safeJson(stdout);
   if (!Array.isArray(json2)) return [];
@@ -35017,7 +35743,7 @@ function safeJson(s) {
   }
 }
 function providerForFile(file2, providers = DEFAULT_PROVIDERS) {
-  const ext = path26.extname(file2).toLowerCase();
+  const ext = path28.extname(file2).toLowerCase();
   return providers.find((p3) => p3.extensions.includes(ext)) ?? null;
 }
 function resolveBin(bin, cwd) {
@@ -35025,10 +35751,10 @@ function resolveBin(bin, cwd) {
   let dir = cwd;
   for (let i = 0; i < 6; i += 1) {
     for (const suffix of suffixes) {
-      const candidate = path26.join(dir, "node_modules", ".bin", `${bin}${suffix}`);
-      if (existsSync14(candidate)) return candidate;
+      const candidate = path28.join(dir, "node_modules", ".bin", `${bin}${suffix}`);
+      if (existsSync15(candidate)) return candidate;
     }
-    const parent = path26.dirname(dir);
+    const parent = path28.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -35101,7 +35827,7 @@ var init_engine2 = __esm({
       };
       let child;
       try {
-        child = process.platform === "win32" ? spawn5(buildCmdLine(cmd, args), { cwd: opts.cwd, shell: true }) : spawn5(cmd, args, { cwd: opts.cwd });
+        child = process.platform === "win32" ? spawn6(buildCmdLine(cmd, args), { cwd: opts.cwd, shell: true }) : spawn6(cmd, args, { cwd: opts.cwd });
       } catch {
         done({ code: null, stdout: "", stderr: "" });
         return;
@@ -35132,19 +35858,19 @@ var init_engine2 = __esm({
 });
 
 // src/cli/tools/krakenRadio.ts
-import { appendFileSync as appendFileSync3, existsSync as existsSync15, mkdirSync as mkdirSync8, readFileSync as readFileSync14, readdirSync as readdirSync2 } from "node:fs";
-import path27 from "node:path";
+import { appendFileSync as appendFileSync3, existsSync as existsSync16, mkdirSync as mkdirSync8, readFileSync as readFileSync14, readdirSync as readdirSync2 } from "node:fs";
+import path29 from "node:path";
 function radioDir(cwd) {
-  return path27.join(cwd, ".zelari", "radio");
+  return path29.join(cwd, ".zelari", "radio");
 }
 function radioPath(cwd, sessionId2) {
   const safe = (sessionId2 || "default").replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 80);
-  return path27.join(radioDir(cwd), `${safe}.jsonl`);
+  return path29.join(radioDir(cwd), `${safe}.jsonl`);
 }
 function appendKrakenRadio(cwd, sessionId2, event) {
   try {
     const dir = radioDir(cwd);
-    if (!existsSync15(dir)) mkdirSync8(dir, { recursive: true });
+    if (!existsSync16(dir)) mkdirSync8(dir, { recursive: true });
     const row = {
       ts: event.ts ?? (/* @__PURE__ */ new Date()).toISOString(),
       kind: event.kind,
@@ -35165,7 +35891,7 @@ function appendKrakenRadio(cwd, sessionId2, event) {
 function readKrakenRadio(cwd, sessionId2, limit = 50) {
   try {
     const file2 = radioPath(cwd, sessionId2);
-    if (!existsSync15(file2)) return [];
+    if (!existsSync16(file2)) return [];
     const lines = readFileSync14(file2, "utf8").split(/\r?\n/).filter(Boolean);
     const slice = lines.slice(-Math.max(1, limit));
     const out = [];
@@ -35189,7 +35915,7 @@ function formatKrakenRadioStatus(cwd, sessionId2, limit = 12) {
     const flag = e.ok === false ? "\u2717" : e.ok === true ? "\u2713" : "\xB7";
     const ms = e.durationMs != null ? ` ${e.durationMs}ms` : "";
     const model = e.model ? ` [${e.model}]` : "";
-    const wt = e.worktree ? ` wt=${path27.basename(e.worktree)}` : "";
+    const wt = e.worktree ? ` wt=${path29.basename(e.worktree)}` : "";
     const detail = e.detail ? ` \u2014 ${e.detail.slice(0, 120)}` : "";
     return `${flag} ${e.ts.slice(11, 19)} ${e.kind} ${e.agent} "${e.description}"${model}${wt}${ms}${detail}`;
   });
@@ -35203,8 +35929,8 @@ var init_krakenRadio = __esm({
 
 // src/cli/tools/krakenWorktree.ts
 import { execFile as execFile2 } from "node:child_process";
-import { existsSync as existsSync16, mkdirSync as mkdirSync9, rmSync } from "node:fs";
-import path28 from "node:path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync9, rmSync } from "node:fs";
+import path30 from "node:path";
 import { promisify } from "node:util";
 import { randomBytes as randomBytes3 } from "node:crypto";
 function isKrakenWorktreeEnabled(env = process.env) {
@@ -35252,10 +35978,10 @@ async function createKrakenWorktree(cwd, label) {
   const id = `${Date.now().toString(36)}-${randomBytes3(3).toString("hex")}`;
   const slug = (label ?? "task").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 24) || "task";
   const branch = `kraken/${slug}-${id}`;
-  const wtRoot = path28.join(repoRoot, ".zelari", "worktrees");
-  const wtPath = path28.join(wtRoot, `kraken-${id}`);
+  const wtRoot = path30.join(repoRoot, ".zelari", "worktrees");
+  const wtPath = path30.join(wtRoot, `kraken-${id}`);
   try {
-    if (!existsSync16(wtRoot)) mkdirSync9(wtRoot, { recursive: true });
+    if (!existsSync17(wtRoot)) mkdirSync9(wtRoot, { recursive: true });
   } catch {
     return null;
   }
@@ -35367,7 +36093,7 @@ async function cleanupKrakenWorktree(handle, env = process.env) {
   if (shouldKeepWorktree(env)) return;
   await git2(handle.repoRoot, ["worktree", "remove", "--force", handle.path]);
   try {
-    if (existsSync16(handle.path)) {
+    if (existsSync17(handle.path)) {
       rmSync(handle.path, { recursive: true, force: true });
     }
   } catch {
@@ -36704,7 +37430,7 @@ var init_askUser = __esm({
 });
 
 // src/cli/skillsMd.ts
-import { existsSync as existsSync17, readdirSync as readdirSync3, readFileSync as readFileSync15 } from "node:fs";
+import { existsSync as existsSync18, readdirSync as readdirSync3, readFileSync as readFileSync15 } from "node:fs";
 import { join as join12 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 function skillMdSearchDirs(projectRoot = process.cwd()) {
@@ -36770,7 +37496,7 @@ function loadSkillMdSkills(projectRoot = process.cwd(), options = {}) {
   const summary = { loaded: [], skipped: [] };
   const seen = new Set(options.existingIds ?? []);
   for (const dir of skillMdSearchDirs(projectRoot)) {
-    if (!existsSync17(dir)) continue;
+    if (!existsSync18(dir)) continue;
     let entries;
     try {
       entries = readdirSync3(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
@@ -36779,7 +37505,7 @@ function loadSkillMdSkills(projectRoot = process.cwd(), options = {}) {
     }
     for (const entry of entries) {
       const skillPath = join12(dir, entry, "SKILL.md");
-      if (!existsSync17(skillPath)) continue;
+      if (!existsSync18(skillPath)) continue;
       try {
         const parsed = parseSkillMd(readFileSync15(skillPath, "utf8"), skillPath);
         if (!parsed) {
@@ -36954,14 +37680,14 @@ var init_todoTools = __esm({
 import {
   mkdirSync as mkdirSync10,
   writeFileSync as writeFileSync12,
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   accessSync,
   constants,
   realpathSync
 } from "node:fs";
 import { join as join13, basename } from "node:path";
 import { homedir as homedir5 } from "node:os";
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 function resolveWorkspaceRoot(projectRoot = process.cwd()) {
   const candidates = [
     join13(projectRoot, ".zelari"),
@@ -36977,11 +37703,11 @@ function resolveWorkspaceRoot(projectRoot = process.cwd()) {
   return candidates[0];
 }
 function hashProject(projectPath) {
-  return createHash7("sha1").update(realpathSync(projectPath)).digest("hex").slice(0, 12);
+  return createHash8("sha1").update(realpathSync(projectPath)).digest("hex").slice(0, 12);
 }
 function isWritableDir(dir) {
   try {
-    if (!existsSync18(dir)) return false;
+    if (!existsSync19(dir)) return false;
     accessSync(dir, constants.W_OK);
     return true;
   } catch {
@@ -36990,9 +37716,9 @@ function isWritableDir(dir) {
 }
 function ensureWorkspaceDir(workspaceDir) {
   mkdirSync10(workspaceDir, { recursive: true });
-  if (workspaceDir.endsWith("/.zelari") && existsSync18(join13(workspaceDir, "..", ".git"))) {
+  if (workspaceDir.endsWith("/.zelari") && existsSync19(join13(workspaceDir, "..", ".git"))) {
     const gitignorePath = join13(workspaceDir, ".gitignore");
-    if (!existsSync18(gitignorePath)) {
+    if (!existsSync19(gitignorePath)) {
       writeFileSync12(gitignorePath, "*\n!.gitignore\n");
     }
   }
@@ -37032,7 +37758,7 @@ __export(storage_exports, {
 import {
   readFileSync as readFileSync16,
   writeFileSync as writeFileSync13,
-  existsSync as existsSync19,
+  existsSync as existsSync20,
   mkdirSync as mkdirSync11,
   readdirSync as readdirSync4,
   renameSync as renameSync2
@@ -37292,7 +38018,7 @@ var init_storage = __esm({
     Storage = class {
       /** Read a Markdown file with frontmatter. Throws if not found. */
       read(path65) {
-        if (!existsSync19(path65)) {
+        if (!existsSync20(path65)) {
           throw new Error(`File not found: ${path65}`);
         }
         const md = readFileSync16(path65, "utf8");
@@ -37300,7 +38026,7 @@ var init_storage = __esm({
       }
       /** Read a Markdown file; returns null if not found. */
       readIfExists(path65) {
-        if (!existsSync19(path65)) return null;
+        if (!existsSync20(path65)) return null;
         return this.read(path65);
       }
       /**
@@ -37316,7 +38042,7 @@ var init_storage = __esm({
       }
       /** List all .md files in a directory (non-recursive). */
       listMarkdown(dir) {
-        if (!existsSync19(dir)) return [];
+        if (!existsSync20(dir)) return [];
         return readdirSync4(dir).filter((f) => f.endsWith(".md") && !f.startsWith(".")).map((f) => join14(dir, f));
       }
     };
@@ -37349,7 +38075,7 @@ var init_storage = __esm({
 // src/cli/workspace/planStore.ts
 import {
   copyFileSync,
-  existsSync as existsSync20,
+  existsSync as existsSync21,
   mkdirSync as mkdirSync12,
   readFileSync as readFileSync17,
   renameSync as renameSync3,
@@ -37400,7 +38126,7 @@ function writePlanTaskArtifact(rootDir, task) {
 }
 function loadHandle(rootDir) {
   const jsonPath = join15(rootDir, "plan.json");
-  if (!existsSync20(jsonPath)) {
+  if (!existsSync21(jsonPath)) {
     return { rootDir, tasks: [], counter: 0, rootFields: {} };
   }
   let parsed;
@@ -37435,7 +38161,7 @@ function saveHandle(rootDir, handle) {
   }
   const jsonPath = join15(rootDir, "plan.json");
   mkdirSync12(rootDir, { recursive: true });
-  if (existsSync20(jsonPath)) {
+  if (existsSync21(jsonPath)) {
     copyFileSync(jsonPath, `${jsonPath}.bak`);
   }
   const file2 = {
@@ -37717,8 +38443,8 @@ var init_planTaskTools = __esm({
 
 // src/cli/tools/inspectTypecheckSafety.ts
 import { promises as fs16 } from "node:fs";
-import path29 from "node:path";
-import { spawn as spawn6 } from "node:child_process";
+import path31 from "node:path";
+import { spawn as spawn7 } from "node:child_process";
 async function scanTsbuildinfo(root) {
   const found = [];
   const stack = [root];
@@ -37731,11 +38457,11 @@ async function scanTsbuildinfo(root) {
       continue;
     }
     for (const entry of entries) {
-      const p3 = path29.join(dir, entry.name);
+      const p3 = path31.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (!SCAN_SKIP.has(entry.name)) stack.push(p3);
       } else if (entry.name.endsWith(".tsbuildinfo")) {
-        found.push(path29.relative(root, p3).split(path29.sep).join("/"));
+        found.push(path31.relative(root, p3).split(path31.sep).join("/"));
       }
     }
   }
@@ -37744,7 +38470,7 @@ async function scanTsbuildinfo(root) {
 }
 async function gitStatusPorcelain(root) {
   return new Promise((resolve3) => {
-    const child = spawn6("git", ["status", "--porcelain"], { cwd: root, shell: false });
+    const child = spawn7("git", ["status", "--porcelain"], { cwd: root, shell: false });
     let out = "";
     child.stdout.on("data", (d) => out += d.toString());
     child.stderr.on("data", (d) => out += d.toString());
@@ -37771,7 +38497,7 @@ async function cleanupArtifacts(root, relPaths) {
   const failed = [];
   for (const rel2 of relPaths) {
     try {
-      await fs16.unlink(path29.join(root, rel2));
+      await fs16.unlink(path31.join(root, rel2));
       cleaned.push(rel2);
     } catch {
       failed.push(rel2);
@@ -37794,17 +38520,17 @@ var init_inspectTypecheckSafety = __esm({
 });
 
 // src/cli/tools/inspectCommand.ts
-import { spawn as spawn7 } from "node:child_process";
-import { createHash as createHash8 } from "node:crypto";
-import { existsSync as existsSync21, promises as fs17 } from "node:fs";
+import { spawn as spawn8 } from "node:child_process";
+import { createHash as createHash9 } from "node:crypto";
+import { existsSync as existsSync22, promises as fs17 } from "node:fs";
 import os8 from "node:os";
-import path30 from "node:path";
+import path32 from "node:path";
 function resolveNodeModuleBin(start, rel2) {
-  let dir = path30.resolve(start);
+  let dir = path32.resolve(start);
   for (; ; ) {
-    const candidate = path30.join(dir, "node_modules", rel2);
-    if (existsSync21(candidate)) return candidate;
-    const parent = path30.dirname(dir);
+    const candidate = path32.join(dir, "node_modules", rel2);
+    if (existsSync22(candidate)) return candidate;
+    const parent = path32.dirname(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -37872,7 +38598,7 @@ function buildInspectCommand(op, ctx) {
     case "npm_ls":
     case "npm_outdated":
     case "npm_view": {
-      const npmCli = ctx.npmCliPath ?? resolveNodeModuleBin(ctx.root, path30.join("npm", "bin", "npm-cli.js")) ?? path30.join(ctx.root, "node_modules", "npm", "bin", "npm-cli.js");
+      const npmCli = ctx.npmCliPath ?? resolveNodeModuleBin(ctx.root, path32.join("npm", "bin", "npm-cli.js")) ?? path32.join(ctx.root, "node_modules", "npm", "bin", "npm-cli.js");
       if (op.operation === "npm_view") {
         const err = rejectFlagLike("package", op.package);
         if (err) return { ok: false, reason: err };
@@ -37881,14 +38607,14 @@ function buildInspectCommand(op, ctx) {
       return { ok: true, command: process.execPath, argv: [npmCli, ...sub], inspectionClass: "env-info" };
     }
     case "typecheck": {
-      const project = path30.resolve(ctx.cwd, op.project ?? "tsconfig.json");
-      const hash3 = createHash8("sha256").update(project).digest("hex").slice(0, 16);
-      const tsBuildInfoFile = path30.join(os8.tmpdir(), "zelari-inspect", `${hash3}.tsbuildinfo`);
+      const project = path32.resolve(ctx.cwd, op.project ?? "tsconfig.json");
+      const hash3 = createHash9("sha256").update(project).digest("hex").slice(0, 16);
+      const tsBuildInfoFile = path32.join(os8.tmpdir(), "zelari-inspect", `${hash3}.tsbuildinfo`);
       return {
         ok: true,
         command: process.execPath,
         argv: [
-          ctx.tscPath ?? resolveNodeModuleBin(ctx.root, path30.join("typescript", "bin", "tsc")) ?? resolveNodeModuleBin(ctx.cwd, path30.join("typescript", "bin", "tsc")) ?? path30.join(ctx.root, "node_modules", "typescript", "bin", "tsc"),
+          ctx.tscPath ?? resolveNodeModuleBin(ctx.root, path32.join("typescript", "bin", "tsc")) ?? resolveNodeModuleBin(ctx.cwd, path32.join("typescript", "bin", "tsc")) ?? path32.join(ctx.root, "node_modules", "typescript", "bin", "tsc"),
           "--noEmit",
           // S3.5 primary mechanism: redirect, never disable — composite forces
           // incremental (TS#30661), so --incremental false would break on the
@@ -37910,7 +38636,7 @@ function runSpawn(command, argv, opts) {
   return new Promise((resolve3) => {
     let child;
     try {
-      child = spawn7(command, argv, { cwd: opts.cwd, shell: false });
+      child = spawn8(command, argv, { cwd: opts.cwd, shell: false });
     } catch (err) {
       resolve3({ code: null, stdout: "", stderr: String(err), timedOut: false, spawnError: String(err) });
       return;
@@ -38648,9 +39374,9 @@ var init_client = __esm({
 });
 
 // src/cli/lsp/servers.ts
-import path31 from "node:path";
+import path33 from "node:path";
 function languageIdForFile(file2) {
-  const ext = path31.extname(file2).toLowerCase();
+  const ext = path33.extname(file2).toLowerCase();
   const map2 = {
     ".ts": "typescript",
     ".tsx": "typescriptreact",
@@ -38665,7 +39391,7 @@ function languageIdForFile(file2) {
   return map2[ext] ?? "plaintext";
 }
 function serverForFile(file2, servers = LSP_SERVERS) {
-  const ext = path31.extname(file2).toLowerCase();
+  const ext = path33.extname(file2).toLowerCase();
   return servers.find((s) => s.extensions.includes(ext)) ?? null;
 }
 function resolveServerCommand(file2, cwd, servers = LSP_SERVERS) {
@@ -38714,7 +39440,7 @@ var init_servers = __esm({
 });
 
 // src/cli/lsp/manager.ts
-import { spawn as spawn8 } from "node:child_process";
+import { spawn as spawn9 } from "node:child_process";
 import { readFileSync as readFileSync18 } from "node:fs";
 function processTransport(child) {
   return {
@@ -38850,7 +39576,7 @@ var init_manager = __esm({
       // languages already flagged as unavailable
       constructor(options = {}) {
         this.cwd = options.cwd ?? process.cwd();
-        this.spawnImpl = options.spawnImpl ?? spawn8;
+        this.spawnImpl = options.spawnImpl ?? spawn9;
         this.timeoutMs = options.timeoutMs ?? 15e3;
         this.onWarn = options.onWarn ?? ((m) => console.error(m));
       }
@@ -39041,7 +39767,7 @@ var init_manager = __esm({
 
 // src/cli/ast/engine.ts
 import { readFile } from "node:fs/promises";
-import path32 from "node:path";
+import path34 from "node:path";
 function loadTs() {
   if (!tsPromise) {
     tsPromise = import("typescript").then((m) => m.default ?? m).catch(() => null);
@@ -39052,8 +39778,8 @@ function errMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
 async function parseFileSymbolsDiag(file2, cwd) {
-  const resolvedPath = path32.isAbsolute(file2) ? file2 : path32.join(cwd ?? process.cwd(), file2);
-  const extension = path32.extname(resolvedPath).toLowerCase();
+  const resolvedPath = path34.isAbsolute(file2) ? file2 : path34.join(cwd ?? process.cwd(), file2);
+  const extension = path34.extname(resolvedPath).toLowerCase();
   if (!TS_EXTENSIONS.has(extension)) {
     return {
       status: "unsupported-extension",
@@ -39095,7 +39821,7 @@ async function parseFileSymbolsDiag(file2, cwd) {
   }
   let source;
   try {
-    source = ts.createSourceFile(path32.basename(resolvedPath), text, ts.ScriptTarget.Latest, true);
+    source = ts.createSourceFile(path34.basename(resolvedPath), text, ts.ScriptTarget.Latest, true);
   } catch (err) {
     return {
       status: "parse-error",
@@ -39318,13 +40044,13 @@ var init_store2 = __esm({
 });
 
 // src/cli/semantic/index.ts
-import { promises as fs18, existsSync as existsSync22, readFileSync as readFileSync19 } from "node:fs";
+import { promises as fs18, existsSync as existsSync23, readFileSync as readFileSync19 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import path33 from "node:path";
-import { createHash as createHash9 } from "node:crypto";
+import path35 from "node:path";
+import { createHash as createHash10 } from "node:crypto";
 function getIndexPath(root) {
-  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`);
+  const hash3 = createHash10("sha1").update(path35.resolve(root)).digest("hex").slice(0, 16);
+  return process.env.ZELARI_SEMANTIC_FILE ?? path35.join(homedir6(), ".tmp", "zelari-code", "semantic", `${hash3}.json`);
 }
 async function collectSourceFiles(root, maxFiles = 1500) {
   const out = [];
@@ -39342,11 +40068,11 @@ async function collectSourceFiles(root, maxFiles = 1500) {
         if (entry.isDirectory() && IGNORE_DIRS.has(entry.name)) continue;
         if (entry.isDirectory()) continue;
       }
-      const full = path33.join(dir, entry.name);
+      const full = path35.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (IGNORE_DIRS.has(entry.name)) continue;
         await walk2(full);
-      } else if (SOURCE_EXTENSIONS.has(path33.extname(entry.name).toLowerCase())) {
+      } else if (SOURCE_EXTENSIONS.has(path35.extname(entry.name).toLowerCase())) {
         out.push(full);
       }
     }
@@ -39395,14 +40121,14 @@ async function buildIndex(files, embed, options) {
 }
 async function saveIndex(root, data) {
   const file2 = getIndexPath(root);
-  await fs18.mkdir(path33.dirname(file2), { recursive: true });
+  await fs18.mkdir(path35.dirname(file2), { recursive: true });
   const tmp = `${file2}.tmp-${process.pid}`;
   await fs18.writeFile(tmp, JSON.stringify(data), "utf8");
   await fs18.rename(tmp, file2);
 }
 function loadIndex(root) {
   const file2 = getIndexPath(root);
-  if (!existsSync22(file2)) return null;
+  if (!existsSync23(file2)) return null;
   try {
     const parsed = JSON.parse(readFileSync19(file2, "utf8"));
     if (parsed && Array.isArray(parsed.chunks)) return parsed;
@@ -39547,7 +40273,7 @@ var init_provider = __esm({
 });
 
 // src/cli/semantic/tools.ts
-import path34 from "node:path";
+import path36 from "node:path";
 function createSemanticTool(deps) {
   const buildEmbedFn = deps.buildEmbedFn ?? buildProviderEmbedFn;
   return {
@@ -39574,7 +40300,7 @@ function createSemanticTool(deps) {
       return typedOk({
         count: res.hits.length,
         results: res.hits.map((h) => ({
-          location: `${path34.relative(deps.root, h.file) || h.file}:${h.startLine}-${h.endLine}`,
+          location: `${path36.relative(deps.root, h.file) || h.file}:${h.startLine}-${h.endLine}`,
           score: Number(h.score.toFixed(3)),
           preview: h.text.length > 400 ? `${h.text.slice(0, 400)}\u2026` : h.text
         }))
@@ -39593,8 +40319,8 @@ var init_tools4 = __esm({
 });
 
 // src/cli/browser/driver.ts
-import { createRequire } from "node:module";
-import path35 from "node:path";
+import { createRequire as createRequire2 } from "node:module";
+import path37 from "node:path";
 import { pathToFileURL } from "node:url";
 function asPlaywright(mod) {
   if (!mod || typeof mod !== "object") return null;
@@ -39605,10 +40331,10 @@ function asPlaywright(mod) {
   return null;
 }
 async function loadPlaywright(cwd) {
-  const base = cwd && cwd.length > 0 ? path35.resolve(cwd) : void 0;
+  const base = cwd && cwd.length > 0 ? path37.resolve(cwd) : void 0;
   if (base) {
     try {
-      const req = createRequire(path35.join(base, "package.json"));
+      const req = createRequire2(path37.join(base, "package.json"));
       const resolved = req.resolve("playwright");
       const mod = await import(pathToFileURL(resolved).href);
       const pw = asPlaywright(mod);
@@ -39823,7 +40549,7 @@ var init_driver = __esm({
 });
 
 // src/cli/browser/tools.ts
-import path36 from "node:path";
+import path38 from "node:path";
 import os9 from "node:os";
 function createBrowserTool(deps = {}) {
   return {
@@ -39842,7 +40568,7 @@ function createBrowserTool(deps = {}) {
     execute: async (args, ctx) => {
       const a = args;
       const dir = deps.screenshotDir ?? os9.tmpdir();
-      const screenshotPath = a.screenshot === false ? void 0 : path36.join(dir, `zelari-browser-${Date.now()}.png`);
+      const screenshotPath = a.screenshot === false ? void 0 : path38.join(dir, `zelari-browser-${Date.now()}.png`);
       const result = await runBrowserCheck(
         {
           url: a.url,
@@ -39934,14 +40660,14 @@ __export(targets_exports, {
 });
 import {
   chmodSync,
-  existsSync as existsSync23,
+  existsSync as existsSync24,
   mkdirSync as mkdirSync13,
   readFileSync as readFileSync20,
   writeFileSync as writeFileSync15
 } from "node:fs";
 import { dirname as dirname4, join as join16 } from "node:path";
 import { homedir as homedir7 } from "node:os";
-import { spawn as spawn9 } from "node:child_process";
+import { spawn as spawn10 } from "node:child_process";
 function getSshTargetsPath() {
   return join16(homedir7(), ".zelari-code", "ssh-targets.json");
 }
@@ -39955,7 +40681,7 @@ function normalizeAuth(auth) {
 }
 function readSecrets() {
   const path65 = getSshSecretsPath();
-  if (!existsSync23(path65)) return {};
+  if (!existsSync24(path65)) return {};
   try {
     return JSON.parse(readFileSync20(path65, "utf8"));
   } catch {
@@ -39998,7 +40724,7 @@ function deleteSshPassword(id) {
 }
 function readStore2() {
   const path65 = getSshTargetsPath();
-  if (!existsSync23(path65)) return [];
+  if (!existsSync24(path65)) return [];
   try {
     const parsed = JSON.parse(readFileSync20(path65, "utf8"));
     const list = Array.isArray(parsed.targets) ? parsed.targets : [];
@@ -40171,7 +40897,7 @@ function runSsh(target, remoteCommand, timeoutMs2 = 6e4) {
       if (!env.DISPLAY) env.DISPLAY = "1";
       env.ZELARI_SSH_ASKPASS_PASS = pass;
     }
-    const child = spawn9("ssh", args, {
+    const child = spawn10("ssh", args, {
       windowsHide: true,
       env,
       stdio: ["ignore", "pipe", "pipe"]
@@ -40212,7 +40938,7 @@ function readSshPublicKey(keyOrPubPath) {
   if (!raw) return { ok: false, error: "Empty path" };
   const candidates = raw.endsWith(".pub") ? [raw] : [`${raw}.pub`, raw];
   for (const p3 of candidates) {
-    if (!existsSync23(p3)) continue;
+    if (!existsSync24(p3)) continue;
     try {
       const content = readFileSync20(p3, "utf8").trim();
       if (!content) continue;
@@ -40396,10 +41122,10 @@ var init_tools6 = __esm({
 
 // src/cli/workspace/worldModel.ts
 import { promises as fs19 } from "node:fs";
-import path37 from "node:path";
-import { spawn as spawn10 } from "node:child_process";
+import path39 from "node:path";
+import { spawn as spawn11 } from "node:child_process";
 function worldDir(cwd) {
-  return path37.join(cwd, WORLD_DIR_NAME);
+  return path39.join(cwd, WORLD_DIR_NAME);
 }
 async function ensureWorldDir(cwd) {
   const dir = worldDir(cwd);
@@ -40409,10 +41135,10 @@ async function ensureWorldDir(cwd) {
 async function appendTimeline(cwd, entry) {
   const dir = await ensureWorldDir(cwd);
   const line = JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry }) + "\n";
-  await fs19.appendFile(path37.join(dir, TIMELINE_FILE), line, "utf8");
+  await fs19.appendFile(path39.join(dir, TIMELINE_FILE), line, "utf8");
 }
 async function readChecks(cwd) {
-  const p3 = path37.join(worldDir(cwd), CHECKS_FILE);
+  const p3 = path39.join(worldDir(cwd), CHECKS_FILE);
   try {
     const raw = await fs19.readFile(p3, "utf8");
     const parsed = JSON.parse(raw);
@@ -40424,7 +41150,7 @@ async function readChecks(cwd) {
 function runShell(command, cwd, timeoutMs2, signal) {
   return new Promise((resolve3) => {
     const isWin = process.platform === "win32";
-    const child = spawn10(isWin ? "cmd.exe" : "/bin/sh", isWin ? ["/c", command] : ["-c", command], {
+    const child = spawn11(isWin ? "cmd.exe" : "/bin/sh", isWin ? ["/c", command] : ["-c", command], {
       cwd,
       env: process.env,
       windowsHide: true,
@@ -40487,8 +41213,8 @@ function runShell(command, cwd, timeoutMs2, signal) {
   });
 }
 async function runBacktest(cwd, signal) {
-  const checksPath = path37.join(worldDir(cwd), CHECKS_FILE);
-  const hypothesisPath = path37.join(worldDir(cwd), HYPOTHESIS_FILE);
+  const checksPath = path39.join(worldDir(cwd), CHECKS_FILE);
+  const hypothesisPath = path39.join(worldDir(cwd), HYPOTHESIS_FILE);
   const checks = await readChecks(cwd);
   if (checks.length === 0) {
     return {
@@ -40557,7 +41283,7 @@ var init_worldModel = __esm({
     "use strict";
     init_zod();
     init_toolTypes();
-    WORLD_DIR_NAME = path37.join(".zelari", "world");
+    WORLD_DIR_NAME = path39.join(".zelari", "world");
     HYPOTHESIS_FILE = "hypothesis.md";
     CHECKS_FILE = "checks.json";
     TIMELINE_FILE = "timeline.jsonl";
@@ -40574,7 +41300,7 @@ var init_worldModel = __esm({
       execute: async (args, ctx) => {
         try {
           const dir = await ensureWorldDir(ctx.cwd);
-          const file2 = path37.join(dir, HYPOTHESIS_FILE);
+          const file2 = path39.join(dir, HYPOTHESIS_FILE);
           if (args.append) {
             const block = `
 
@@ -40613,7 +41339,7 @@ ${args.content}
       execute: async (args, ctx) => {
         try {
           const dir = await ensureWorldDir(ctx.cwd);
-          const file2 = path37.join(dir, CHECKS_FILE);
+          const file2 = path39.join(dir, CHECKS_FILE);
           const body = { checks: args.checks };
           await fs19.writeFile(file2, JSON.stringify(body, null, 2) + "\n", "utf8");
           await appendTimeline(ctx.cwd, { kind: "checks_set", count: args.checks.length });
@@ -40652,8 +41378,8 @@ ${args.content}
                 stdoutPreview: "(dryRun)",
                 mismatch: "dryRun"
               })),
-              hypothesisPath: path37.join(worldDir(ctx.cwd), HYPOTHESIS_FILE),
-              checksPath: path37.join(worldDir(ctx.cwd), CHECKS_FILE)
+              hypothesisPath: path39.join(worldDir(ctx.cwd), HYPOTHESIS_FILE),
+              checksPath: path39.join(worldDir(ctx.cwd), CHECKS_FILE)
             });
           }
           const result = await runBacktest(ctx.cwd, ctx.signal);
@@ -40677,7 +41403,7 @@ ${args.content}
       execute: async (args, ctx) => {
         try {
           const dir = await ensureWorldDir(ctx.cwd);
-          const file2 = path37.join(dir, TIMELINE_FILE);
+          const file2 = path39.join(dir, TIMELINE_FILE);
           await appendTimeline(ctx.cwd, {
             kind: args.kind,
             summary: args.summary,
@@ -40785,13 +41511,13 @@ __export(folderTrust_exports, {
   untrustFolder: () => untrustFolder
 });
 import { homedir as homedir8 } from "node:os";
-import { existsSync as existsSync24, mkdirSync as mkdirSync14, readFileSync as readFileSync21, writeFileSync as writeFileSync16 } from "node:fs";
-import path38 from "node:path";
+import { existsSync as existsSync25, mkdirSync as mkdirSync14, readFileSync as readFileSync21, writeFileSync as writeFileSync16 } from "node:fs";
+import path40 from "node:path";
 function trustStorePath() {
-  return _overrideStorePath ?? path38.join(homedir8(), ".zelari-code", "trust.json");
+  return _overrideStorePath ?? path40.join(homedir8(), ".zelari-code", "trust.json");
 }
 function normalize4(p3) {
-  const resolved = path38.resolve(p3);
+  const resolved = path40.resolve(p3);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function readStore3() {
@@ -40807,7 +41533,7 @@ function readStore3() {
 function writeStore3(store6) {
   const p3 = trustStorePath();
   try {
-    mkdirSync14(path38.dirname(p3), { recursive: true });
+    mkdirSync14(path40.dirname(p3), { recursive: true });
     writeFileSync16(p3, JSON.stringify(store6, null, 2), "utf8");
   } catch (err) {
     throw new Error(
@@ -40833,7 +41559,7 @@ function isFolderTrusted(folderPath) {
 }
 function trustFolder(folderPath) {
   const store6 = readStore3();
-  const normalized = path38.resolve(folderPath);
+  const normalized = path40.resolve(folderPath);
   if (!store6.folders.some((f) => normalize4(f.path) === normalize4(normalized))) {
     store6.folders.push({ path: normalized, trustedAt: (/* @__PURE__ */ new Date()).toISOString() });
     writeStore3(store6);
@@ -40863,7 +41589,7 @@ function getTrustStorePath() {
   return trustStorePath();
 }
 function hasTrustStore() {
-  return existsSync24(trustStorePath());
+  return existsSync25(trustStorePath());
 }
 function _setTrustStorePathForTests(p3) {
   _overrideStorePath = p3;
@@ -40947,9 +41673,9 @@ var init_lifecycleHooks = __esm({
 });
 
 // src/cli/toolResultCache.ts
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 import { promises as fs20 } from "node:fs";
-import path39 from "node:path";
+import path41 from "node:path";
 function isToolCacheEnabled() {
   const raw = process.env.ZELARI_TOOL_CACHE;
   return raw !== "0" && raw !== "false" && raw !== "off";
@@ -40960,7 +41686,7 @@ function resolveToolCacheTtlMs() {
   return Number.isFinite(n) && n >= 0 ? n : TOOL_CACHE_DEFAULT_TTL_MS;
 }
 function hashKey(parts) {
-  return createHash10("sha256").update(JSON.stringify(parts), "utf8").digest("hex");
+  return createHash11("sha256").update(JSON.stringify(parts), "utf8").digest("hex");
 }
 function resultBytes(result) {
   try {
@@ -41034,7 +41760,7 @@ async function statKey(toolName, input, ctx) {
   if (!input || typeof input !== "object") return null;
   const rawPath = input.path;
   if (typeof rawPath !== "string" || rawPath.length === 0) return null;
-  const abs = path39.isAbsolute(rawPath) ? rawPath : path39.join(ctx.cwd, rawPath);
+  const abs = path41.isAbsolute(rawPath) ? rawPath : path41.join(ctx.cwd, rawPath);
   try {
     const st = await fs20.stat(abs);
     return hashKey({
@@ -41715,14 +42441,14 @@ var init_toolRegistry = __esm({
 });
 
 // src/cli/state/fileStateStore.ts
-import { createHash as createHash12, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash13, randomUUID as randomUUID2 } from "node:crypto";
 import { promises as fs21 } from "node:fs";
-import * as path41 from "node:path";
+import * as path43 from "node:path";
 function shortId() {
   return randomUUID2().replace(/-/g, "").slice(0, 12);
 }
 async function writeJsonAtomic(filePath, data) {
-  await fs21.mkdir(path41.dirname(filePath), { recursive: true });
+  await fs21.mkdir(path43.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
   await fs21.writeFile(tmp, JSON.stringify(data, null, 2) + "\n", "utf8");
   await fs21.rename(tmp, filePath);
@@ -41767,7 +42493,7 @@ async function getStateStore(projectRoot, env = process.env) {
   }
 }
 function hashStablePrompt(stable) {
-  return createHash12("sha256").update(stable, "utf8").digest("hex").slice(0, 16);
+  return createHash13("sha256").update(stable, "utf8").digest("hex").slice(0, 16);
 }
 var DEFAULT_MATERIALIZE_CHARS, FileDurableStateStore, NoopDurableStateStore;
 var init_fileStateStore = __esm({
@@ -41783,11 +42509,11 @@ var init_fileStateStore = __esm({
       indexPath = "";
       async init(projectRoot) {
         this.root = projectRoot;
-        this.stateDir = path41.join(projectRoot, ".zelari", "state");
-        this.commitsDir = path41.join(this.stateDir, "commits");
-        this.artifactsDir = path41.join(this.stateDir, "artifacts");
-        this.headPath = path41.join(this.stateDir, "HEAD.json");
-        this.indexPath = path41.join(this.stateDir, "index.jsonl");
+        this.stateDir = path43.join(projectRoot, ".zelari", "state");
+        this.commitsDir = path43.join(this.stateDir, "commits");
+        this.artifactsDir = path43.join(this.stateDir, "artifacts");
+        this.headPath = path43.join(this.stateDir, "HEAD.json");
+        this.indexPath = path43.join(this.stateDir, "index.jsonl");
         await fs21.mkdir(this.commitsDir, { recursive: true });
         await fs21.mkdir(this.artifactsDir, { recursive: true });
       }
@@ -41800,13 +42526,13 @@ var init_fileStateStore = __esm({
         const discoveries = input.discoveries ?? [];
         const parent = await this.head();
         const id = shortId();
-        const artifactRel = path41.join("artifacts", id);
-        const artifactAbs = path41.join(this.artifactsDir, id);
+        const artifactRel = path43.join("artifacts", id);
+        const artifactAbs = path43.join(this.artifactsDir, id);
         await fs21.mkdir(artifactAbs, { recursive: true });
         const summary = defaultSummary(input, discoveries);
-        await fs21.writeFile(path41.join(artifactAbs, "summary.md"), summary + "\n", "utf8");
-        await writeJsonAtomic(path41.join(artifactAbs, "discoveries.json"), discoveries);
-        await writeJsonAtomic(path41.join(artifactAbs, "verification.json"), input.verification);
+        await fs21.writeFile(path43.join(artifactAbs, "summary.md"), summary + "\n", "utf8");
+        await writeJsonAtomic(path43.join(artifactAbs, "discoveries.json"), discoveries);
+        await writeJsonAtomic(path43.join(artifactAbs, "verification.json"), input.verification);
         const meta3 = {
           id,
           parentId: parent?.id ?? null,
@@ -41818,14 +42544,14 @@ var init_fileStateStore = __esm({
           workspaceCheckpointId: input.workspaceCheckpointId,
           verification: {
             ...input.verification,
-            reportPath: input.verification.reportPath ?? path41.join(".zelari", "state", artifactRel, "verification.json").replace(/\\/g, "/")
+            reportPath: input.verification.reportPath ?? path43.join(".zelari", "state", artifactRel, "verification.json").replace(/\\/g, "/")
           },
           changedPaths: input.changedPaths ?? [],
           stablePromptHash: input.stablePromptHash,
           discoveryCount: discoveries.length,
           artifactDir: artifactRel.replace(/\\/g, "/")
         };
-        await writeJsonAtomic(path41.join(this.commitsDir, `${id}.json`), meta3);
+        await writeJsonAtomic(path43.join(this.commitsDir, `${id}.json`), meta3);
         await writeJsonAtomic(this.headPath, { id, updatedAt: meta3.createdAt });
         await fs21.appendFile(this.indexPath, JSON.stringify({ id, createdAt: meta3.createdAt, label: meta3.label }) + "\n", "utf8");
         return stripStored(meta3);
@@ -41836,7 +42562,7 @@ var init_fileStateStore = __esm({
         return this.get(head.id);
       }
       async get(id) {
-        const stored = await readJsonFile(path41.join(this.commitsDir, `${id}.json`));
+        const stored = await readJsonFile(path43.join(this.commitsDir, `${id}.json`));
         return stored ? stripStored(stored) : null;
       }
       async list(limit = 20) {
@@ -41875,9 +42601,9 @@ var init_fileStateStore = __esm({
       async loadDiscoveries(id) {
         const meta3 = id ? await this.get(id) : await this.head();
         if (!meta3) return [];
-        const stored = await readJsonFile(path41.join(this.commitsDir, `${meta3.id}.json`));
+        const stored = await readJsonFile(path43.join(this.commitsDir, `${meta3.id}.json`));
         if (!stored?.artifactDir) return [];
-        const discPath = path41.join(this.stateDir, stored.artifactDir, "discoveries.json");
+        const discPath = path43.join(this.stateDir, stored.artifactDir, "discoveries.json");
         return await readJsonFile(discPath) ?? [];
       }
       async materializeContext(id, maxChars = DEFAULT_MATERIALIZE_CHARS) {
@@ -42531,7 +43257,7 @@ __export(conversationContext_exports, {
   setHistory: () => setHistory,
   setLastClarification: () => setLastClarification
 });
-import { existsSync as existsSync25 } from "node:fs";
+import { existsSync as existsSync26 } from "node:fs";
 import { join as join19 } from "node:path";
 function getHistory() {
   return history;
@@ -42541,7 +43267,7 @@ function setHistory(messages) {
   history = projected === messages ? [...messages] : projected;
 }
 function compactInPlace(cwd = process.cwd()) {
-  const durableStatePresent = existsSync25(join19(cwd, ".zelari", "state", "HEAD.json"));
+  const durableStatePresent = existsSync26(join19(cwd, ".zelari", "state", "HEAD.json"));
   history = applySessionSurface(compactHistory(history, { durableStatePresent }));
 }
 function appendMessages(msgs) {
@@ -43124,7 +43850,6 @@ __export(headlessSpine_exports, {
   seedHeadlessModelHistory: () => seedHeadlessModelHistory,
   sessionStartedEvent: () => sessionStartedEvent
 });
-import path42 from "node:path";
 function sessionStartedEvent(handle) {
   return {
     type: "session_started",
@@ -43158,12 +43883,10 @@ async function openHeadlessSpine(opts) {
   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);
+      await restoreBudgetRuntimeFromSession(budget, opts.sessionId, opts.baseDir);
     }
     spine.attachBudgetRuntime(budget);
+    await noteHarnessLifecycle(spine, opts.sessionId, profileId, budget, opts.baseDir);
     spine.note("headless.profile", { profile: profileId, mode: opts.mode ?? "kraken" });
   }
   return {
@@ -43175,11 +43898,20 @@ async function openHeadlessSpine(opts) {
         spine.mirrorBrainEvent(ev);
       }
     },
+    beginResourceTurn() {
+      return spine.beginResourceTurn();
+    },
     userMessage(text) {
       spine.userMessage(text);
     },
-    gateResourceToolCall(toolName) {
-      return spine.gateResourceToolCall(toolName);
+    gateResourceToolCall(toolName, args) {
+      return spine.gateResourceToolCall(toolName, args);
+    },
+    resourceBudgetLimit() {
+      return spine.resourceBudgetLimit();
+    },
+    resourceBudgetSummary() {
+      return spine.resourceBudgetSummary();
     },
     verificationRun(payload) {
       spine.verificationRun(payload);
@@ -43253,7 +43985,7 @@ async function seedHeadlessModelHistory(handle, legacy) {
   }
   for (const m of legacySeed) {
     if (m.role === "user") {
-      mirror.userMessage(m.content);
+      mirror.userMessage(m.content, { beginResourceTurn: false, imported: "legacy-history" });
     } else {
       mirror.assistantMessage(m.content, { imported: "legacy-history" });
     }
@@ -43297,10 +44029,11 @@ var init_headlessSpine = __esm({
     init_dist();
     init_session();
     init_mission2();
-    init_session();
     init_runtime2();
     init_sessionSpine();
     init_budgetRuntime();
+    init_restoreRuntime();
+    init_sessionSpine();
     init_headless();
   }
 });
@@ -43444,7 +44177,7 @@ var claudeProvider_exports = {};
 __export(claudeProvider_exports, {
   createLocalCliProvider: () => createLocalCliProvider
 });
-import { spawn as spawn11 } from "node:child_process";
+import { spawn as spawn12 } from "node:child_process";
 function waitForExit(child, timeoutMs2 = 2e3) {
   return new Promise((resolve3) => {
     if (child.exitCode != null) return resolve3(child.exitCode);
@@ -43473,7 +44206,7 @@ function createLocalCliProvider(opts = {}) {
         );
       }
     }
-    const spawnFn = opts.spawnFn ?? spawn11;
+    const spawnFn = opts.spawnFn ?? spawn12;
     let child;
     try {
       child = spawnFn(cli, args, {
@@ -43568,12 +44301,12 @@ var init_claudeProvider = __esm({
 });
 
 // src/cli/workspace/projectInstructions.ts
-import { existsSync as existsSync26, readFileSync as readFileSync23 } from "node:fs";
+import { existsSync as existsSync27, readFileSync as readFileSync23 } from "node:fs";
 import { join as join20 } from "node:path";
 function loadProjectInstructions(projectRoot = process.cwd(), maxChars = MAX_CHARS) {
   for (const name of CANDIDATES) {
     const full = join20(projectRoot, name);
-    if (!existsSync26(full)) continue;
+    if (!existsSync27(full)) continue;
     try {
       let raw = readFileSync23(full, "utf8");
       raw = raw.replace(/\r\n/g, "\n").trim();
@@ -43619,7 +44352,7 @@ __export(workspaceSummary_exports, {
   buildWorkspaceSummary: () => buildWorkspaceSummary,
   buildZelariReadHint: () => buildZelariReadHint
 });
-import { existsSync as existsSync27, readFileSync as readFileSync24, readdirSync as readdirSync6, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync28, readFileSync as readFileSync24, readdirSync as readdirSync6, statSync as statSync5 } from "node:fs";
 import { join as join21, relative } from "node:path";
 function buildWorkspaceSummary(projectRoot = process.cwd(), options = {}) {
   const { maxEntries = 30, maxChars = 3500, maxDeps = 24, maxScripts = 16 } = options;
@@ -43654,7 +44387,7 @@ function formatTaskLine(t) {
 function buildPlanSummary(projectRoot = process.cwd(), options) {
   const zelariRoot = resolveWorkspaceRoot(projectRoot);
   const planPath = join21(zelariRoot, "plan.json");
-  if (!existsSync27(planPath)) return null;
+  if (!existsSync28(planPath)) return null;
   let plan;
   try {
     plan = JSON.parse(readFileSync24(planPath, "utf8"));
@@ -43797,7 +44530,7 @@ function pickNextTask(open) {
 }
 function buildZelariReadHint(projectRoot = process.cwd()) {
   const planPath = join21(resolveWorkspaceRoot(projectRoot), "plan.json");
-  if (!existsSync27(planPath)) return "";
+  if (!existsSync28(planPath)) return "";
   return [
     "# Council workspace detected (.zelari/) \u2014 DRAFT vault",
     "`.zelari/plan.json` and `.zelari/docs/` hold **design hypotheses**, not verified product state.",
@@ -43813,7 +44546,7 @@ function safeProjectName(root) {
 }
 function readPackageJson(projectRoot) {
   const p3 = join21(projectRoot, "package.json");
-  if (!existsSync27(p3)) return null;
+  if (!existsSync28(p3)) return null;
   try {
     return JSON.parse(readFileSync24(p3, "utf8"));
   } catch {
@@ -43917,12 +44650,12 @@ var init_workspaceSummary = __esm({
 });
 
 // src/cli/workspace/buildLessonsSummary.ts
-import { existsSync as existsSync28 } from "node:fs";
+import { existsSync as existsSync29 } from "node:fs";
 import { join as join22 } from "node:path";
 function buildLessonsSummary(projectRoot = process.cwd(), taskText) {
   if (process.env["ZELARI_LESSONS"] === "0") return null;
   const zelariRoot = resolveWorkspaceRoot(projectRoot);
-  if (!existsSync28(join22(zelariRoot, "lessons.jsonl"))) return null;
+  if (!existsSync29(join22(zelariRoot, "lessons.jsonl"))) return null;
   const lessons = recallLessons(zelariRoot, {
     maxLessons: 5,
     maxBytes: 2048,
@@ -43943,7 +44676,7 @@ var composeContext_exports = {};
 __export(composeContext_exports, {
   composeProjectContext: () => composeProjectContext
 });
-import { existsSync as existsSync29, readdirSync as readdirSync7, readFileSync as readFileSync25 } from "node:fs";
+import { existsSync as existsSync30, readdirSync as readdirSync7, readFileSync as readFileSync25 } from "node:fs";
 import { join as join23 } from "node:path";
 function cap2(text, max, label) {
   if (!text || text.length <= max) return { text: text || "", truncated: false };
@@ -43956,13 +44689,13 @@ function cap2(text, max, label) {
 }
 function buildDesignIndex(projectRoot, maxChars) {
   const root = resolveWorkspaceRoot(projectRoot);
-  if (!existsSync29(root)) return "";
+  if (!existsSync30(root)) return "";
   const lines = [
     "# Design vault index (.zelari/) \u2014 HYPOTHESES only",
     "Full design docs are NOT product source of truth. Open with list_files / read_file / searchDocuments if needed."
   ];
   const docsDir = join23(root, "docs");
-  if (existsSync29(docsDir)) {
+  if (existsSync30(docsDir)) {
     try {
       const docs = readdirSync7(docsDir).filter((n) => n.endsWith(".md")).slice(0, 12);
       if (docs.length > 0) {
@@ -43976,12 +44709,12 @@ function buildDesignIndex(projectRoot, maxChars) {
     }
   }
   for (const name of ["risks.md", "plan.json", "nfr-spec.json"]) {
-    if (existsSync29(join23(root, name))) {
+    if (existsSync30(join23(root, name))) {
       lines.push(`- .zelari/${name} present`);
     }
   }
   const decisionsDir = join23(root, "decisions");
-  if (existsSync29(decisionsDir)) {
+  if (existsSync30(decisionsDir)) {
     try {
       const n = readdirSync7(decisionsDir).filter((f) => f.endsWith(".md")).length;
       if (n > 0) lines.push(`- .zelari/decisions/ (${n} ADR file(s) \u2014 treat proposed as non-binding)`);
@@ -44083,15 +44816,15 @@ function composeProjectContext(input) {
 function readDurableHeadSync(projectRoot) {
   try {
     const headPath = join23(projectRoot, ".zelari", "state", "HEAD.json");
-    if (!existsSync29(headPath)) return "";
+    if (!existsSync30(headPath)) return "";
     const head = JSON.parse(readFileSync25(headPath, "utf8"));
     if (!head?.id) return "";
     const metaPath = join23(projectRoot, ".zelari", "state", "commits", `${head.id}.json`);
-    if (!existsSync29(metaPath)) return "";
+    if (!existsSync30(metaPath)) return "";
     const meta3 = JSON.parse(readFileSync25(metaPath, "utf8"));
     const discPath = meta3.artifactDir ? join23(projectRoot, ".zelari", "state", meta3.artifactDir, "discoveries.json") : join23(projectRoot, ".zelari", "state", "artifacts", head.id, "discoveries.json");
     let discoveries = [];
-    if (existsSync29(discPath)) {
+    if (existsSync30(discPath)) {
       discoveries = JSON.parse(readFileSync25(discPath, "utf8"));
     }
     const reusable = discoveries.filter((d) => d.reusable !== false);
@@ -44125,11 +44858,11 @@ var planDetect_exports = {};
 __export(planDetect_exports, {
   hasWorkspacePlan: () => hasWorkspacePlan
 });
-import { existsSync as existsSync30, readFileSync as readFileSync26 } from "node:fs";
+import { existsSync as existsSync31, readFileSync as readFileSync26 } from "node:fs";
 import { join as join24 } from "node:path";
 function hasWorkspacePlan(projectRoot = process.cwd()) {
   const planPath = join24(resolveWorkspaceRoot(projectRoot), "plan.json");
-  if (!existsSync30(planPath)) return false;
+  if (!existsSync31(planPath)) return false;
   try {
     const parsed = JSON.parse(readFileSync26(planPath, "utf8"));
     return Array.isArray(parsed.phases) && parsed.phases.length > 0;
@@ -44190,7 +44923,7 @@ __export(stubs_exports, {
   resolveWorkspaceRoot: () => resolveWorkspaceRoot
 });
 import {
-  existsSync as existsSync31,
+  existsSync as existsSync32,
   readdirSync as readdirSync8,
   writeFileSync as writeFileSync17,
   readFileSync as readFileSync27,
@@ -44211,7 +44944,7 @@ function planJsonPath(ctx) {
 }
 function readPlan(ctx) {
   const jsonPath = planJsonPath(ctx);
-  if (existsSync31(jsonPath)) {
+  if (existsSync32(jsonPath)) {
     try {
       const parsed = JSON.parse(
         readFileSync27(jsonPath, "utf8")
@@ -44321,7 +45054,7 @@ function renderPlanBody(summary) {
 }
 function nextAdrId(ctx) {
   const decisionsDir = join25(ctx.rootDir, "decisions");
-  if (!existsSync31(decisionsDir)) return "001";
+  if (!existsSync32(decisionsDir)) return "001";
   const existing = readdirSync8(decisionsDir).filter((f) => f.endsWith(".md")).map((f) => f.match(/^(\d+)-/)).filter((m) => !!m).map((m) => parseInt(m[1], 10));
   const max = existing.length === 0 ? 0 : Math.max(...existing);
   return String(max + 1).padStart(3, "0");
@@ -44777,7 +45510,7 @@ function searchDocumentsStub(ctx) {
       ];
       const results = [];
       for (const file2 of files) {
-        if (!existsSync31(file2)) continue;
+        if (!existsSync32(file2)) continue;
         const raw = readFileSync27(file2, "utf8");
         const content = raw.toLowerCase();
         let idx = -1;
@@ -44945,176 +45678,6 @@ var init_toolRegistry2 = __esm({
   }
 });
 
-// src/cli/updater.ts
-var updater_exports = {};
-__export(updater_exports, {
-  REGISTRY_URL: () => REGISTRY_URL,
-  checkForUpdate: () => checkForUpdate,
-  compareSemver: () => compareSemver,
-  distTagForVersion: () => distTagForVersion,
-  fetchLatestVersion: () => fetchLatestVersion,
-  getCurrentVersion: () => getCurrentVersion,
-  looksLikeBrokenShim: () => looksLikeBrokenShim,
-  performUpdate: () => performUpdate,
-  registryUrlForTag: () => registryUrlForTag,
-  resolveBundledNpmCli: () => resolveBundledNpmCli
-});
-import { createRequire as createRequire2 } from "node:module";
-import { spawn as spawn12 } from "node:child_process";
-import { existsSync as existsSync32 } from "node:fs";
-import path43 from "node:path";
-import { fileURLToPath } from "node:url";
-function resolveBundledNpmCli(execPath = process.execPath) {
-  const dir = path43.dirname(execPath);
-  const candidates = [
-    // Windows: C:\...\node.exe → C:\...\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
-    path43.join(dir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")
-  ];
-  for (const candidate of candidates) {
-    try {
-      if (existsSync32(candidate)) return candidate;
-    } catch {
-    }
-  }
-  return null;
-}
-function looksLikeBrokenShim(exitCode, output) {
-  if (exitCode === 127) return true;
-  const h = output.toLowerCase();
-  return h.includes("shim target not found") || h.includes("is not recognized");
-}
-function getCurrentVersion() {
-  try {
-    const pkgPath = path43.resolve(__dirname2, "..", "..", "package.json");
-    const pkg = require2(pkgPath);
-    return pkg.version;
-  } catch {
-    return "0.0.0";
-  }
-}
-function compareSemver(a, b) {
-  const parse3 = (v) => {
-    const m = v.match(/^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/);
-    if (!m) return [0, 0, 0, null];
-    return [Number(m[1]), Number(m[2]), Number(m[3]), m[4] ?? null];
-  };
-  const [a1, a2, a3, aPre] = parse3(a);
-  const [b1, b2, b3, bPre] = parse3(b);
-  if (a1 !== b1) return a1 < b1 ? -1 : 1;
-  if (a2 !== b2) return a2 < b2 ? -1 : 1;
-  if (a3 !== b3) return a3 < b3 ? -1 : 1;
-  if (aPre === bPre) return 0;
-  if (aPre === null) return 1;
-  if (bPre === null) return -1;
-  return aPre < bPre ? -1 : 1;
-}
-function distTagForVersion(version2) {
-  if (version2.includes("-alpha.")) return "alpha";
-  if (version2.includes("-beta.")) return "beta";
-  if (version2.includes("-next.")) return "next";
-  return "latest";
-}
-function registryUrlForTag(tag = distTagForVersion(getCurrentVersion())) {
-  return `https://registry.npmjs.org/zelari-code/${tag}`;
-}
-async function fetchLatestVersion(fetcher = fetch, registryUrl = REGISTRY_URL, timeoutMs2 = 5e3) {
-  try {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs2);
-    const response = await fetcher(registryUrl, { signal: controller.signal });
-    clearTimeout(timer);
-    if (!response.ok) {
-      return { error: `Registry responded ${response.status}` };
-    }
-    const data = await response.json();
-    if (!data.version || typeof data.version !== "string") {
-      return { error: "Registry response missing version field" };
-    }
-    return { version: data.version };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return { error: message };
-  }
-}
-async function checkForUpdate(fetcher = fetch, registryUrl) {
-  const currentVersion = getCurrentVersion();
-  const url2 = registryUrl ?? registryUrlForTag();
-  const latest = await fetchLatestVersion(fetcher, url2);
-  if ("error" in latest) {
-    return {
-      currentVersion,
-      latestVersion: currentVersion,
-      updateAvailable: false,
-      error: latest.error
-    };
-  }
-  const cmp = compareSemver(currentVersion, latest.version);
-  return {
-    currentVersion,
-    latestVersion: latest.version,
-    updateAvailable: cmp < 0
-  };
-}
-async function performUpdate(packageName = "zelari-code", executor = spawn12, resolveNpmCli = resolveBundledNpmCli, channel) {
-  const tag = channel ?? distTagForVersion(getCurrentVersion());
-  const args = ["install", "-g", `${packageName}@${tag}`];
-  const primary = await runNpm(executor, args, "shim");
-  if (primary.ok) return primary;
-  const npmCli = resolveNpmCli();
-  if (npmCli && looksLikeBrokenShim(primary.exitCode, primary.output)) {
-    const fallback = await runNpm(executor, args, "bundled", npmCli);
-    return {
-      ...fallback,
-      output: `[update] npm shim failed (${primary.error ?? "exit " + primary.exitCode}); retried via bundled npm (${npmCli}).
-${fallback.output}`
-    };
-  }
-  return primary;
-}
-function runNpm(executor, args, mode, npmCliPath) {
-  return new Promise((resolve3) => {
-    let stdout = "";
-    let stderr = "";
-    const stdio = ["ignore", "pipe", "pipe"];
-    const child = mode === "bundled" && npmCliPath ? executor(process.execPath, [npmCliPath, ...args], { stdio }) : process.platform === "win32" ? executor(buildCmdLine("npm", args), { stdio, shell: true }) : executor("npm", args, { stdio });
-    child.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    child.stderr?.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    child.on("error", (err) => {
-      resolve3({
-        ok: false,
-        output: stdout + stderr,
-        error: err.message,
-        exitCode: null
-      });
-    });
-    child.on("close", (code) => {
-      const ok = code === 0;
-      resolve3({
-        ok,
-        output: stdout + stderr,
-        error: ok ? void 0 : `npm exited with code ${code}`,
-        exitCode: code
-      });
-    });
-  });
-}
-var require2, __dirname2, REGISTRY_URL;
-var init_updater = __esm({
-  "src/cli/updater.ts"() {
-    "use strict";
-    init_cmdline();
-    require2 = createRequire2(import.meta.url);
-    __dirname2 = path43.dirname(fileURLToPath(import.meta.url));
-    REGISTRY_URL = "https://registry.npmjs.org/zelari-code/latest";
-  }
-});
-
 // src/cli/mcp/mcpClient.ts
 import { spawn as spawn13 } from "node:child_process";
 var DEFAULT_REQUEST_TIMEOUT_MS, INIT_TIMEOUT_MS, MCP_PROTOCOL_VERSION, McpClient;
@@ -45784,7 +46347,7 @@ __export(agentsMd_exports, {
   updateAgentsMd: () => updateAgentsMd
 });
 import { existsSync as existsSync35, readFileSync as readFileSync30, writeFileSync as writeFileSync19 } from "node:fs";
-import { createHash as createHash13 } from "node:crypto";
+import { createHash as createHash14 } from "node:crypto";
 import { join as join28 } from "node:path";
 import { readFile as readFile4 } from "node:fs/promises";
 async function readPackageJson2(projectRoot) {
@@ -45999,7 +46562,7 @@ async function updateAgentsMd(ctx, projectRoot) {
   return { changed: true, sections: changedSections };
 }
 function hash2(s) {
-  return createHash13("sha256").update(s).digest("hex").slice(0, 16);
+  return createHash14("sha256").update(s).digest("hex").slice(0, 16);
 }
 var AUTO_SECTIONS, MARKER_OPEN, MARKER_CLOSE, GENERATORS;
 var init_agentsMd = __esm({
@@ -51691,8 +52254,8 @@ function shouldRunGauntletHostLoop(opts) {
 }
 function budgetAwareGauntletGate(input) {
   if (input.verdict === "PASS") return "proceed";
-  if (input.toolCallsRemaining <= input.verificationReserve) return "finalize-verify";
   if (input.toolCallsRemaining <= 0) return "hold";
+  if (input.toolCallsRemaining <= input.verificationReserve) return "finalize-verify";
   return "proceed";
 }
 var DEFAULT_MAX_PIECES, DEFAULT_MAX_ROUNDS, DEFAULT_MAX_PARALLEL2, DEFAULT_WALL_MS, GAUNTLET_PARENT_BLOCKED_TOOLS;
@@ -52162,7 +52725,8 @@ var init_schedule = __esm({
 
 // src/cli/gauntlet/loop.ts
 async function runGauntletLoop(args) {
-  const { caps, deps } = args;
+  const { caps } = args;
+  const deps = { ...args.deps, budgetGate: args.budgetGate ?? args.deps.budgetGate };
   const pieces = args.pieces.slice(0, caps.maxPieces);
   const started = (deps.now ?? Date.now)();
   const results = [];
@@ -52229,6 +52793,21 @@ async function runGauntletLoop(args) {
         builderError: built.error
       });
       winner = parseBlindWinner(criticized.result) ?? winner;
+      if (last.kind !== "PASS") {
+        const b = deps.budgetGate?.() ?? null;
+        if (b) {
+          const decision = budgetAwareGauntletGate({
+            verdict: last.kind,
+            toolCallsRemaining: b.remaining,
+            verificationReserve: b.verificationReserve
+          });
+          if (decision === "hold") {
+            gap = last.gap;
+            break;
+          }
+          if (decision === "finalize-verify") break;
+        }
+      }
       emitProgress({
         phase: last.kind === "PASS" ? "settled" : last.kind === "BLOCKED" ? "blocked" : "repairing",
         pieceId: piece.id,
@@ -52292,6 +52871,7 @@ var init_loop = __esm({
     init_blind();
     init_policy();
     init_verdict2();
+    init_policy();
     init_prompts();
     init_schedule();
     init_events3();
@@ -52395,7 +52975,12 @@ async function runHeadlessGauntlet(opts, provider, model) {
       type: "log",
       message: `[gauntlet] ${decomposed.pieces.length} piece(s) from ${decomposed.source}${decomposed.error ? ` (${decomposed.error.slice(0, 80)})` : ""}`
     });
+    const budgetGate = () => {
+      const lim = spine.resourceBudgetLimit();
+      return lim ? { remaining: lim.remaining, verificationReserve: lim.verificationReserve } : null;
+    };
     const result = await runGauntletLoop({
+      budgetGate,
       pieces: decomposed.pieces,
       caps,
       deps: {
@@ -53470,7 +54055,7 @@ import {
 } from "node:fs";
 import { join as join38 } from "node:path";
 import { homedir as homedir13 } from "node:os";
-import { createHash as createHash14, randomBytes as randomBytes5, timingSafeEqual } from "node:crypto";
+import { createHash as createHash15, randomBytes as randomBytes5, timingSafeEqual } from "node:crypto";
 function getZelariHome() {
   return join38(homedir13(), ".zelari-code");
 }
@@ -53546,8 +54131,8 @@ function loadOrCreateToken(explicit) {
 }
 function tokenMatches(expected, provided) {
   if (!provided) return false;
-  const a = createHash14("sha256").update(expected).digest();
-  const b = createHash14("sha256").update(provided).digest();
+  const a = createHash15("sha256").update(expected).digest();
+  const b = createHash15("sha256").update(provided).digest();
   try {
     return timingSafeEqual(a, b);
   } catch {
@@ -58143,13 +58728,13 @@ init_completionGate();
 // src/cli/kraken/verificationBridge.ts
 init_candidateRegistry();
 init_completionGate();
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 
 // src/cli/kraken/nativeVerification.ts
 init_runtime2();
 init_verification2();
 import { readFile as readFile2 } from "node:fs/promises";
-import path40 from "node:path";
+import path42 from "node:path";
 function nativePackEnabled(env = process.env) {
   const v = env.ZELARI_VERIFY_PACK?.toLowerCase();
   return v === "1" || v === "on" || v === "true";
@@ -58176,7 +58761,7 @@ function packTimeoutMs(env = process.env) {
 }
 async function readPackageScripts(cwd = process.cwd()) {
   try {
-    const raw = await readFile2(path40.join(cwd, "package.json"), "utf-8");
+    const raw = await readFile2(path42.join(cwd, "package.json"), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && typeof parsed.scripts === "object") {
       return parsed.scripts;
@@ -58270,7 +58855,7 @@ function krakenResultsToContract(requiredChecks, results, now = Date.now()) {
   return { criteria, results: verifications };
 }
 function sha256Hex2(input) {
-  return createHash11("sha256").update(input).digest("hex");
+  return createHash12("sha256").update(input).digest("hex");
 }
 function matchNoteToToolTrace(note, trace) {
   const n = normalize5(note);
@@ -58991,7 +59576,9 @@ async function buildModelContext(input) {
     };
     input.onCompactionMetric?.(compactionMetrics);
   }
-  if (input.resourceSnapshot) {
+  if (input.resourceSnapshot && !history2.some(
+    (m) => m.role === "system" && typeof m.content === "string" && m.content.startsWith("RESOURCE STATUS")
+  )) {
     history2 = [...history2, resourceStatusMessage(input.resourceSnapshot)];
   }
   if (requestSurface) {
@@ -59195,6 +59782,7 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
         }
         const cwd = process.cwd();
         const requestSnapshot = getRequestSnapshotWithUsage(sessionId2);
+        await writerRef.current?.spine?.beginResourceTurn();
         const modelContext = await buildModelContext({
           fallbackHistory: historyForModel,
           session: writerRef.current?.spine ?? null,
@@ -59393,10 +59981,12 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
           systemMessages = [{ role: "system", content: fallback }];
         }
         systemPrefixLen = systemMessages.length;
-        const maxToolCallsPerTurn = envNumber(process.env.ZELARI_MAX_TOOL_CALLS, {
+        const perTurnEnv = envNumber(process.env.ZELARI_MAX_TOOL_CALLS, {
           default: 25,
           min: 1
         });
+        const sessionCap = writerRef.current?.spine?.resourceBudgetLimit();
+        const maxToolCallsPerTurn = sessionCap ? Math.max(1, Math.min(perTurnEnv, sessionCap.maxToolCalls)) : perTurnEnv;
         const maxToolLoopIterations = budget.maxToolLoopIterations;
         const maxToolLoopHardCap = envNumber(process.env.ZELARI_MAX_TOOL_LOOP_HARD, {
           default: 0,
@@ -59426,7 +60016,9 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
           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 },
+          // 2.6.1 (plan §13): argument-aware — bash is essential only when
+          // the command is a test/typecheck/build/git-diff line.
+          toolCallGate: (name, args) => writerRef.current?.spine?.gateResourceToolCall(name, args) ?? { allowed: true },
           cwd,
           maxToolCallsPerTurn,
           maxToolLoopIterations,
@@ -59874,6 +60466,7 @@ async function dispatchCouncilPromptImpl(text, deps, overrides = {}) {
   setBusy(true);
   const anchored = maybeAnchorShortAnswer(text);
   const effectiveText = anchored ?? text;
+  await writerRef.current?.spine?.beginResourceTurn();
   const councilContext = await buildModelContext({
     fallbackHistory: getHistory(),
     session: writerRef.current?.spine ?? null,
@@ -60007,10 +60600,12 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il membro riprende dop
   let streamContent = "";
   let streamMemberId = null;
   const streamScrub = createStreamScrubber(16);
-  const councilMaxToolCalls = envNumber(process.env.ZELARI_MAX_TOOL_CALLS, {
+  const councilPerTurnEnv = envNumber(process.env.ZELARI_MAX_TOOL_CALLS, {
     default: 15,
     min: 1
   });
+  const councilSessionCap = writerRef.current?.spine?.resourceBudgetLimit();
+  const councilMaxToolCalls = councilSessionCap ? Math.max(1, Math.min(councilPerTurnEnv, councilSessionCap.maxToolCalls)) : councilPerTurnEnv;
   const councilMaxToolLoop = envNumber(
     process.env.ZELARI_MAX_TOOL_LOOP_ITERATIONS,
     { default: 30, min: 1 }
@@ -65397,6 +65992,7 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
       }
     ];
   }
+  await spine.beginResourceTurn();
   const modelContext = await buildModelContext({
     fallbackHistory: seededHistory.history,
     session: spine.spine,
@@ -65443,7 +66039,9 @@ async function runHeadlessSingle(opts, provider, model, 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 },
+      // 2.6.1 (plan §13): argument-aware — bash is essential only when the
+      // command is a test/typecheck/build/git-diff line.
+      toolCallGate: (name, args) => spine.gateResourceToolCall(name, args) ?? { allowed: true },
       maxToolLoopIterations: maxToolLoop
     });
     let finalReason = "completed";
@@ -65755,6 +66353,7 @@ async function runHeadlessCouncil(opts, provider, model, providerStream) {
     description: tool.function.description,
     parameters: tool.function.parameters
   }));
+  await spine.beginResourceTurn();
   const councilContext = await buildModelContext({
     fallbackHistory: seededHistory.history,
     session: spine.spine,
@@ -65925,6 +66524,7 @@ async function runHeadlessZelari(opts, provider, model, providerStream) {
     description: tool.function.description,
     parameters: tool.function.parameters
   }));
+  await spine.beginResourceTurn();
   const missionContext = await buildModelContext({
     fallbackHistory: seededHistory.history,
     session: spine.spine,
@@ -66094,6 +66694,28 @@ ${ragContext}` : slicePrompt;
             if (completionOk) {
               emit(`[zelari] slice completion ok`);
             }
+            try {
+              const budget = spine.resourceBudgetSummary();
+              if (budget && !completionOk) {
+                const { evaluateResourceReserveGate: evaluateResourceReserveGate2 } = await Promise.resolve().then(() => (init_verification2(), verification_exports));
+                const gated = evaluateResourceReserveGate2({
+                  evaluation: {
+                    verdict: "REPAIR_REQUIRED",
+                    summary: "headless slice completion",
+                    satisfied: [],
+                    unsatisfied: [],
+                    evidenceComplete: false,
+                    eventBackedEvidenceComplete: false
+                  },
+                  budget
+                });
+                if (gated.verdict === "BLOCKED") {
+                  emit("[zelari] completion BLOCKED: resource budget exhausted (non-PASS + zero remaining)");
+                }
+                spine.note("completion.resource_gate", { decision: gated.verdict, remaining: budget.toolCalls.remaining });
+              }
+            } catch {
+            }
           } catch {
           }
           if (synthesisText.trim()) {