zelari-code 2.37.2 → 2.38.0

package/dist/cli/main.bundled.js

@@ -19560,11 +19560,11 @@ var init_listFiles = __esm({
               return 1;
             return a.name.localeCompare(b.name);
           });
-          const MAX_ENTRIES2 = 500;
-          const truncated = entries.length > MAX_ENTRIES2;
+          const MAX_ENTRIES3 = 500;
+          const truncated = entries.length > MAX_ENTRIES3;
           const warnings = entries.length === 0 ? ["DIR_EMPTY"] : [];
           const status = entries.length === 0 ? "empty" : truncated ? "partial" : "complete";
-          return typedOk({ dir: target, entries: truncated ? entries.slice(0, MAX_ENTRIES2) : entries, truncated }, {
+          return typedOk({ dir: target, entries: truncated ? entries.slice(0, MAX_ENTRIES3) : entries, truncated }, {
             status,
             counts: { filesWalked: entries.length },
             ...warnings.length > 0 ? { warnings } : {},
@@ -22452,6 +22452,12 @@ var init_worktreeWorkspace = __esm({
 
 // packages/core/dist/core/requestSnapshot.js
 import { createHash as createHash3 } from "node:crypto";
+function resolveRequestSnapshotMode(env = process.env) {
+  const raw = env.ZELARI_REQUEST_SNAPSHOT?.trim().toLowerCase();
+  if (raw === "lite" || raw === "off")
+    return raw;
+  return "full";
+}
 function stableStringify(value) {
   if (value === null || typeof value !== "object")
     return JSON.stringify(value) ?? "null";
@@ -22467,43 +22473,96 @@ function stableStringify(value) {
 function sha256Hex(input) {
   return createHash3("sha256").update(input, "utf8").digest("hex").slice(0, 32);
 }
-function cloneMessages(messages) {
+function cloneMessagesDeep(messages) {
   return structuredClone(messages);
 }
+function cloneMessagesLite(messages) {
+  return messages.map((m) => ({ ...m }));
+}
 function canonicalTools(tools) {
   return [...tools].sort((a, b) => a.name.localeCompare(b.name));
 }
+function cloneToolsDeep(tools) {
+  return canonicalTools(tools).map((t) => structuredClone(t));
+}
+function cloneToolsLite(tools) {
+  return canonicalTools(tools).map((t) => ({ ...t }));
+}
+function __resetRequestSnapshotMemoForTests() {
+  headerMemo = null;
+}
 function createRoutedRequestSnapshot(params) {
+  const mode = params.mode ?? resolveRequestSnapshotMode();
   let split = 0;
   while (split < params.messages.length && params.messages[split].role === "system") {
     split++;
   }
-  const systemMessages = cloneMessages(params.messages.slice(0, split));
-  const conversation = cloneMessages(params.messages.slice(split));
-  const tools = canonicalTools(params.tools).map((t) => structuredClone(t));
-  const header = stableStringify({
-    provider: params.provider,
-    model: params.model,
-    systemMessages,
-    tools
-  });
-  const request = stableStringify({
-    provider: params.provider,
-    model: params.model,
-    systemMessages,
-    tools,
-    conversation
-  });
-  return {
-    provider: params.provider,
-    model: params.model,
+  const lite = mode === "lite";
+  const cloneMsg = lite ? cloneMessagesLite : cloneMessagesDeep;
+  const systemMessages = cloneMsg(params.messages.slice(0, split));
+  const conversation = cloneMsg(params.messages.slice(split));
+  const createdAt = Date.now();
+  const { provider, model } = params;
+  if (!lite) {
+    const tools2 = cloneToolsDeep(params.tools);
+    const header = stableStringify({ provider, model, systemMessages, tools: tools2 });
+    const request = stableStringify({
+      provider,
+      model,
+      systemMessages,
+      tools: tools2,
+      conversation
+    });
+    return {
+      provider,
+      model,
+      systemMessages,
+      conversation,
+      tools: tools2,
+      headerFingerprint: sha256Hex(header),
+      requestFingerprint: sha256Hex(request),
+      createdAt
+    };
+  }
+  const systemKey = sha256Hex(stableStringify(systemMessages));
+  let tools;
+  let headerFp;
+  if (headerMemo && headerMemo.toolsRef === params.tools && headerMemo.provider === provider && headerMemo.model === model && headerMemo.systemKey === systemKey) {
+    tools = headerMemo.tools;
+    headerFp = headerMemo.headerFingerprint;
+  } else {
+    tools = cloneToolsLite(params.tools);
+  }
+  let requestFp;
+  const snap = {
+    provider,
+    model,
     systemMessages,
     conversation,
     tools,
-    headerFingerprint: sha256Hex(header),
-    requestFingerprint: sha256Hex(request),
-    createdAt: Date.now()
+    createdAt,
+    get headerFingerprint() {
+      if (headerFp === void 0) {
+        headerFp = sha256Hex(stableStringify({ provider, model, systemMessages, tools }));
+        headerMemo = {
+          toolsRef: params.tools,
+          provider,
+          model,
+          systemKey,
+          tools,
+          headerFingerprint: headerFp
+        };
+      }
+      return headerFp;
+    },
+    get requestFingerprint() {
+      if (requestFp === void 0) {
+        requestFp = sha256Hex(stableStringify({ provider, model, systemMessages, tools, conversation }));
+      }
+      return requestFp;
+    }
   };
+  return snap;
 }
 function compareReplayPrefix(snapshot, messages) {
   const base2 = snapshot.conversation;
@@ -22517,9 +22576,11 @@ function compareReplayPrefix(snapshot, messages) {
   }
   return { exact: true, matchingMessages: matching };
 }
+var headerMemo;
 var init_requestSnapshot = __esm({
   "packages/core/dist/core/requestSnapshot.js"() {
     "use strict";
+    headerMemo = null;
   }
 });
 
@@ -23520,15 +23581,22 @@ async function readSessionLog(filePath) {
     }
     throw err;
   }
+  return parseSessionLogText(filePath, content);
+}
+function parseSessionLogText(filePath, content) {
+  const { events, issues } = parseSessionLogLines(content.split("\n"));
+  return { path: filePath, events, issues, ok: issues.length === 0 };
+}
+function parseSessionLogLines(lines, opts = {}) {
   const events = [];
   const issues = [];
-  let expected = 1;
-  const lines = content.split("\n");
+  const base2 = opts.linesConsumed ?? 0;
+  let expected = opts.expected ?? 1;
   for (let i = 0; i < lines.length; i++) {
     const trimmed = lines[i].trim();
     if (!trimmed)
       continue;
-    const lineNo = i + 1;
+    const lineNo = base2 + i + 1;
     let parsed;
     try {
       parsed = JSON.parse(trimmed);
@@ -23562,7 +23630,7 @@ async function readSessionLog(filePath) {
       expected = envelope.seq + 1;
     }
   }
-  return { path: filePath, events, issues, ok: issues.length === 0 };
+  return { events, issues, expected, linesConsumed: base2 + lines.length };
 }
 function parseVerification(e) {
   const raw = Array.isArray(e.data.results) ? e.data.results : [];
@@ -23810,7 +23878,7 @@ async function createExecutionContext(options = {}) {
       workspaceKind: workspace.kind
     }
   });
-  const fs48 = options.fs ?? new NodeFsProvider(workspace);
+  const fs49 = options.fs ?? new NodeFsProvider(workspace);
   const shell = options.shell ?? new NodeShellProvider(workspace);
   const subagent = options.subagent ?? NOOP_SUBAGENT_PROVIDER;
   const env = options.env ?? process.env;
@@ -23818,7 +23886,7 @@ async function createExecutionContext(options = {}) {
     sessionId: sessionId2,
     profile,
     workspace,
-    fs: fs48,
+    fs: fs49,
     shell,
     subagent,
     appendSessionEvent: (input) => writer.append(input),
@@ -25589,6 +25657,60 @@ var init_scopeDiscipline = __esm({
   }
 });
 
+// packages/core/dist/verification/commandConcurrency.js
+function isVerifyParallelEnabled(env = process.env) {
+  const raw = env.ZELARI_VERIFY_PARALLEL?.trim().toLowerCase();
+  return raw !== void 0 && PARALLEL_TRUTHY.has(raw);
+}
+function resolveCommandConcurrency(env = process.env) {
+  if (!isVerifyParallelEnabled(env))
+    return 1;
+  const raw = Number(env.ZELARI_VERIFY_CONCURRENCY);
+  if (!Number.isFinite(raw) || raw <= 0)
+    return DEFAULT_COMMAND_CONCURRENCY;
+  return Math.floor(raw);
+}
+var DEFAULT_COMMAND_CONCURRENCY, PARALLEL_TRUTHY;
+var init_commandConcurrency = __esm({
+  "packages/core/dist/verification/commandConcurrency.js"() {
+    "use strict";
+    DEFAULT_COMMAND_CONCURRENCY = 3;
+    PARALLEL_TRUTHY = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+  }
+});
+
+// packages/core/dist/verification/runWithLimit.js
+async function runWithLimit(items, limit, fn) {
+  const slots = Math.min(items.length, Math.max(1, Number.isFinite(limit) ? Math.floor(limit) : 1));
+  if (slots <= 0)
+    return;
+  let cursor = 0;
+  let failed = false;
+  let firstError;
+  const worker = async () => {
+    while (!failed && cursor < items.length) {
+      const index = cursor;
+      cursor += 1;
+      try {
+        await fn(items[index], index);
+      } catch (err) {
+        if (!failed) {
+          failed = true;
+          firstError = err;
+        }
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: slots }, () => worker()));
+  if (failed)
+    throw firstError;
+}
+var init_runWithLimit = __esm({
+  "packages/core/dist/verification/runWithLimit.js"() {
+    "use strict";
+  }
+});
+
 // packages/core/dist/verification/engine.js
 import { createHash as createHash8 } from "node:crypto";
 function defaultSha256(input) {
@@ -25597,11 +25719,14 @@ function defaultSha256(input) {
 function tail(text, max = 400) {
   return text.length > max ? `\u2026${text.slice(text.length - max)}` : text;
 }
-var VerificationEngine;
+var CACHED_DETAIL_NOTE, VerificationEngine;
 var init_engine = __esm({
   "packages/core/dist/verification/engine.js"() {
     "use strict";
     init_scopeDiscipline();
+    init_commandConcurrency();
+    init_runWithLimit();
+    CACHED_DETAIL_NOTE = "cached \u2014 tree unchanged since last run";
     VerificationEngine = class {
       services;
       options;
@@ -25612,8 +25737,15 @@ var init_engine = __esm({
       /** Evaluate criteria deterministically; optionally emit the spine event. */
       async evaluate(criteria, context = {}) {
         const results = [];
-        for (const criterion of criteria) {
-          results.push(await this.evaluateOne(criterion, context.scope));
+        const limit = this.options.commandConcurrency ?? resolveCommandConcurrency();
+        if (limit <= 1) {
+          for (const criterion of criteria) {
+            results.push(await this.evaluateOne(criterion, context.scope));
+          }
+        } else {
+          await runWithLimit(criteria, limit, async (criterion, index) => {
+            results[index] = await this.evaluateOne(criterion, context.scope);
+          });
         }
         if (this.options.emit) {
           try {
@@ -25704,13 +25836,18 @@ var init_engine = __esm({
         }
       }
       async evalCommand(check2, done) {
-        const sha256 = this.options.sha256 ?? defaultSha256;
+        const sha2562 = this.options.sha256 ?? defaultSha256;
         const shell = this.services.shell;
         if (!shell) {
           return done({ status: "unknown", evidence: [], detail: "shell provider unavailable" });
         }
         const result = await shell.exec(check2.command, { timeoutMs: check2.timeoutMs });
-        const digest = sha256(result.stdout);
+        const digest = sha2562(result.stdout);
+        const cached2 = result.cached === true;
+        const finish2 = (patch) => cached2 ? done({
+          ...patch,
+          detail: patch.detail ? `${patch.detail} (${CACHED_DETAIL_NOTE})` : CACHED_DETAIL_NOTE
+        }) : done(patch);
         const seq = await this.emitEvidence({
           observation: "command",
           command: check2.command,
@@ -25718,7 +25855,9 @@ var init_engine = __esm({
           timedOut: result.timedOut,
           digest,
           stdoutTail: tail(result.stdout),
-          stderrTail: tail(result.stderr)
+          stderrTail: tail(result.stderr),
+          // Additive (optional) field: replay of older logs without it still parses.
+          ...cached2 ? { cached: true } : {}
         });
         const evidence = [
           {
@@ -25730,32 +25869,32 @@ var init_engine = __esm({
           }
         ];
         if (result.timedOut) {
-          return done({ status: "unknown", evidence, detail: `command timed out (${check2.timeoutMs ?? "default"}ms)` });
+          return finish2({ status: "unknown", evidence, detail: `command timed out (${check2.timeoutMs ?? "default"}ms)` });
         }
         const expectExit = check2.expectExit ?? 0;
         if (result.exitCode !== expectExit) {
-          return done({
+          return finish2({
             status: "fail",
             evidence,
             detail: `exit ${result.exitCode} (expected ${expectExit}) \u2014 stderr: ${tail(result.stderr)}`
           });
         }
         if (check2.expectStdoutIncludes && !result.stdout.includes(check2.expectStdoutIncludes)) {
-          return done({
+          return finish2({
             status: "fail",
             evidence,
             detail: `stdout missing "${check2.expectStdoutIncludes}" \u2014 got: ${tail(result.stdout)}`
           });
         }
-        return done({ status: "pass", evidence });
+        return finish2({ status: "pass", evidence });
       }
       /**
        * F3: the fs observation is logged to the spine (path, existence, optional
        * content digest) and the returned ref carries the event seq when the
        * emitter resolved one.
        */
-      async fsEvidence(observation, path101, sha256, content, extra = {}) {
-        const digest = sha256 && content !== void 0 ? sha256(content) : void 0;
+      async fsEvidence(observation, path101, sha2562, content, extra = {}) {
+        const digest = sha2562 && content !== void 0 ? sha2562(content) : void 0;
         const seq = await this.emitEvidence({ observation, path: path101, ...extra, ...digest ? { digest } : {} });
         return {
           tier: "fs-observation",
@@ -25766,26 +25905,26 @@ var init_engine = __esm({
         };
       }
       async evalFileExists(check2, done) {
-        const sha256 = this.options.sha256 ?? defaultSha256;
-        const fs48 = this.services.fs;
-        if (!fs48)
+        const sha2562 = this.options.sha256 ?? defaultSha256;
+        const fs49 = this.services.fs;
+        if (!fs49)
           return done({ status: "unknown", evidence: [], detail: "fs provider unavailable" });
-        const exists = await fs48.exists(check2.path);
+        const exists = await fs49.exists(check2.path);
         if (!exists) {
           await this.emitEvidence({ observation: "file-exists", path: check2.path, exists: false });
           return done({ status: "fail", evidence: [], detail: `file not found: ${check2.path}` });
         }
-        const content = await fs48.readFile(check2.path).catch(() => "");
+        const content = await fs49.readFile(check2.path).catch(() => "");
         return done({
           status: "pass",
-          evidence: [await this.fsEvidence("file-exists", check2.path, sha256, content, { exists: true })]
+          evidence: [await this.fsEvidence("file-exists", check2.path, sha2562, content, { exists: true })]
         });
       }
       async evalFileAbsent(check2, done) {
-        const fs48 = this.services.fs;
-        if (!fs48)
+        const fs49 = this.services.fs;
+        if (!fs49)
           return done({ status: "unknown", evidence: [], detail: "fs provider unavailable" });
-        const exists = await fs48.exists(check2.path);
+        const exists = await fs49.exists(check2.path);
         if (exists) {
           await this.emitEvidence({ observation: "file-absent", path: check2.path, exists: true });
           return done({ status: "fail", evidence: [], detail: `file still present: ${check2.path}` });
@@ -25796,18 +25935,18 @@ var init_engine = __esm({
         });
       }
       async evalFileContains(check2, done) {
-        const sha256 = this.options.sha256 ?? defaultSha256;
-        const fs48 = this.services.fs;
-        if (!fs48)
+        const sha2562 = this.options.sha256 ?? defaultSha256;
+        const fs49 = this.services.fs;
+        if (!fs49)
           return done({ status: "unknown", evidence: [], detail: "fs provider unavailable" });
         let content;
         try {
-          content = await fs48.readFile(check2.path);
+          content = await fs49.readFile(check2.path);
         } catch {
           await this.emitEvidence({ observation: "file-contains", path: check2.path, readable: false });
           return done({ status: "fail", evidence: [], detail: `file not readable: ${check2.path}` });
         }
-        const evidence = [await this.fsEvidence("file-contains", check2.path, sha256, content)];
+        const evidence = [await this.fsEvidence("file-contains", check2.path, sha2562, content)];
         let hit;
         try {
           hit = new RegExp(check2.pattern, "m").test(content);
@@ -26355,6 +26494,7 @@ __export(verification_exports, {
   CommandCheckSchema: () => CommandCheckSchema,
   CriterionSchema: () => CriterionSchema,
   CriterionSourceSchema: () => CriterionSourceSchema,
+  DEFAULT_COMMAND_CONCURRENCY: () => DEFAULT_COMMAND_CONCURRENCY,
   DEFAULT_VERIFIER_CONFIG: () => DEFAULT_VERIFIER_CONFIG,
   DETERMINISTIC_EVIDENCE_TIERS: () => DETERMINISTIC_EVIDENCE_TIERS,
   DeterministicCheckSchema: () => DeterministicCheckSchema,
@@ -26383,9 +26523,11 @@ __export(verification_exports, {
   evaluateResourceReserveGate: () => evaluateResourceReserveGate,
   isEventBackedEvidence: () => isEventBackedEvidence,
   isGeneratedPath: () => isGeneratedPath,
+  isVerifyParallelEnabled: () => isVerifyParallelEnabled,
   lastVerificationRun: () => lastVerificationRun,
   parseNameOnlyDiff: () => parseNameOnlyDiff,
   parseVerificationRunPayload: () => parseVerificationRunPayload,
+  resolveCommandConcurrency: () => resolveCommandConcurrency,
   snapshotToCompletionEvaluation: () => snapshotToCompletionEvaluation,
   strictBuildGate: () => strictBuildGate,
   verificationCostRatio: () => verificationCostRatio,
@@ -26402,6 +26544,7 @@ var init_verification = __esm({
     init_metrics();
     init_verifier();
     init_scopeDiscipline();
+    init_commandConcurrency();
     init_resourceReserveGate();
   }
 });
@@ -26749,6 +26892,102 @@ var init_verificationAdapters = __esm({
   }
 });
 
+// src/cli/kraken/cachedShell.ts
+import { execFile as execFile2 } from "node:child_process";
+import { createHash as createHash9 } from "node:crypto";
+import { promisify } from "node:util";
+function verifyCacheEnabled(env = process.env) {
+  const v = env.ZELARI_VERIFY_CACHE?.toLowerCase();
+  if (v === "0" || v === "off" || v === "false") return false;
+  return true;
+}
+function sha256(input) {
+  return createHash9("sha256").update(input).digest("hex");
+}
+async function readTreeState(root) {
+  try {
+    const opts = { maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, windowsHide: true };
+    const [head, status] = await Promise.all([
+      execFileAsync("git", ["-C", root, "rev-parse", "HEAD"], opts),
+      execFileAsync("git", ["-C", root, "status", "--porcelain", "--untracked-files=all"], opts)
+    ]);
+    return `HEAD:${String(head.stdout).trim()}|${sha256(String(status.stdout))}`;
+  } catch {
+    return null;
+  }
+}
+function wrapWithVerifyCache(shell, options = {}) {
+  const env = options.env ?? process.env;
+  if (!verifyCacheEnabled(env)) return shell;
+  return new CachedShellProvider(shell, options);
+}
+var execFileAsync, MAX_ENTRIES, TREE_TTL_MS, GIT_MAX_BUFFER, GIT_TIMEOUT_MS, cache, CachedShellProvider;
+var init_cachedShell = __esm({
+  "src/cli/kraken/cachedShell.ts"() {
+    "use strict";
+    execFileAsync = promisify(execFile2);
+    MAX_ENTRIES = 32;
+    TREE_TTL_MS = 5e3;
+    GIT_MAX_BUFFER = 8 * 1024 * 1024;
+    GIT_TIMEOUT_MS = 1e4;
+    cache = /* @__PURE__ */ new Map();
+    CachedShellProvider = class {
+      constructor(inner, options = {}) {
+        this.inner = inner;
+        this.root = options.root ?? process.cwd();
+      }
+      root;
+      /**
+       * Tree token memo, PER INSTANCE (5 s TTL). Deliberately not module-level: a
+       * stale token would keep matching the pre-write key for up to the TTL and
+       * serve the PRE-repair result after the repair wrote files — a false PASS
+       * window on the gate. Every evaluation builds its own decorator, so a write
+       * made between evaluations is always observed; the memo only avoids
+       * re-running git for the sibling criteria of the SAME evaluation.
+       */
+      treeMemo;
+      async treeState() {
+        const now = Date.now();
+        if (this.treeMemo && now - this.treeMemo.at < TREE_TTL_MS) return this.treeMemo.value;
+        const value = await readTreeState(this.root);
+        this.treeMemo = { at: now, value };
+        return value;
+      }
+      async exec(command, options = {}) {
+        const tree = await this.treeState();
+        if (tree === null) return await this.inner.exec(command, options);
+        const key = sha256(
+          JSON.stringify({
+            command,
+            cwd: options.cwd ?? "",
+            timeoutMs: options.timeoutMs ?? null,
+            tree,
+            // Additive safety field: two evaluation roots in ONE process must
+            // never collide on the same relative cwd.
+            root: this.root
+          })
+        );
+        const started = Date.now();
+        const hit = cache.get(key);
+        if (hit !== void 0) {
+          cache.delete(key);
+          cache.set(key, hit);
+          return { ...hit, cached: true, durationMs: Date.now() - started };
+        }
+        const result = await this.inner.exec(command, options);
+        if (!result.timedOut && result.exitCode !== null) {
+          cache.set(key, { ...result });
+          if (cache.size > MAX_ENTRIES) {
+            const oldest = cache.keys().next().value;
+            if (oldest !== void 0) cache.delete(oldest);
+          }
+        }
+        return result;
+      }
+    };
+  }
+});
+
 // src/cli/kraken/nativeVerification.ts
 var nativeVerification_exports = {};
 __export(nativeVerification_exports, {
@@ -26829,7 +27068,7 @@ async function evaluateNativePack(deps = {}) {
   if (!commands.typecheckCommand && !commands.testCommand && !commands.buildCommand) return null;
   const criteria = buildNativeCriteria(commands, packTimeoutMs(env));
   if (criteria.length === 0) return null;
-  const shell = deps.shell ?? new NodeShellProvider(new LocalWorkspace(cwd));
+  const shell = deps.shell ?? wrapWithVerifyCache(new NodeShellProvider(new LocalWorkspace(cwd)), { root: cwd, env });
   const engine = deps.emit ? new VerificationEngine({ shell }, { emit: deps.emit }) : new VerificationEngine({ shell });
   const results = await engine.evaluate(criteria, { packId: ZELARI_CODING_PACK_ID });
   return { packId: ZELARI_CODING_PACK_ID, criteria, results };
@@ -26841,6 +27080,7 @@ var init_nativeVerification = __esm({
     init_runtime();
     init_verification();
     init_verificationAdapters();
+    init_cachedShell();
     EMPTY_PLAN = {
       typecheckCommand: null,
       testCommand: null,
@@ -27207,7 +27447,7 @@ async function evaluateContractCriteria(contract, deps = {}) {
   const cwd = deps.cwd ?? process.cwd();
   const criteria = compileVerificationCriteria(contract, { timeoutMs: deps.timeoutMs });
   if (criteria.length === 0) return null;
-  const shell = deps.shell ?? new NodeShellProvider(new LocalWorkspace(cwd));
+  const shell = deps.shell ?? wrapWithVerifyCache(new NodeShellProvider(new LocalWorkspace(cwd)), { root: cwd });
   const engine = deps.emit ? new VerificationEngine({ shell }, { emit: deps.emit }) : new VerificationEngine({ shell });
   const results = await engine.evaluate(criteria, { packId: CONTRACT_CRITERIA_PACK_ID });
   return { criteria, results };
@@ -27219,6 +27459,7 @@ var init_contractCompiler = __esm({
     init_runtime();
     init_verification();
     init_policyEngine();
+    init_cachedShell();
     CONTRACT_CRITERIA_PACK_ID = "task-contract/v1";
     CONTRACT_COMMAND_TIMEOUT_MS = 6e5;
     MAX_COMMAND_LENGTH = 512;
@@ -27242,7 +27483,7 @@ __export(verificationBridge_exports, {
   strictGateEventPayload: () => strictGateEventPayload,
   strictGateExitCode: () => strictGateExitCode
 });
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 function strictDoneEnabled(surface = "kraken", env = process.env) {
   if (surface === "mission") {
     const v2 = env.ZELARI_MISSION_STRICT;
@@ -27318,7 +27559,7 @@ function krakenResultsToContract(requiredChecks, results, now = Date.now()) {
   return { criteria, results: verifications };
 }
 function sha256Hex2(input) {
-  return createHash9("sha256").update(input).digest("hex");
+  return createHash10("sha256").update(input).digest("hex");
 }
 function matchNoteToToolTrace(note, trace) {
   const n = normalize3(note);
@@ -28993,6 +29234,9 @@ var init_AgentHarness = __esm({
       maxToolLoopIterations;
       maxToolLoopHardCap;
       cancelled = false;
+      /** Host-supplied cancel cause (`turn_timeout` vs user Stop). */
+      cancelReason;
+      cancelEventEmitted = false;
       activeController = null;
       queue = [];
       /**
@@ -29347,13 +29591,28 @@ ${shared.content}`,
        * After cancel() returns, the harness should be discarded by the
        * caller (the run() generator finishes after the current turn ends).
        * For mid-stream interrupt + new-prompt injection, see Task C.3.2.
+       *
+       * `reason` is optional host context: `turn_timeout` is the Desktop sidecar
+       * idle watchdog (not a user Stop). The error event message must not claim
+       * the user cancelled when they did not.
        */
-      cancel() {
+      cancel(reason) {
         if (this.cancelled)
           return;
         this.cancelled = true;
+        if (reason)
+          this.cancelReason = reason;
         this.activeController?.abort();
       }
+      buildCancelEvent() {
+        this.cancelEventEmitted = true;
+        const watchdog = this.cancelReason === "turn_timeout";
+        return createBrainEvent("error", this.sessionId, {
+          severity: "cancelled",
+          message: watchdog ? "Turn cancelled: Desktop idle watchdog saw no events (silent model thinking or a tentacle with no tools). This was not a user Stop." : "Run cancelled by user.",
+          code: watchdog ? "turn_timeout" : "cancelled"
+        });
+      }
       /** Current size of the queued user-prompt buffer. */
       get queueLength() {
         return this.queue.length;
@@ -29398,6 +29657,7 @@ ${shared.content}`,
       async *run() {
         const startTime = Date.now();
         this.activeController = new AbortController();
+        this.cancelEventEmitted = false;
         this.toolCallCache = /* @__PURE__ */ new Map();
         this.toolCallCounts = /* @__PURE__ */ new Map();
         this.textToolReentries = 0;
@@ -29643,6 +29903,11 @@ ${shared.content}`,
           } catch {
           }
         }
+        if (this.cancelled && !this.cancelEventEmitted) {
+          const cancelEvent = this.buildCancelEvent();
+          this.emit(cancelEvent);
+          yield cancelEvent;
+        }
         const agentEnd = createBrainEvent("agent_end", this.sessionId, {
           reason: hadError ? "error" : this.cancelled ? "cancelled" : "completed",
           durationMs: Date.now() - startTime,
@@ -29705,6 +29970,8 @@ ${shared.content}`,
       emitSnapshot(tools, generation, messages = this.messagesForProvider()) {
         if (!this.config.onRequestSnapshot)
           return;
+        if (resolveRequestSnapshotMode() === "off")
+          return;
         try {
           this.config.onRequestSnapshot(createRoutedRequestSnapshot({
             messages,
@@ -29754,11 +30021,7 @@ ${shared.content}`,
           let lastLoopCheckLen = 0;
           for await (const delta of stream) {
             if (this.cancelled) {
-              const cancelEvent = createBrainEvent("error", this.sessionId, {
-                severity: "cancelled",
-                message: "Run cancelled by user.",
-                code: "cancelled"
-              });
+              const cancelEvent = this.buildCancelEvent();
               this.emit(cancelEvent);
               yield cancelEvent;
               break;
@@ -31002,6 +31265,7 @@ __export(harness_exports, {
   TEXT_TOOLS_PARTIAL_USER: () => TEXT_TOOLS_PARTIAL_USER,
   TOOL_CALL_TRUNCATED_RECOVERY_MARKER: () => TOOL_CALL_TRUNCATED_RECOVERY_MARKER,
   TOOL_CALL_TRUNCATED_RECOVERY_USER: () => TOOL_CALL_TRUNCATED_RECOVERY_USER,
+  __resetRequestSnapshotMemoForTests: () => __resetRequestSnapshotMemoForTests,
   canonicalTools: () => canonicalTools,
   collapseLoopedAssistantText: () => collapseLoopedAssistantText,
   compareReplayPrefix: () => compareReplayPrefix,
@@ -31024,6 +31288,7 @@ __export(harness_exports, {
   recordRequest: () => recordRequest,
   recordToolResult: () => recordToolResult,
   recordUsage: () => recordUsage,
+  resolveRequestSnapshotMode: () => resolveRequestSnapshotMode,
   runExtensionPreToolUse: () => runExtensionPreToolUse,
   sha256Hex: () => sha256Hex,
   splitHookCommandLine: () => splitHookCommandLine,
@@ -37360,6 +37625,146 @@ var init_agentAdapter = __esm({
   }
 });
 
+// packages/core/dist/session/replayCache.js
+import { promises as fs14 } from "node:fs";
+function isReplayCacheEnabled(env = process.env) {
+  const v = (env.ZELARI_SPINE_REPLAY_CACHE ?? "").trim().toLowerCase();
+  return v === "1" || v === "true" || v === "yes" || v === "on";
+}
+function utf8IncompleteTailBytes(buf) {
+  const max = Math.min(4, buf.length);
+  for (let back = 1; back <= max; back++) {
+    const b = buf[buf.length - back];
+    if (b < 128)
+      return 0;
+    if (b >= 192) {
+      const need = b >= 240 ? 4 : b >= 224 ? 3 : 2;
+      return back >= need ? 0 : need - back;
+    }
+  }
+  return 0;
+}
+async function readAt(fh, position, length) {
+  const buf = Buffer.allocUnsafe(length);
+  let done = 0;
+  while (done < length) {
+    const { bytesRead } = await fh.read(buf, done, length - done, position + done);
+    if (bytesRead === 0)
+      break;
+    done += bytesRead;
+  }
+  return done === length ? buf : buf.subarray(0, done);
+}
+function toReport(filePath, entry) {
+  const events = entry.events.slice();
+  const issues = entry.issues.slice();
+  return { path: filePath, events, issues, ok: issues.length === 0 };
+}
+async function readSessionLogCached(filePath, cache4, env = process.env) {
+  if (!cache4 || !isReplayCacheEnabled(env))
+    return readSessionLog(filePath);
+  return cache4.read(filePath);
+}
+var NL, SessionLogCache;
+var init_replayCache = __esm({
+  "packages/core/dist/session/replayCache.js"() {
+    "use strict";
+    init_replay();
+    NL = 10;
+    SessionLogCache = class {
+      entries = /* @__PURE__ */ new Map();
+      /** Files currently cached (diagnostics). */
+      get size() {
+        return this.entries.size;
+      }
+      /** The cached entry for `filePath` (copy; tests + diagnostics), if any. */
+      peek(filePath) {
+        const entry = this.entries.get(filePath);
+        return entry ? { ...entry } : void 0;
+      }
+      /** Read the log, incrementally when a usable entry exists. */
+      async read(filePath) {
+        const cached2 = this.entries.get(filePath);
+        let stat8;
+        try {
+          stat8 = await fs14.stat(filePath);
+        } catch (err) {
+          if (err.code === "ENOENT") {
+            this.entries.delete(filePath);
+            return { path: filePath, events: [], issues: [], ok: true };
+          }
+          throw err;
+        }
+        if (cached2 && stat8.size >= cached2.byteSize && stat8.mtimeMs >= cached2.mtimeMs) {
+          if (stat8.size > cached2.byteSize)
+            return this.extend(filePath, cached2, stat8);
+          return toReport(filePath, cached2);
+        }
+        return this.full(filePath, stat8);
+      }
+      /** Append-path read: only the bytes written since the last read are parsed. */
+      async extend(filePath, cached2, stat8) {
+        const fh = await fs14.open(filePath, "r");
+        let chunk;
+        try {
+          chunk = await readAt(fh, cached2.byteSize, stat8.size - cached2.byteSize);
+        } finally {
+          await fh.close();
+        }
+        const nl = chunk.lastIndexOf(NL);
+        const headEnd = nl === -1 ? 0 : nl + 1;
+        const tail2 = chunk.subarray(headEnd);
+        const keep = tail2.subarray(0, tail2.length - utf8IncompleteTailBytes(tail2));
+        const head = cached2.partial + chunk.subarray(0, headEnd).toString("utf8");
+        const lines = headEnd > 0 ? head.split("\n").slice(0, -1) : [];
+        const parsed = parseSessionLogLines(lines, {
+          expected: cached2.expectedSeq,
+          linesConsumed: cached2.linesConsumed
+        });
+        const entry = {
+          byteSize: cached2.byteSize + headEnd + keep.length,
+          mtimeMs: stat8.mtimeMs,
+          events: parsed.events.length > 0 ? cached2.events.concat(parsed.events) : cached2.events,
+          issues: parsed.issues.length > 0 ? cached2.issues.concat(parsed.issues) : cached2.issues,
+          expectedSeq: parsed.expected,
+          partial: (headEnd > 0 ? "" : cached2.partial) + keep.toString("utf8"),
+          linesConsumed: parsed.linesConsumed
+        };
+        this.entries.set(filePath, entry);
+        return toReport(filePath, entry);
+      }
+      /** Cold / rotated read: same parse as `readSessionLog`, then seed the entry. */
+      async full(filePath, stat8) {
+        let content;
+        try {
+          content = await fs14.readFile(filePath, "utf-8");
+        } catch (err) {
+          if (err.code === "ENOENT") {
+            this.entries.delete(filePath);
+            return { path: filePath, events: [], issues: [], ok: true };
+          }
+          throw err;
+        }
+        const lines = content.split("\n");
+        const parsed = parseSessionLogLines(lines);
+        const linesConsumed = content.length === 0 ? 0 : content.endsWith("\n") ? lines.length - 1 : lines.length;
+        const entry = {
+          // Bytes actually read (never the pre-read stat: the log may have grown).
+          byteSize: Buffer.byteLength(content, "utf8"),
+          mtimeMs: stat8.mtimeMs,
+          events: parsed.events,
+          issues: parsed.issues,
+          expectedSeq: parsed.expected,
+          partial: "",
+          linesConsumed
+        };
+        this.entries.set(filePath, entry);
+        return { path: filePath, events: entry.events.slice(), issues: entry.issues.slice(), ok: entry.issues.length === 0 };
+      }
+    };
+  }
+});
+
 // packages/core/dist/session/lineage.js
 async function forkSession(store6, parentSessionId, options = {}) {
   const parent = await store6.read(parentSessionId);
@@ -37923,6 +38328,7 @@ var init_session = __esm({
     init_agentAdapter();
     init_writer();
     init_replay();
+    init_replayCache();
     init_store();
     init_lineage();
     init_exportSession();
@@ -38416,12 +38822,12 @@ var CORE_VERSION;
 var init_version = __esm({
   "packages/core/dist/version.js"() {
     "use strict";
-    CORE_VERSION = "2.37.2";
+    CORE_VERSION = "2.38.0";
   }
 });
 
 // packages/core/dist/runtime/fingerprints.js
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 function toolFingerprintHash(tools) {
   const canonical = [...tools].map((t) => ({
     name: t.name,
@@ -38430,7 +38836,7 @@ function toolFingerprintHash(tools) {
     ...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 createHash10("sha256").update(stableStringify(canonical)).digest("hex");
+  return createHash11("sha256").update(stableStringify(canonical)).digest("hex");
 }
 function skillFingerprintHash(skills) {
   const canonical = [...skills].map((s) => ({
@@ -38438,7 +38844,7 @@ function skillFingerprintHash(skills) {
     ...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 createHash10("sha256").update(stableStringify(canonical)).digest("hex");
+  return createHash11("sha256").update(stableStringify(canonical)).digest("hex");
 }
 var init_fingerprints = __esm({
   "packages/core/dist/runtime/fingerprints.js"() {
@@ -38476,6 +38882,7 @@ __export(dist_exports, {
   CommandCheckSchema: () => CommandCheckSchema,
   CriterionSchema: () => CriterionSchema,
   CriterionSourceSchema: () => CriterionSourceSchema,
+  DEFAULT_COMMAND_CONCURRENCY: () => DEFAULT_COMMAND_CONCURRENCY,
   DEFAULT_CONTEXT_POLICY: () => DEFAULT_CONTEXT_POLICY,
   DEFAULT_HEARTBEAT_STALE_MS: () => DEFAULT_HEARTBEAT_STALE_MS,
   DEFAULT_MAX_NODES: () => DEFAULT_MAX_NODES,
@@ -38602,6 +39009,7 @@ __export(dist_exports, {
   SessionActorSchema: () => SessionActorSchema,
   SessionEventEnvelopeSchema: () => SessionEventEnvelopeSchema,
   SessionJsonlWriter: () => SessionJsonlWriter,
+  SessionLogCache: () => SessionLogCache,
   SessionLogLockedError: () => SessionLogLockedError,
   SessionLogWriter: () => SessionLogWriter,
   SessionStore: () => SessionStore,
@@ -38640,6 +39048,7 @@ __export(dist_exports, {
   WorkspacePathEscapeError: () => WorkspacePathEscapeError,
   WorktreeWorkspace: () => WorktreeWorkspace,
   ZELARI_CODING_PACK_ID: () => ZELARI_CODING_PACK_ID,
+  __resetRequestSnapshotMemoForTests: () => __resetRequestSnapshotMemoForTests,
   analyzeScope: () => analyzeScope,
   applyCompletionRetry: () => applyCompletionRetry,
   applyDeterministicAutofix: () => applyDeterministicAutofix,
@@ -38801,6 +39210,7 @@ __export(dist_exports, {
   isFollowUpControlEvent: () => isFollowUpControlEvent,
   isGeneratedPath: () => isGeneratedPath,
   isModelSurfaceEvent: () => isModelSurfaceEvent,
+  isReplayCacheEnabled: () => isReplayCacheEnabled,
   isReviewerKind: () => isReviewerKind,
   isSearchTool: () => isSearchTool,
   isSeqShadowed: () => isSeqShadowed,
@@ -38809,6 +39219,7 @@ __export(dist_exports, {
   isSteerControlEvent: () => isSteerControlEvent,
   isValidTool: () => isValidTool,
   isVerificationReserveProtected: () => isVerificationReserveProtected,
+  isVerifyParallelEnabled: () => isVerifyParallelEnabled,
   isVerifyToolCheckSkipped: () => isVerifyToolCheckSkipped,
   jaccardSimilarity: () => jaccardSimilarity,
   jsonBytes: () => jsonBytes,
@@ -38847,6 +39258,8 @@ __export(dist_exports, {
   parseNameOnlyDiff: () => parseNameOnlyDiff,
   parsePersonaVerdict: () => parsePersonaVerdict,
   parseProjectRootFromWorkspaceContext: () => parseProjectRootFromWorkspaceContext,
+  parseSessionLogLines: () => parseSessionLogLines,
+  parseSessionLogText: () => parseSessionLogText,
   parseTextToolCalls: () => parseTextToolCalls,
   parseTextToolCallsDetailed: () => parseTextToolCallsDetailed,
   parseThinking: () => parseThinking,
@@ -38864,6 +39277,7 @@ __export(dist_exports, {
   readLessonsDeduped: () => readLessonsDeduped,
   readSession: () => readSession,
   readSessionLog: () => readSessionLog,
+  readSessionLogCached: () => readSessionLogCached,
   recallLessons: () => recallLessons,
   recencyScore: () => recencyScore,
   recordRequest: () => recordRequest,
@@ -38880,6 +39294,7 @@ __export(dist_exports, {
   renderSteers: () => renderSteers,
   replayChairmanTextTools: () => replayChairmanTextTools,
   resolveAgentSkills: () => resolveAgentSkills,
+  resolveCommandConcurrency: () => resolveCommandConcurrency,
   resolveCouncilRunMode: () => resolveCouncilRunMode,
   resolveHeartbeatStaleMs: () => resolveHeartbeatStaleMs,
   resolveInterventions: () => resolveInterventions,
@@ -38887,6 +39302,7 @@ __export(dist_exports, {
   resolveMaxTentacles: () => resolveMaxTentacles,
   resolvePlanTimeoutMs: () => resolvePlanTimeoutMs,
   resolveProfile: () => resolveProfile,
+  resolveRequestSnapshotMode: () => resolveRequestSnapshotMode,
   resolveResponseLanguage: () => resolveResponseLanguage,
   resolveRoleSystemPrompt: () => resolveRoleSystemPrompt,
   resolveSessionsDir: () => resolveSessionsDir,
@@ -39121,7 +39537,7 @@ var init_graphStatus = __esm({
 });
 
 // src/cli/sessionManager.ts
-import { promises as fs14, existsSync as existsSync13, readFileSync as readFileSync15, writeFileSync as writeFileSync11, mkdirSync as mkdirSync6, unlinkSync as unlinkSync2, statSync } from "node:fs";
+import { promises as fs15, existsSync as existsSync13, readFileSync as readFileSync15, writeFileSync as writeFileSync11, mkdirSync as mkdirSync6, unlinkSync as unlinkSync2, statSync } from "node:fs";
 import path30 from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
 function getSessionBaseDir() {
@@ -39131,7 +39547,7 @@ function getCurrentSessionFile() {
   return currentSessionPath();
 }
 async function ensureSessionDir() {
-  await fs14.mkdir(getSessionBaseDir(), { recursive: true });
+  await fs15.mkdir(getSessionBaseDir(), { recursive: true });
 }
 function getCurrentSessionId() {
   const file2 = getCurrentSessionFile();
@@ -39181,7 +39597,7 @@ async function listSessions() {
   const baseDir = getSessionBaseDir();
   let entries;
   try {
-    entries = await fs14.readdir(baseDir);
+    entries = await fs15.readdir(baseDir);
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw err;
@@ -39571,16 +39987,16 @@ var init_budgetRuntime = __esm({
 
 // src/cli/budget/restoreRuntime.ts
 import path31 from "node:path";
-async function restoreBudgetRuntimeFromSession(budget, sessionId2, baseDir) {
+async function restoreBudgetRuntimeFromSession(budget, sessionId2, baseDir, cache4) {
   const eventsPath = path31.join(resolveSessionsDir({ baseDir }), sessionId2, "events.jsonl");
-  const report = await readSessionLog(eventsPath).catch(() => null);
+  const report = await readSessionLogCached(eventsPath, cache4).catch(() => null);
   if (!report || report.events.length === 0) return false;
   budget.adoptLedgerFromEvents(report.events);
   return true;
 }
-async function lastHarnessManifestHash(sessionId2, baseDir) {
+async function lastHarnessManifestHash(sessionId2, baseDir, cache4) {
   const eventsPath = path31.join(resolveSessionsDir({ baseDir }), sessionId2, "events.jsonl");
-  const report = await readSessionLog(eventsPath).catch(() => null);
+  const report = await readSessionLogCached(eventsPath, cache4).catch(() => null);
   if (!report) return null;
   for (let i = report.events.length - 1; i >= 0; i--) {
     const e = report.events[i];
@@ -40046,7 +40462,7 @@ async function wrapSessionWriter(inner, sessionId2, options = {}) {
       enforcement: resolveResourceEnforcement()
     });
     if (spine.resumedFromSeq !== void 0 && spine.resumedFromSeq > 0) {
-      await restoreBudgetRuntimeFromSession(budget, sessionId2, options.baseDir);
+      await restoreBudgetRuntimeFromSession(budget, sessionId2, options.baseDir, spine.replayCache);
     }
     spine.attachBudgetRuntime(budget);
     await noteHarnessLifecycle(
@@ -40077,7 +40493,7 @@ async function noteHarnessLifecycle(spine, sessionId2, profileId, budget, baseDi
       resourcePolicy: budget.policy
     });
     if (spine.resumedFromSeq !== void 0 && spine.resumedFromSeq > 0) {
-      if (await lastHarnessManifestHash(sessionId2, baseDir) === null) {
+      if (await lastHarnessManifestHash(sessionId2, baseDir, spine.replayCache) === null) {
         spine.harnessManifest(manifest, manifestHash);
       }
     } else {
@@ -40127,6 +40543,13 @@ var init_sessionSpine = __esm({
       /** Seq the log continued from when adopting an existing session. */
       resumedFromSeq;
       sessionsDir;
+      /**
+       * PERF-4a: session log cache — ONE per session (this mirror). Every read of
+       * `<sessionId>/events.jsonl` goes through it; the kill switch
+       * ZELARI_SPINE_REPLAY_CACHE defaults OFF (see @zelari/core/session
+       * replayCache.ts), and shared with the host helpers that take a cache.
+       */
+      replayCache = new SessionLogCache();
       /**
        * Adopt a 1.x sessionId into the spine: continue the seq when the log
        * already exists (resume), otherwise start fresh with `session.started`.
@@ -40137,7 +40560,10 @@ var init_sessionSpine = __esm({
         if (!spineEnabled()) return mirror;
         try {
           const sessionDir = path33.join(mirror.sessionsDir, sessionId2);
-          const report = await readSessionLog(path33.join(sessionDir, "events.jsonl"));
+          const report = await readSessionLogCached(
+            path33.join(sessionDir, "events.jsonl"),
+            mirror.replayCache
+          );
           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;
@@ -40312,8 +40738,9 @@ var init_sessionSpine = __esm({
        */
       async derivedPriorTurns() {
         if (this.status !== "active" && this.status !== "closed") return null;
-        const report = await readSessionLog(
-          path33.join(this.sessionsDir, this.sessionId, "events.jsonl")
+        const report = await readSessionLogCached(
+          path33.join(this.sessionsDir, this.sessionId, "events.jsonl"),
+          this.replayCache
         ).catch(() => null);
         if (!report || report.events.length === 0) return null;
         return deriveMessages(report.events);
@@ -40322,8 +40749,9 @@ var init_sessionSpine = __esm({
       async compactionStateSnapshot(toSeq) {
         if (this.status !== "active" && this.status !== "closed") return null;
         await this.flush();
-        const report = await readSessionLog(
-          path33.join(this.sessionsDir, this.sessionId, "events.jsonl")
+        const report = await readSessionLogCached(
+          path33.join(this.sessionsDir, this.sessionId, "events.jsonl"),
+          this.replayCache
         ).catch(() => null);
         if (!report || report.events.length === 0) return null;
         return buildCompactionStateSnapshot(report.events, toSeq);
@@ -40335,8 +40763,9 @@ var init_sessionSpine = __esm({
        */
       async lastVerificationRun() {
         if (this.status !== "active" && this.status !== "closed") return null;
-        const report = await readSessionLog(
-          path33.join(this.sessionsDir, this.sessionId, "events.jsonl")
+        const report = await readSessionLogCached(
+          path33.join(this.sessionsDir, this.sessionId, "events.jsonl"),
+          this.replayCache
         ).catch(() => null);
         if (!report) return null;
         return lastVerificationRun(report.events);
@@ -40472,7 +40901,7 @@ var init_sessionSpine = __esm({
           seq = seq.then(async (s) => {
             try {
               const eventsPath = path33.join(this.sessionsDir, this.sessionId, "events.jsonl");
-              const report = await readSessionLog(eventsPath).catch(() => null);
+              const report = await readSessionLogCached(eventsPath, this.replayCache).catch(() => null);
               if (!report || typeof s !== "number") return s;
               const current = latestTaskContract(report.events);
               if (!current) return s;
@@ -40740,7 +41169,7 @@ async function loadObservationIndex(sessionId2, baseDir) {
       mtimeMs = 0;
     }
   }
-  const hit = cache.get(sessionId2);
+  const hit = cache2.get(sessionId2);
   if (hit && !exists) return hit;
   if (hit && hit.filePath === filePath && hit.mtimeMs === mtimeMs) return hit;
   const events = existsSync15(filePath) ? await readSession(filePath) : [];
@@ -40769,12 +41198,12 @@ async function loadObservationIndex(sessionId2, baseDir) {
     if (e.toolCallId) byToolCallId.set(e.toolCallId, seq);
   }
   const index = { filePath, mtimeMs, bySeq, byToolCallId, names };
-  cache.set(sessionId2, index);
+  cache2.set(sessionId2, index);
   return index;
 }
 function invalidateObservationIndex(sessionId2) {
-  if (sessionId2) cache.delete(sessionId2);
-  else cache.clear();
+  if (sessionId2) cache2.delete(sessionId2);
+  else cache2.clear();
 }
 async function getObservationBySeq(sessionId2, seq, baseDir) {
   const index = await loadObservationIndex(sessionId2, baseDir);
@@ -40782,7 +41211,7 @@ async function getObservationBySeq(sessionId2, seq, baseDir) {
 }
 function lookupSeqSync(sessionId2, toolCallId, baseDir) {
   const filePath = sessionFilePath(sessionId2, baseDir);
-  const hit = cache.get(sessionId2);
+  const hit = cache2.get(sessionId2);
   if (hit && hit.filePath === filePath) return hit.byToolCallId.get(toolCallId);
   return void 0;
 }
@@ -40797,10 +41226,10 @@ function emptyIndex(sessionId2, baseDir) {
 }
 function ingestLiveEvent(sessionId2, event, baseDir) {
   if (!sessionId2) return;
-  let index = cache.get(sessionId2);
+  let index = cache2.get(sessionId2);
   if (!index) {
     index = emptyIndex(sessionId2, baseDir);
-    cache.set(sessionId2, index);
+    cache2.set(sessionId2, index);
   }
   if (isToolStart(event)) {
     index.names.set(event.toolCallId, event.toolName);
@@ -40828,19 +41257,19 @@ function applySessionSurface(messages) {
   const lookup = sid ? (id3) => lookupSeqSync(sid, id3) : void 0;
   return projectSessionSurface(messages, void 0, lookup).messages;
 }
-var cache;
+var cache2;
 var init_observationStore = __esm({
   "src/cli/hooks/observationStore.ts"() {
     "use strict";
     init_harness();
     init_sessionManager();
     init_sessionSurface();
-    cache = /* @__PURE__ */ new Map();
+    cache2 = /* @__PURE__ */ new Map();
   }
 });
 
 // packages/core/dist/core/tools/toolOutputSpill.js
-import { createHash as createHash11, randomBytes as randomBytes3 } from "node:crypto";
+import { createHash as createHash12, randomBytes as randomBytes3 } from "node:crypto";
 import { existsSync as existsSync16, mkdirSync as mkdirSync7, writeFileSync as writeFileSync12 } from "node:fs";
 import { homedir as homedir5, tmpdir as tmpdir2 } from "node:os";
 import { join as join14 } from "node:path";
@@ -40870,7 +41299,7 @@ function spillToolOutput(fullText, meta3) {
     if (!existsSync16(dir)) {
       mkdirSync7(dir, { recursive: true });
     }
-    const hash3 = createHash11("sha256").update(fullText).digest("hex").slice(0, 12);
+    const hash3 = createHash12("sha256").update(fullText).digest("hex").slice(0, 12);
     const stamp = Date.now().toString(36);
     const rnd = randomBytes3(3).toString("hex");
     const safeTool = (meta3?.toolName ?? "tool").replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 32);
@@ -41173,7 +41602,7 @@ var init_registry2 = __esm({
 
 // src/cli/safety/sandboxPath.ts
 import path35 from "node:path";
-import fs15 from "node:fs";
+import fs16 from "node:fs";
 function normalizedCase(p3) {
   return IS_CASE_FOLDING ? p3.toLowerCase() : p3;
 }
@@ -41207,7 +41636,7 @@ function assertRealAncestorContained(resolvedLexical, realRoot, userPath) {
   for (; ; ) {
     if (probe === path35.dirname(probe)) break;
     try {
-      realProbe = fs15.realpathSync(probe);
+      realProbe = fs16.realpathSync(probe);
       break;
     } catch (err) {
       if (err?.code === "ENOENT") {
@@ -41235,7 +41664,7 @@ function resolveSandboxedCore(userPath, options = {}) {
   assertLexicalContainment(resolved, root, userPath);
   let realRoot = null;
   try {
-    realRoot = fs15.realpathSync(root);
+    realRoot = fs16.realpathSync(root);
   } catch {
     return resolved;
   }
@@ -41254,7 +41683,7 @@ function verifyContainment(resolvedAbsolute, options = {}) {
   assertLexicalContainment(resolved, root, resolvedAbsolute);
   let realRoot = null;
   try {
-    realRoot = fs15.realpathSync(root);
+    realRoot = fs16.realpathSync(root);
   } catch {
     return;
   }
@@ -41278,7 +41707,7 @@ var init_sandboxPath = __esm({
 });
 
 // src/cli/tools/krakenRadio.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync17, mkdirSync as mkdirSync8, readFileSync as readFileSync16, readdirSync as readdirSync3 } from "node:fs";
+import { appendFileSync as appendFileSync2, closeSync, existsSync as existsSync17, mkdirSync as mkdirSync8, openSync, readFileSync as readFileSync16, readdirSync as readdirSync3, writeSync } from "node:fs";
 import path36 from "node:path";
 function radioDir(cwd) {
   return path36.join(cwd, ".zelari", "radio");
@@ -41287,6 +41716,35 @@ function radioPath(cwd, sessionId2) {
   const safe = (sessionId2 || "default").replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 80);
   return path36.join(radioDir(cwd), `${safe}.jsonl`);
 }
+function appendRadioLine(file2, line) {
+  try {
+    const cached2 = radioFds.get(file2);
+    if (cached2 !== void 0) {
+      writeSync(cached2, line, null, "utf8");
+      return;
+    }
+    if (radioFds.size >= MAX_CACHED_RADIO_FDS) {
+      appendFileSync2(file2, line, "utf8");
+      return;
+    }
+    const fd = openSync(file2, "a");
+    writeSync(fd, line, null, "utf8");
+    radioFds.set(file2, fd);
+  } catch {
+    const stale = radioFds.get(file2);
+    if (stale !== void 0) {
+      radioFds.delete(file2);
+      try {
+        closeSync(stale);
+      } catch {
+      }
+    }
+    try {
+      appendFileSync2(file2, line, "utf8");
+    } catch {
+    }
+  }
+}
 function appendKrakenRadio(cwd, sessionId2, event) {
   try {
     const dir = radioDir(cwd);
@@ -41312,8 +41770,8 @@ function appendKrakenRadio(cwd, sessionId2, event) {
       ...event.symbolsA !== void 0 ? { symbolsA: event.symbolsA } : {},
       ...event.symbolsB !== void 0 ? { symbolsB: event.symbolsB } : {}
     };
-    appendFileSync2(radioPath(cwd, sessionId2), `${JSON.stringify(row)}
-`, "utf8");
+    appendRadioLine(radioPath(cwd, sessionId2), `${JSON.stringify(row)}
+`);
   } catch {
   }
 }
@@ -41350,9 +41808,12 @@ function formatKrakenRadioStatus(cwd, sessionId2, limit = 12) {
   });
   return [`Kraken radio (last ${events.length}) session=${sessionId2}:`, ...lines].join("\n");
 }
+var MAX_CACHED_RADIO_FDS, radioFds;
 var init_krakenRadio = __esm({
   "src/cli/tools/krakenRadio.ts"() {
     "use strict";
+    MAX_CACHED_RADIO_FDS = 32;
+    radioFds = /* @__PURE__ */ new Map();
   }
 });
 
@@ -41366,7 +41827,7 @@ import {
   realpathSync
 } from "node:fs";
 import { join as join15, basename } from "node:path";
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 function resolveWorkspaceRoot(projectRoot = process.cwd()) {
   const candidates = [
     join15(projectRoot, ".zelari"),
@@ -41382,7 +41843,7 @@ function resolveWorkspaceRoot(projectRoot = process.cwd()) {
   return candidates[0];
 }
 function hashProject(projectPath) {
-  return createHash12("sha1").update(realpathSync(projectPath)).digest("hex").slice(0, 12);
+  return createHash13("sha1").update(realpathSync(projectPath)).digest("hex").slice(0, 12);
 }
 function isWritableDir(dir) {
   try {
@@ -42107,12 +42568,12 @@ var init_taskTouchGuard = __esm({
 });
 
 // src/cli/gitOps.ts
-import { execFile as execFile2 } from "node:child_process";
-import { promisify } from "node:util";
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
 import path38 from "node:path";
 async function git2(cwd, args) {
   try {
-    const { stdout } = await execFileAsync("git", ["-C", cwd, ...args], {
+    const { stdout } = await execFileAsync2("git", ["-C", cwd, ...args], {
       maxBuffer: 16 * 1024 * 1024
     });
     return stdout;
@@ -42164,11 +42625,11 @@ async function undoWorkingChanges(opts = {}) {
 function defaultProjectRoot() {
   return path38.resolve(__dirname, "..", "..", "..");
 }
-var execFileAsync;
+var execFileAsync2;
 var init_gitOps = __esm({
   "src/cli/gitOps.ts"() {
     "use strict";
-    execFileAsync = promisify(execFile2);
+    execFileAsync2 = promisify2(execFile3);
   }
 });
 
@@ -42303,7 +42764,7 @@ var auditLogger_exports = {};
 __export(auditLogger_exports, {
   AuditLogger: () => AuditLogger
 });
-import { promises as fs16 } from "node:fs";
+import { promises as fs17 } from "node:fs";
 import path39 from "node:path";
 function defaultAuditPath() {
   return auditLogPath();
@@ -42350,8 +42811,8 @@ var init_auditLogger = __esm({
       async append(entry) {
         const line = JSON.stringify(entry) + "\n";
         this.writeQueue = this.writeQueue.then(async () => {
-          await fs16.mkdir(path39.dirname(this.logPath), { recursive: true });
-          await fs16.appendFile(this.logPath, line, "utf-8");
+          await fs17.mkdir(path39.dirname(this.logPath), { recursive: true });
+          await fs17.appendFile(this.logPath, line, "utf-8");
         });
         return this.writeQueue;
       }
@@ -42570,11 +43031,54 @@ var init_engine2 = __esm({
   }
 });
 
+// src/cli/kraken/worktreeCleanupBatch.ts
+function resolveWorktreeCleanupMode(env = process.env) {
+  const v = (env.ZELARI_KRAKEN_WORKTREE_CLEANUP ?? "").trim().toLowerCase();
+  if (v === "eager") return "eager";
+  return "batch";
+}
+function isKrakenWorktreeCleanupBatched(env = process.env) {
+  return batchScopes > 0 && resolveWorktreeCleanupMode(env) === "batch";
+}
+function beginKrakenWorktreeCleanupBatch(env = process.env) {
+  if (resolveWorktreeCleanupMode(env) !== "batch") return false;
+  batchScopes += 1;
+  return true;
+}
+function queueWorktreeCleanup(repoRoot, branch) {
+  pendingPruneRoots.add(repoRoot);
+  if (!branch) return;
+  const queued = pendingBranches.get(repoRoot) ?? /* @__PURE__ */ new Set();
+  queued.add(branch);
+  pendingBranches.set(repoRoot, queued);
+}
+function takeQueuedWorktreeCleanup() {
+  if (batchScopes > 0) batchScopes -= 1;
+  const repoRoots = /* @__PURE__ */ new Set([...pendingPruneRoots, ...pendingBranches.keys()]);
+  const branchesByRoot = /* @__PURE__ */ new Map();
+  for (const repoRoot of repoRoots) {
+    const queued = pendingBranches.get(repoRoot);
+    if (queued && queued.size > 0) branchesByRoot.set(repoRoot, [...queued]);
+    pendingPruneRoots.delete(repoRoot);
+    pendingBranches.delete(repoRoot);
+  }
+  return { repoRoots: [...repoRoots], branchesByRoot };
+}
+var pendingPruneRoots, pendingBranches, batchScopes;
+var init_worktreeCleanupBatch = __esm({
+  "src/cli/kraken/worktreeCleanupBatch.ts"() {
+    "use strict";
+    pendingPruneRoots = /* @__PURE__ */ new Set();
+    pendingBranches = /* @__PURE__ */ new Map();
+    batchScopes = 0;
+  }
+});
+
 // src/cli/tools/krakenWorktree.ts
-import { execFile as execFile3 } from "node:child_process";
+import { execFile as execFile4 } from "node:child_process";
 import { existsSync as existsSync24, mkdirSync as mkdirSync12, rmSync } from "node:fs";
 import path41 from "node:path";
-import { promisify as promisify2 } from "node:util";
+import { promisify as promisify3 } from "node:util";
 import { randomBytes as randomBytes4 } from "node:crypto";
 function isKrakenWorktreeEnabled(env = process.env) {
   const v = (env.ZELARI_KRAKEN_WORKTREE ?? "").trim().toLowerCase();
@@ -42590,9 +43094,29 @@ function isKrakenWorktreeAutoMergeEnabled(env = process.env) {
   if (v === "0" || v === "false" || v === "no" || v === "off") return false;
   return true;
 }
+async function flushKrakenWorktreeCleanupBatch() {
+  const { repoRoots, branchesByRoot } = takeQueuedWorktreeCleanup();
+  const branches = [];
+  const deleted = [];
+  let pruned = 0;
+  for (const repoRoot of repoRoots) {
+    await git3(repoRoot, ["worktree", "prune"]);
+    pruned += 1;
+    const list = branchesByRoot.get(repoRoot);
+    if (list && list.length > 0) {
+      branches.push(...list);
+      const r = await git3(repoRoot, ["branch", "-D", ...list]);
+      for (const line of r.stdout.split("\n")) {
+        const m = /^Deleted branch (\S+)/.exec(line.trim());
+        if (m?.[1]) deleted.push(m[1]);
+      }
+    }
+  }
+  return { pruned, branches, deleted, repoRoots };
+}
 async function git3(cwd, args) {
   try {
-    const { stdout, stderr } = await execFileAsync2("git", ["-C", cwd, ...args], {
+    const { stdout, stderr } = await execFileAsync3("git", ["-C", cwd, ...args], {
       maxBuffer: 16 * 1024 * 1024,
       windowsHide: true
     });
@@ -42608,10 +43132,15 @@ async function git3(cwd, args) {
   }
 }
 async function resolveGitRoot(cwd) {
+  const key = path41.resolve(cwd);
+  const memo = gitRootMemo.get(key);
+  if (memo) return memo;
   const r = await git3(cwd, ["rev-parse", "--show-toplevel"]);
   if (!r.ok) return null;
   const root = r.stdout.trim();
-  return root || null;
+  if (!root) return null;
+  gitRootMemo.set(key, root);
+  return root;
 }
 async function createKrakenWorktree(cwd, label) {
   const repoRoot = await resolveGitRoot(cwd);
@@ -42741,9 +43270,14 @@ async function cleanupKrakenWorktree(handle, env = process.env) {
     }
   } catch {
   }
+  const branch = handle.branch.startsWith("kraken/") ? handle.branch : null;
+  if (isKrakenWorktreeCleanupBatched(env)) {
+    queueWorktreeCleanup(handle.repoRoot, branch);
+    return;
+  }
   await git3(handle.repoRoot, ["worktree", "prune"]);
-  if (handle.branch.startsWith("kraken/")) {
-    await git3(handle.repoRoot, ["branch", "-D", handle.branch]);
+  if (branch) {
+    await git3(handle.repoRoot, ["branch", "-D", branch]);
   }
 }
 function formatWorktreeFooter(handle, opts = {}) {
@@ -42757,11 +43291,14 @@ function formatWorktreeFooter(handle, opts = {}) {
   }
   return `worktree used: branch=${handle.branch} path=${handle.path}`;
 }
-var execFileAsync2;
+var execFileAsync3, gitRootMemo;
 var init_krakenWorktree = __esm({
   "src/cli/tools/krakenWorktree.ts"() {
     "use strict";
-    execFileAsync2 = promisify2(execFile3);
+    init_worktreeCleanupBatch();
+    init_worktreeCleanupBatch();
+    execFileAsync3 = promisify3(execFile4);
+    gitRootMemo = /* @__PURE__ */ new Map();
   }
 });
 
@@ -43086,6 +43623,43 @@ var init_metrics2 = __esm({
   }
 });
 
+// src/cli/tools/tentacleHeartbeat.ts
+function resolveTentacleHeartbeatMs(env = process.env) {
+  const raw = env.ZELARI_TENTACLE_HEARTBEAT_MS?.trim();
+  if (raw === "0" || raw === "off") return 0;
+  if (!raw) return TENTACLE_HEARTBEAT_DEFAULT_MS;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n >= 0 ? n : TENTACLE_HEARTBEAT_DEFAULT_MS;
+}
+function formatTentacleElapsed(ms) {
+  const totalSec = Math.max(0, Math.floor(ms / 1e3));
+  const m = Math.floor(totalSec / 60);
+  const s = totalSec % 60;
+  return m > 0 ? `${m}m ${s}s` : `${s}s`;
+}
+function tentacleHeartbeatCaption(elapsedMs) {
+  return `reasoning \xB7 ${formatTentacleElapsed(elapsedMs)}`;
+}
+function startTentacleHeartbeat(onBeat, opts) {
+  const intervalMs = opts?.intervalMs ?? resolveTentacleHeartbeatMs();
+  if (intervalMs <= 0) return () => {
+  };
+  const now = opts?.now ?? Date.now;
+  const started = now();
+  const timer = setInterval(() => {
+    onBeat(tentacleHeartbeatCaption(now() - started));
+  }, intervalMs);
+  timer.unref?.();
+  return () => clearInterval(timer);
+}
+var TENTACLE_HEARTBEAT_DEFAULT_MS;
+var init_tentacleHeartbeat = __esm({
+  "src/cli/tools/tentacleHeartbeat.ts"() {
+    "use strict";
+    TENTACLE_HEARTBEAT_DEFAULT_MS = 15e3;
+  }
+});
+
 // src/cli/kraken/tentacle.ts
 var tentacle_exports = {};
 __export(tentacle_exports, {
@@ -43100,15 +43674,46 @@ var init_tentacle = __esm({
   }
 });
 
+// src/cli/asyncLimit.ts
+async function runWithLimit2(items, limit, fn) {
+  const slots = Math.min(
+    items.length,
+    Math.max(1, Number.isFinite(limit) ? Math.floor(limit) : 1)
+  );
+  if (slots <= 0) return;
+  let cursor = 0;
+  let failed = false;
+  const worker = async () => {
+    while (!failed && cursor < items.length) {
+      const index = cursor;
+      cursor += 1;
+      try {
+        await fn(items[index], index);
+      } catch (err) {
+        failed = true;
+        throw err;
+      }
+    }
+  };
+  const workers = [];
+  for (let i = 0; i < slots; i += 1) workers.push(worker());
+  await Promise.all(workers);
+}
+var init_asyncLimit = __esm({
+  "src/cli/asyncLimit.ts"() {
+    "use strict";
+  }
+});
+
 // src/cli/checkpoint/checkpointManager.ts
-import { execFile as execFile4 } from "node:child_process";
-import { promisify as promisify3 } from "node:util";
+import { execFile as execFile5 } from "node:child_process";
+import { promisify as promisify4 } from "node:util";
 import { mkdtempSync, rmSync as rmSync2 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import path42 from "node:path";
 import { randomUUID as randomUUID3 } from "node:crypto";
 async function git4(cwd, args, env) {
-  const { stdout } = await execFileAsync3("git", ["-C", cwd, ...args], {
+  const { stdout } = await execFileAsync4("git", ["-C", cwd, ...args], {
     maxBuffer: 64 * 1024 * 1024,
     env: env ? { ...process.env, ...env } : process.env
   });
@@ -43230,11 +43835,11 @@ async function restoreCheckpoint(cwd, id3) {
 async function dropCheckpoint(cwd, id3) {
   return await gitSafe(cwd, ["update-ref", "-d", `${REF_PREFIX}${id3}`]) !== null;
 }
-var execFileAsync3, REF_PREFIX;
+var execFileAsync4, REF_PREFIX;
 var init_checkpointManager = __esm({
   "src/cli/checkpoint/checkpointManager.ts"() {
     "use strict";
-    execFileAsync3 = promisify3(execFile4);
+    execFileAsync4 = promisify4(execFile5);
     REF_PREFIX = "refs/zelari/checkpoints/";
   }
 });
@@ -43296,7 +43901,7 @@ var init_transactional = __esm({
 });
 
 // src/cli/workspace/worldModel.ts
-import { promises as fs17 } from "node:fs";
+import { promises as fs18 } from "node:fs";
 import path43 from "node:path";
 import { spawn as spawn8 } from "node:child_process";
 function worldDir(cwd) {
@@ -43304,18 +43909,18 @@ function worldDir(cwd) {
 }
 async function ensureWorldDir(cwd) {
   const dir = worldDir(cwd);
-  await fs17.mkdir(dir, { recursive: true });
+  await fs18.mkdir(dir, { recursive: true });
   return dir;
 }
 async function appendTimeline(cwd, entry) {
   const dir = await ensureWorldDir(cwd);
   const line = JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry }) + "\n";
-  await fs17.appendFile(path43.join(dir, TIMELINE_FILE), line, "utf8");
+  await fs18.appendFile(path43.join(dir, TIMELINE_FILE), line, "utf8");
 }
 async function readChecks(cwd) {
   const p3 = path43.join(worldDir(cwd), CHECKS_FILE);
   try {
-    const raw = await fs17.readFile(p3, "utf8");
+    const raw = await fs18.readFile(p3, "utf8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed.checks) ? parsed.checks : [];
   } catch {
@@ -43483,11 +44088,11 @@ var init_worldModel = __esm({
 
 ${args.content}
 `;
-            await fs17.appendFile(file2, block, "utf8");
+            await fs18.appendFile(file2, block, "utf8");
           } else {
-            await fs17.writeFile(file2, args.content, "utf8");
+            await fs18.writeFile(file2, args.content, "utf8");
           }
-          const st = await fs17.stat(file2);
+          const st = await fs18.stat(file2);
           await appendTimeline(ctx.cwd, { kind: "hypothesis_update", bytes: st.size, append: !!args.append });
           return typedOk({ path: file2, bytes: st.size });
         } catch (err) {
@@ -43516,7 +44121,7 @@ ${args.content}
           const dir = await ensureWorldDir(ctx.cwd);
           const file2 = path43.join(dir, CHECKS_FILE);
           const body = { checks: args.checks };
-          await fs17.writeFile(file2, JSON.stringify(body, null, 2) + "\n", "utf8");
+          await fs18.writeFile(file2, JSON.stringify(body, null, 2) + "\n", "utf8");
           await appendTimeline(ctx.cwd, { kind: "checks_set", count: args.checks.length });
           return typedOk({ path: file2, count: args.checks.length });
         } catch (err) {
@@ -43601,7 +44206,7 @@ __export(graphMemory_exports, {
   saveGraphSnapshot: () => saveGraphSnapshot,
   toGraphSnapshot: () => toGraphSnapshot
 });
-import { promises as fs18 } from "node:fs";
+import { promises as fs19 } from "node:fs";
 import path44 from "node:path";
 function snapshotPath(cwd) {
   return path44.join(cwd, SNAPSHOT_DIR, SNAPSHOT_FILE);
@@ -43629,16 +44234,16 @@ function toGraphSnapshot(graph, opts) {
 }
 async function saveGraphSnapshot(cwd, snapshot) {
   try {
-    await fs18.access(cwd);
+    await fs19.access(cwd);
     const file2 = snapshotPath(cwd);
-    await fs18.mkdir(path44.dirname(file2), { recursive: true });
-    await fs18.writeFile(file2, JSON.stringify(snapshot, null, 2) + "\n", "utf8");
+    await fs19.mkdir(path44.dirname(file2), { recursive: true });
+    await fs19.writeFile(file2, JSON.stringify(snapshot, null, 2) + "\n", "utf8");
   } catch {
   }
 }
 async function loadGraphSnapshot(cwd) {
   try {
-    const raw = await fs18.readFile(snapshotPath(cwd), "utf8");
+    const raw = await fs19.readFile(snapshotPath(cwd), "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || !Array.isArray(parsed.nodes)) return null;
     return parsed;
@@ -43705,7 +44310,7 @@ var init_graphMemory = __esm({
 });
 
 // src/cli/kraken/workbench.ts
-import { promises as fs19 } from "node:fs";
+import { promises as fs20 } from "node:fs";
 import path45 from "node:path";
 function isWorkbenchEnabled(env = process.env) {
   const v = (env.ZELARI_KRAKEN_WORKBENCH ?? "1").trim().toLowerCase();
@@ -43876,11 +44481,11 @@ var init_workbench = __esm({
         if (!this.enabled) return null;
         if (!this.dirty && this.lastWrite) return this.lastWrite;
         const out = workbenchPath(this.cwd, this.graphId);
-        await fs19.mkdir(path45.dirname(out), { recursive: true });
+        await fs20.mkdir(path45.dirname(out), { recursive: true });
         const body = this.render();
         const tmp = `${out}.${process.pid}.${Date.now()}.tmp`;
-        await fs19.writeFile(tmp, body, "utf8");
-        await fs19.rename(tmp, out);
+        await fs20.writeFile(tmp, body, "utf8");
+        await fs20.rename(tmp, out);
         this.dirty = false;
         this.lastWrite = Promise.resolve(out);
         return out;
@@ -44460,9 +45065,11 @@ var init_reputationStore = __esm({
 // src/cli/tools/krakenModel.ts
 var krakenModel_exports = {};
 __export(krakenModel_exports, {
+  familyCandidatesFromRegistry: () => familyCandidatesFromRegistry,
   inferModelFamily: () => inferModelFamily,
   isCheapModelId: () => isCheapModelId,
   isKrakenAutoModelEnabled: () => isKrakenAutoModelEnabled,
+  isKrakenCrossModelEnabled: () => isKrakenCrossModelEnabled,
   isUnknownModelError: () => isUnknownModelError,
   parseQualifiedModelRef: () => parseQualifiedModelRef,
   pickCheapModel: () => pickCheapModel,
@@ -44503,6 +45110,10 @@ function isKrakenAutoModelEnabled(env = process.env) {
   if (v === "0" || v === "false" || v === "no" || v === "off") return false;
   return true;
 }
+function isKrakenCrossModelEnabled(env = process.env) {
+  const v = (env.ZELARI_KRAKEN_CROSS_MODEL ?? "").trim().toLowerCase();
+  return !(v === "0" || v === "false" || v === "no" || v === "off");
+}
 function parseQualifiedModelRef(ref) {
   const s = ref?.trim() ?? "";
   const slash = s.indexOf("/");
@@ -44539,8 +45150,7 @@ function pickDifferentFamily(builder, candidates) {
   return null;
 }
 function resolveCrossModelVerifier(builder, candidates, env = process.env) {
-  const cross = (env.ZELARI_KRAKEN_CROSS_MODEL ?? "").trim().toLowerCase();
-  if (cross === "0" || cross === "false" || cross === "off") return null;
+  if (!isKrakenCrossModelEnabled(env)) return null;
   const specific = env.ZELARI_KRAKEN_VERIFY_MODEL?.trim();
   if (specific) {
     const qualified = parseQualifiedModelRef(specific);
@@ -44562,7 +45172,7 @@ function resolveKrakenSubModel(agent, parentModel, env = process.env, opts = {})
     }
     return shared;
   }
-  if (agent === "verify" && opts.familyCandidates && opts.familyCandidates.length > 0) {
+  if (agent === "verify" && opts.familyCandidates && opts.familyCandidates.length > 0 && isKrakenCrossModelEnabled(env)) {
     const picked = pickDifferentFamily(
       { provider: opts.provider ?? "", model: parentModel },
       opts.familyCandidates
@@ -44592,20 +45202,40 @@ function resolvePersonaModel(kind2, parentModel, env = process.env, opts = {}) {
   if (specific) return specific;
   return resolveKrakenSubModel("verify", parentModel, env, opts);
 }
+function familyCandidatesFromRegistry(registry4) {
+  if (!registry4 || typeof registry4 !== "object") return [];
+  const out = [];
+  for (const [key, entry] of Object.entries(registry4)) {
+    const provider = key?.trim() ?? "";
+    if (!provider) continue;
+    const models = entry?.models;
+    if (!Array.isArray(models)) continue;
+    for (const raw of models) {
+      const id3 = typeof raw === "string" ? raw : raw && typeof raw.id === "string" ? raw.id : "";
+      const model = id3.trim();
+      if (model) out.push({ provider, model });
+    }
+  }
+  return out;
+}
 async function resolveKrakenSubModelAsync(agent, parentModel, env = process.env, opts = {}) {
   let candidates = [];
-  if (opts.provider) {
-    try {
-      const mod = await Promise.resolve().then(() => (init_modelDiscovery(), modelDiscovery_exports));
+  let familyCandidates = [];
+  try {
+    const mod = await Promise.resolve().then(() => (init_modelDiscovery(), modelDiscovery_exports));
+    if (opts.provider) {
       const ids = mod.getDiscoveredModelIds(opts.provider);
       if (Array.isArray(ids)) candidates = ids;
-    } catch {
-      candidates = [];
     }
+    familyCandidates = familyCandidatesFromRegistry(mod.loadModelsRegistry());
+  } catch {
+    candidates = [];
+    familyCandidates = [];
   }
   return resolveKrakenSubModel(agent, parentModel, env, {
     provider: opts.provider,
-    candidates
+    candidates,
+    familyCandidates
   });
 }
 var CHEAP_RE, FLAGSHIP_RE;
@@ -45068,6 +45698,7 @@ var init_executor = __esm({
     init_tentacle();
     init_krakenWorktree();
     init_krakenRadio();
+    init_asyncLimit();
     init_transactional();
     init_worldModel();
     init_graphStatus();
@@ -45238,11 +45869,13 @@ var init_executor = __esm({
           }, this.graphTimeoutMs);
           graphTimer.unref?.();
         }
+        const worktreeCleanupBatched = beginKrakenWorktreeCleanupBatch(process.env);
         try {
           return await this.schedule(graph);
         } finally {
           if (graphTimer) clearTimeout(graphTimer);
           this.signal?.removeEventListener("abort", onAbort);
+          if (worktreeCleanupBatched) await flushKrakenWorktreeCleanupBatch();
         }
       }
       /** The scheduling loop proper. See {@link execute} for the cancellation wrapper. */
@@ -46029,6 +46662,7 @@ ${upstream}` : node.prompt,
         const memory = this.deps.memoryService;
         if (!memory || this.deps.memoryAutoWrite === false) return;
         try {
+          const edges = [];
           for (const node of graph.nodes.values()) {
             const nodeMemoryId = this.memoryIds.get(node.id);
             if (!nodeMemoryId) continue;
@@ -46037,22 +46671,21 @@ ${upstream}` : node.prompt,
               if (!dependencyMemoryId) continue;
               if (node.kind === "verify") {
                 const verdict = parseVerifyVerdict(node.result).verdict;
-                await memory.connect({
+                edges.push({
                   from: dependencyMemoryId,
                   to: nodeMemoryId,
-                  relation: verdict === "pass" ? "validated_by" : verdict === "fail" ? "invalidated_by" : "related_to",
-                  createdBy: "kraken-orchestrator"
+                  relation: verdict === "pass" ? "validated_by" : verdict === "fail" ? "invalidated_by" : "related_to"
                 });
               } else {
-                await memory.connect({
-                  from: nodeMemoryId,
-                  to: dependencyMemoryId,
-                  relation: "derived_from",
-                  createdBy: "kraken-orchestrator"
-                });
+                edges.push({ from: nodeMemoryId, to: dependencyMemoryId, relation: "derived_from" });
               }
             }
           }
+          await runWithLimit2(
+            edges,
+            8,
+            (edge) => memory.connect({ ...edge, createdBy: "kraken-orchestrator" }).catch(() => void 0)
+          );
           const counts = countByStatus(graph);
           const outcome = await memory.remember({
             kind: converged ? "outcome" : "failure",
@@ -46064,14 +46697,17 @@ ${upstream}` : node.prompt,
             metadata: { graphId: graph.id, converged, counts, writeClass: "auto" },
             writeClass: "auto"
           });
-          for (const memoryId of this.memoryIds.values()) {
-            await memory.connect({
-              from: outcome.id,
-              to: memoryId,
-              relation: "derived_from",
-              createdBy: "kraken-orchestrator"
-            });
-          }
+          const outcomeEdges = [...this.memoryIds.values()].map((memoryId) => ({
+            from: outcome.id,
+            to: memoryId,
+            relation: "derived_from",
+            createdBy: "kraken-orchestrator"
+          }));
+          await runWithLimit2(
+            outcomeEdges,
+            8,
+            (edge) => memory.connect(edge).catch(() => void 0)
+          );
           await memory.consolidate({
             source: { agent: "kraken-orchestrator", sessionId: this.sessionId },
             minOccurrences: 2
@@ -46875,36 +47511,54 @@ ${taskUserContent}`,
       emitActivity({ type: "agent_tool", agentId: liveId, toolCallId: ev.toolCallId, tool: startedTools.get(ev.toolCallId) ?? "unknown", status: ev.isError ? "failed" : "completed", durationMs: ev.durationMs, ts: Date.now() });
     }
   };
-  let { result, error: error51, aborted: aborted2, usage, toolTrace } = await runSubAgent(harness, {
-    ...opts.signal ? { signal: opts.signal } : {},
-    onEvent: onHarnessEvent
+  const stopHeartbeat = startTentacleHeartbeat((caption) => {
+    emitActivity({
+      type: "agent_status",
+      agentId: liveId,
+      status: "running",
+      message: caption,
+      ts: Date.now()
+    });
   });
-  if (!aborted2 && !result && sub.fallback && sub.fallback.model !== sub.model) {
-    const { isUnknownModelError: isUnknownModelError2 } = await Promise.resolve().then(() => (init_krakenModel(), krakenModel_exports));
-    if (isUnknownModelError2(error51)) {
-      emitPhase(`model ${sub.model} unavailable \u2014 retrying with ${sub.fallback.model}`);
-      const retryConfig = {
-        ...config2,
-        model: sub.fallback.model,
-        provider: sub.fallback.provider,
-        providerStream: sub.fallback.providerStream
-      };
-      try {
-        harness = deps.harnessFactory ? deps.harnessFactory(retryConfig) : new (await Promise.resolve().then(() => (init_harness(), harness_exports))).AgentHarness(retryConfig);
-        const retry = await runSubAgent(harness, {
-          ...opts.signal ? { signal: opts.signal } : {},
-          onEvent: onHarnessEvent
-        });
-        result = retry.result;
-        error51 = retry.error;
-        aborted2 = retry.aborted;
-        usage = retry.usage;
-        toolTrace = retry.toolTrace;
-        sub = { ...sub, model: sub.fallback.model, provider: sub.fallback.provider };
-      } catch (err) {
-        error51 = err instanceof Error ? err.message : String(err);
+  let result;
+  let error51;
+  let aborted2;
+  let usage;
+  let toolTrace;
+  try {
+    ({ result, error: error51, aborted: aborted2, usage, toolTrace } = await runSubAgent(harness, {
+      ...opts.signal ? { signal: opts.signal } : {},
+      onEvent: onHarnessEvent
+    }));
+    if (!aborted2 && !result && sub.fallback && sub.fallback.model !== sub.model) {
+      const { isUnknownModelError: isUnknownModelError2 } = await Promise.resolve().then(() => (init_krakenModel(), krakenModel_exports));
+      if (isUnknownModelError2(error51)) {
+        emitPhase(`model ${sub.model} unavailable \u2014 retrying with ${sub.fallback.model}`);
+        const retryConfig = {
+          ...config2,
+          model: sub.fallback.model,
+          provider: sub.fallback.provider,
+          providerStream: sub.fallback.providerStream
+        };
+        try {
+          harness = deps.harnessFactory ? deps.harnessFactory(retryConfig) : new (await Promise.resolve().then(() => (init_harness(), harness_exports))).AgentHarness(retryConfig);
+          const retry = await runSubAgent(harness, {
+            ...opts.signal ? { signal: opts.signal } : {},
+            onEvent: onHarnessEvent
+          });
+          result = retry.result;
+          error51 = retry.error;
+          aborted2 = retry.aborted;
+          usage = retry.usage;
+          toolTrace = retry.toolTrace;
+          sub = { ...sub, model: sub.fallback.model, provider: sub.fallback.provider };
+        } catch (err) {
+          error51 = err instanceof Error ? err.message : String(err);
+        }
       }
     }
+  } finally {
+    stopHeartbeat();
   }
   const durationMs = Date.now() - started;
   if (aborted2) {
@@ -46914,7 +47568,7 @@ ${taskUserContent}`,
       agent,
       thoroughness,
       description: args.description,
-      detail: "cancelled: node timeout",
+      detail: "cancelled by parent",
       model: sub.model,
       worktree: worktree?.path ?? null,
       durationMs,
@@ -46926,7 +47580,7 @@ ${taskUserContent}`,
       detail: "cancelled",
       durationMs
     });
-    return { ok: false, agent, error: "task: sub-agent cancelled (node timeout)", cancelled: true };
+    return { ok: false, agent, error: "task: sub-agent cancelled by parent", cancelled: true };
   }
   if (!result) {
     if (worktree) await cleanupKrakenWorktree(worktree);
@@ -47204,6 +47858,7 @@ var init_taskTool = __esm({
     init_verifyReport();
     init_metrics2();
     init_dist();
+    init_tentacleHeartbeat();
     TASK_TOOL_TIMEOUT_MS = 27e5;
     EXPLORE_PROMPT = [
       "You are a focused EXPLORE tentacle of Kraken (parent super-agent).",
@@ -49136,7 +49791,7 @@ var init_planTaskTools = __esm({
 });
 
 // src/cli/tools/inspectTypecheckSafety.ts
-import { promises as fs20 } from "node:fs";
+import { promises as fs21 } from "node:fs";
 import path49 from "node:path";
 import { spawn as spawn9 } from "node:child_process";
 async function scanTsbuildinfo(root) {
@@ -49146,7 +49801,7 @@ async function scanTsbuildinfo(root) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = await fs20.readdir(dir, { withFileTypes: true });
+      entries = await fs21.readdir(dir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -49191,7 +49846,7 @@ async function cleanupArtifacts(root, relPaths) {
   const failed = [];
   for (const rel2 of relPaths) {
     try {
-      await fs20.unlink(path49.join(root, rel2));
+      await fs21.unlink(path49.join(root, rel2));
       cleaned.push(rel2);
     } catch {
       failed.push(rel2);
@@ -49215,8 +49870,8 @@ var init_inspectTypecheckSafety = __esm({
 
 // src/cli/tools/inspectCommand.ts
 import { spawn as spawn10 } from "node:child_process";
-import { createHash as createHash13 } from "node:crypto";
-import { existsSync as existsSync28, promises as fs21 } from "node:fs";
+import { createHash as createHash14 } from "node:crypto";
+import { existsSync as existsSync28, promises as fs22 } from "node:fs";
 import os2 from "node:os";
 import path50 from "node:path";
 function resolveNodeModuleBin(start, rel2) {
@@ -49302,7 +49957,7 @@ function buildInspectCommand(op, ctx) {
     }
     case "typecheck": {
       const project = path50.resolve(ctx.cwd, op.project ?? "tsconfig.json");
-      const hash3 = createHash13("sha256").update(project).digest("hex").slice(0, 16);
+      const hash3 = createHash14("sha256").update(project).digest("hex").slice(0, 16);
       const tsBuildInfoFile = path50.join(os2.tmpdir(), "zelari-inspect", `${hash3}.tsbuildinfo`);
       return {
         ok: true,
@@ -49441,7 +50096,7 @@ function createInspectCommandTool(rootOrDeps) {
       if (op.operation === "typecheck") {
         const tsc = built.argv[0];
         try {
-          await fs21.access(tsc);
+          await fs22.access(tsc);
         } catch {
           return typedErr(
             `TYPESCRIPT_UNAVAILABLE: no TypeScript compiler at ${tsc} \u2014 inspect_command typecheck uses the project toolchain (walk-up to node_modules/typescript/bin/tsc) and refuses to guess. Install dependencies or fall back to read_file/grep_content.`
@@ -50837,11 +51492,11 @@ var init_store2 = __esm({
 });
 
 // src/cli/semantic/index.ts
-import { promises as fs22, existsSync as existsSync29, readFileSync as readFileSync21 } from "node:fs";
+import { promises as fs23, existsSync as existsSync29, readFileSync as readFileSync21 } from "node:fs";
 import path53 from "node:path";
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 function getIndexPath(root) {
-  const hash3 = createHash14("sha1").update(path53.resolve(root)).digest("hex").slice(0, 16);
+  const hash3 = createHash15("sha1").update(path53.resolve(root)).digest("hex").slice(0, 16);
   return process.env.ZELARI_SEMANTIC_FILE ?? path53.join(semanticStateDir(), `${hash3}.json`);
 }
 async function collectSourceFiles(root, maxFiles = 1500) {
@@ -50850,7 +51505,7 @@ async function collectSourceFiles(root, maxFiles = 1500) {
     if (out.length >= maxFiles) return;
     let entries;
     try {
-      entries = await fs22.readdir(dir, { withFileTypes: true });
+      entries = await fs23.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -50880,7 +51535,7 @@ async function buildIndex(files, embed, options) {
   for (const file2 of files) {
     let text;
     try {
-      text = await fs22.readFile(file2, "utf8");
+      text = await fs23.readFile(file2, "utf8");
     } catch {
       continue;
     }
@@ -50913,10 +51568,10 @@ async function buildIndex(files, embed, options) {
 }
 async function saveIndex(root, data) {
   const file2 = getIndexPath(root);
-  await fs22.mkdir(path53.dirname(file2), { recursive: true });
+  await fs23.mkdir(path53.dirname(file2), { recursive: true });
   const tmp = `${file2}.tmp-${process.pid}`;
-  await fs22.writeFile(tmp, JSON.stringify(data), "utf8");
-  await fs22.rename(tmp, file2);
+  await fs23.writeFile(tmp, JSON.stringify(data), "utf8");
+  await fs23.rename(tmp, file2);
 }
 function loadIndex(root) {
   const file2 = getIndexPath(root);
@@ -52177,13 +52832,13 @@ var init_tools5 = __esm({
 });
 
 // src/cli/tools/screenshotTool.ts
-import { execFile as execFile5 } from "node:child_process";
+import { execFile as execFile6 } from "node:child_process";
 import { mkdir as mkdir3, readFile as readFile8, stat as stat7 } from "node:fs/promises";
 import path57 from "node:path";
-import { promisify as promisify4 } from "node:util";
+import { promisify as promisify5 } from "node:util";
 async function captureWindows(target) {
   const script = `Add-Type -AssemblyName System.Windows.Forms,System.Drawing;$b=[System.Windows.Forms.SystemInformation]::VirtualScreen;$bmp=New-Object System.Drawing.Bitmap $b.Width,$b.Height;$g=[System.Drawing.Graphics]::FromImage($bmp);$g.CopyFromScreen($b.Left,$b.Top,0,0,$bmp.Size);$g.Dispose(); $bmp.Save('${target.replace(/'/g, "''")}'); $bmp.Dispose();`;
-  await execFileAsync4("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
+  await execFileAsync5("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
     timeout: 12e3,
     windowsHide: true
   });
@@ -52197,7 +52852,7 @@ async function captureUnixLike(target) {
   let lastErr = null;
   for (const [bin, args] of attempts) {
     try {
-      await execFileAsync4(bin, args, { timeout: 12e3 });
+      await execFileAsync5(bin, args, { timeout: 12e3 });
       return;
     } catch (e) {
       lastErr = e;
@@ -52251,13 +52906,13 @@ function createScreenshotTool(deps = {}) {
     }
   };
 }
-var execFileAsync4, SCREENSHOT_MAX_BYTES2;
+var execFileAsync5, SCREENSHOT_MAX_BYTES2;
 var init_screenshotTool = __esm({
   "src/cli/tools/screenshotTool.ts"() {
     "use strict";
     init_zod();
     init_toolTypes();
-    execFileAsync4 = promisify4(execFile5);
+    execFileAsync5 = promisify5(execFile6);
     SCREENSHOT_MAX_BYTES2 = 8 * 1024 * 1024;
   }
 });
@@ -53580,6 +54235,163 @@ var init_resolveStream = __esm({
   }
 });
 
+// src/cli/providerFailover.ts
+function providerFailover(options) {
+  const isTransient = options.isTransientFailure ?? DEFAULT_IS_TRANSIENT;
+  const primaryFailedMsg = options.fallbackLabel ? `[failover] primary failed, switching to ${options.fallbackLabel}` : "[failover] primary failed, switching to fallback";
+  const primaryThrewMsg = options.fallbackLabel ? `[failover] primary threw, switching to ${options.fallbackLabel}: ` : "[failover] primary threw: ";
+  const fallbackFailedMsg = options.fallbackLabel ? `[failover] fallback (${options.fallbackLabel}) also failed: ` : "[failover] fallback also failed: ";
+  const notify = (phase2, message) => {
+    if (!options.onFailover) return;
+    try {
+      options.onFailover({
+        phase: phase2,
+        message,
+        ...options.fallbackLabel ? { label: options.fallbackLabel } : {}
+      });
+    } catch {
+    }
+  };
+  return async function* (params) {
+    const triedFallback = { value: false };
+    try {
+      for await (const delta of options.primary(params)) {
+        if (isTransient(delta)) {
+          yield delta;
+          triedFallback.value = true;
+          yield {
+            kind: "error",
+            message: primaryFailedMsg
+          };
+          notify("swap-delta", primaryFailedMsg);
+          break;
+        }
+        yield delta;
+      }
+    } catch (err) {
+      triedFallback.value = true;
+      const threwMsg = `${primaryThrewMsg}${err instanceof Error ? err.message : String(err)}`;
+      yield {
+        kind: "error",
+        message: threwMsg
+      };
+      notify("swap-throw", threwMsg);
+    }
+    if (triedFallback.value) {
+      try {
+        for await (const delta of options.fallback(params)) {
+          yield delta;
+        }
+      } catch (err) {
+        const failedMsg = `${fallbackFailedMsg}${err instanceof Error ? err.message : String(err)}`;
+        yield {
+          kind: "error",
+          message: failedMsg
+        };
+        notify("fallback-failed", failedMsg);
+        return;
+      }
+    }
+  };
+}
+var DEFAULT_IS_TRANSIENT;
+var init_providerFailover = __esm({
+  "src/cli/providerFailover.ts"() {
+    "use strict";
+    DEFAULT_IS_TRANSIENT = (delta) => delta.kind === "error";
+  }
+});
+
+// src/cli/crossProviderFailover.ts
+var crossProviderFailover_exports = {};
+__export(crossProviderFailover_exports, {
+  isHeadlessFailoverEnabled: () => isHeadlessFailoverEnabled,
+  resolveFailoverStream: () => resolveFailoverStream,
+  wrapWithHeadlessFailover: () => wrapWithHeadlessFailover
+});
+async function resolveFailoverStream(options) {
+  if (!options.failoverEnabled) {
+    return {
+      fallback: options.primary,
+      fallbackLabel: void 0,
+      warning: "",
+      reason: "disabled"
+    };
+  }
+  const requested = options.envValue?.trim();
+  if (!requested || requested.length === 0) {
+    return {
+      fallback: options.primary,
+      fallbackLabel: void 0,
+      warning: "",
+      reason: "unset"
+    };
+  }
+  const valid = new Set(options.validProviderIds);
+  if (!valid.has(requested)) {
+    return {
+      fallback: options.primary,
+      fallbackLabel: void 0,
+      warning: `[failover] ANATHEMA_FAILOVER_PROVIDER="${requested}" is not a known provider. Falling back to v3-G same-provider behavior. Available: ${options.validProviderIds.join(", ")}.`,
+      reason: "unknown"
+    };
+  }
+  if (requested === options.primaryProviderId) {
+    return {
+      fallback: options.primary,
+      fallbackLabel: void 0,
+      warning: "",
+      reason: "same-as-primary"
+    };
+  }
+  const fallbackConfig = await options.lookupFallbackConfig(requested);
+  if (!fallbackConfig) {
+    return {
+      fallback: options.primary,
+      fallbackLabel: void 0,
+      warning: `[failover] No API key configured for provider "${requested}". Falling back to v3-G same-provider behavior.`,
+      reason: "missing-key"
+    };
+  }
+  return {
+    fallback: options.buildStream(fallbackConfig),
+    fallbackLabel: requested,
+    warning: "",
+    reason: "resolved"
+  };
+}
+function isHeadlessFailoverEnabled(env = process.env) {
+  return env.ZELARI_HEADLESS_FAILOVER === "1" && env.ANATHEMA_FAILOVER !== "0";
+}
+async function wrapWithHeadlessFailover(options) {
+  const env = options.env ?? process.env;
+  if (!isHeadlessFailoverEnabled(env)) {
+    return options.primary;
+  }
+  const resolved = await resolveFailoverStream({
+    failoverEnabled: true,
+    envValue: env.ANATHEMA_FAILOVER_PROVIDER,
+    primaryProviderId: options.primaryProviderId,
+    primary: options.primary,
+    validProviderIds: options.validProviderIds,
+    lookupFallbackConfig: options.lookupFallbackConfig,
+    buildStream: options.buildStream
+  });
+  if (resolved.warning) options.onWarning?.(resolved.warning);
+  return providerFailover({
+    primary: options.primary,
+    fallback: resolved.fallback,
+    ...resolved.fallbackLabel ? { fallbackLabel: resolved.fallbackLabel } : {},
+    ...options.onFailover ? { onFailover: options.onFailover } : {}
+  });
+}
+var init_crossProviderFailover = __esm({
+  "src/cli/crossProviderFailover.ts"() {
+    "use strict";
+    init_providerFailover();
+  }
+});
+
 // src/cli/safety/toolPermissions.ts
 var toolPermissions_exports = {};
 __export(toolPermissions_exports, {
@@ -53766,7 +54578,7 @@ function recordNonUserContent(source2, text, tool) {
     const excerpt = normalize5(raw).slice(0, MAX_EXCERPT);
     if (excerpt.length < PROVENANCE_MIN_MATCH * 2) return;
     ring.push({ source: source2, tool, excerpt, at: Date.now() });
-    if (ring.length > MAX_ENTRIES) ring.splice(0, ring.length - MAX_ENTRIES);
+    if (ring.length > MAX_ENTRIES2) ring.splice(0, ring.length - MAX_ENTRIES2);
   } catch {
   }
 }
@@ -53822,11 +54634,11 @@ function safeJson2(v) {
     return "";
   }
 }
-var MAX_ENTRIES, MAX_EXCERPT, PROVENANCE_MIN_MATCH, SHINGLE_STEP, MAX_SHINGLES, ring;
+var MAX_ENTRIES2, MAX_EXCERPT, PROVENANCE_MIN_MATCH, SHINGLE_STEP, MAX_SHINGLES, ring;
 var init_provenance = __esm({
   "src/cli/safety/provenance.ts"() {
     "use strict";
-    MAX_ENTRIES = 40;
+    MAX_ENTRIES2 = 40;
     MAX_EXCERPT = 8192;
     PROVENANCE_MIN_MATCH = 48;
     SHINGLE_STEP = 24;
@@ -54019,7 +54831,7 @@ var init_lifecycleHooks = __esm({
 });
 
 // src/cli/safety/astGate.ts
-import { promises as fs23 } from "node:fs";
+import { promises as fs24 } from "node:fs";
 import path59 from "node:path";
 function astGateEnabled() {
   return process.env.ZELARI_AST_GATE !== "0";
@@ -54069,7 +54881,7 @@ function wrapWithAstGate(original, opts) {
         if (astGateEnabled()) gateTarget = containedPathOf(args);
         if (gateTarget !== null && isAstSupported(gateTarget)) {
           try {
-            preContent = await fs23.readFile(gateTarget, "utf8");
+            preContent = await fs24.readFile(gateTarget, "utf8");
           } catch (err) {
             if (err?.code === "ENOENT") preContent = null;
           }
@@ -54098,16 +54910,16 @@ function wrapWithAstGate(original, opts) {
           );
           return result;
         }
-        const post = await fs23.readFile(absPath, "utf8");
+        const post = await fs24.readFile(absPath, "utf8");
         const syntaxError = firstSyntaxError(ts, path59.basename(absPath), post);
         if (!syntaxError) return result;
         const parseError = `${syntaxError.message} (line ${syntaxError.line}, col ${syntaxError.character})`;
         let revertedTo;
         if (preContent === null) {
-          await fs23.unlink(absPath).catch(() => void 0);
+          await fs24.unlink(absPath).catch(() => void 0);
           revertedTo = "absent";
         } else {
-          await fs23.writeFile(absPath, preContent, "utf8");
+          await fs24.writeFile(absPath, preContent, "utf8");
           revertedTo = snapshotIdOf(preContent);
         }
         const relLabel = path59.relative(opts.root, absPath) || path59.basename(absPath);
@@ -54533,8 +55345,8 @@ var init_resourceClaims = __esm({
 });
 
 // src/cli/toolResultCache.ts
-import { createHash as createHash15 } from "node:crypto";
-import { promises as fs24 } from "node:fs";
+import { createHash as createHash16 } from "node:crypto";
+import { promises as fs25 } from "node:fs";
 import path60 from "node:path";
 function isToolCacheEnabled() {
   const raw = process.env.ZELARI_TOOL_CACHE;
@@ -54546,7 +55358,7 @@ function resolveToolCacheTtlMs() {
   return Number.isFinite(n) && n >= 0 ? n : TOOL_CACHE_DEFAULT_TTL_MS;
 }
 function hashKey(parts) {
-  return createHash15("sha256").update(JSON.stringify(parts), "utf8").digest("hex");
+  return createHash16("sha256").update(JSON.stringify(parts), "utf8").digest("hex");
 }
 function resultBytes(result) {
   try {
@@ -54622,7 +55434,7 @@ async function statKey(toolName, input, ctx) {
   if (typeof rawPath !== "string" || rawPath.length === 0) return null;
   const abs = path60.isAbsolute(rawPath) ? rawPath : path60.join(ctx.cwd, rawPath);
   try {
-    const st = await fs24.stat(abs);
+    const st = await fs25.stat(abs);
     return hashKey({
       tool: toolName,
       args: input,
@@ -55047,9 +55859,11 @@ function createKrakenSubAgentContextFactory(opts) {
   return async ({ agent, cwd: subCwd }) => {
     const cfg = providerOverride ? await providerConfigFor(providerOverride) : await providerFromEnv();
     if (!cfg) return null;
-    const { resolveKrakenSubModel: resolveKrakenSubModel2, parseQualifiedModelRef: parseQualifiedModelRef2 } = await Promise.resolve().then(() => (init_krakenModel(), krakenModel_exports));
+    const { resolveKrakenSubModelAsync: resolveKrakenSubModelAsync2, parseQualifiedModelRef: parseQualifiedModelRef2 } = await Promise.resolve().then(() => (init_krakenModel(), krakenModel_exports));
     const parentModel = modelOverride || cfg.model;
-    const resolvedModel = resolveKrakenSubModel2(agent, parentModel);
+    const resolvedModel = await resolveKrakenSubModelAsync2(agent, parentModel, process.env, {
+      provider: cfg.providerId
+    });
     let effCfg = cfg;
     let model = resolvedModel;
     const ref = parseQualifiedModelRef2(resolvedModel);
@@ -55082,15 +55896,31 @@ function createKrakenSubAgentContextFactory(opts) {
       // P0.5: the tentacle's agent identity drives per-agent policy rules.
       policyAgent: agent
     });
+    const wrapTentacleStream = (primary, primaryProviderId) => wrapWithHeadlessFailover({
+      primary,
+      primaryProviderId,
+      validProviderIds: PROVIDERS.map((p3) => p3.id),
+      lookupFallbackConfig: (id3) => providerConfigFor(id3),
+      buildStream: (config2) => buildProviderStream(config2)
+    });
+    const providerStream = await wrapTentacleStream(
+      buildProviderStream(subCfg),
+      subCfg.providerId
+    );
     return {
-      providerStream: buildProviderStream(subCfg),
+      providerStream,
       model,
       provider: subCfg.providerId,
       ...model !== parentModel ? {
         fallback: {
           model: parentModel,
           provider: cfg.providerId,
-          providerStream: buildProviderStream({ ...cfg, model: parentModel })
+          // Wrap the 404-parent fallback too so a later model retry still
+          // has transport failover. Orthogonal to isUnknownModelError.
+          providerStream: await wrapTentacleStream(
+            buildProviderStream({ ...cfg, model: parentModel }),
+            cfg.providerId
+          )
         }
       } : {},
       registry: subRegistry,
@@ -55577,6 +56407,8 @@ var init_toolRegistry = __esm({
     init_openai_compatible();
     init_resolveStream();
     init_providerConfig();
+    init_crossProviderFailover();
+    init_keyStore();
     init_toolPermissions();
     init_destructiveCommands();
     init_provenance();
@@ -55617,12 +56449,12 @@ var init_toolRegistry = __esm({
 });
 
 // src/cli/metrics.ts
-import { promises as fs25, existsSync as existsSync33, statSync as statSync4, renameSync as renameSync4, appendFileSync as appendFileSync3, mkdirSync as mkdirSync15 } from "node:fs";
+import { promises as fs26, existsSync as existsSync33, statSync as statSync4, renameSync as renameSync4, appendFileSync as appendFileSync3, mkdirSync as mkdirSync15 } from "node:fs";
 import path62 from "node:path";
 async function readMetrics(file2) {
   let raw = "";
   try {
-    raw = await fs25.readFile(file2, "utf-8");
+    raw = await fs26.readFile(file2, "utf-8");
   } catch {
     return [];
   }
@@ -56000,8 +56832,8 @@ __export(completionProofProbe_exports, {
   gatherGitAttestation: () => gatherGitAttestation,
   harnessManifest: () => harnessManifest
 });
-import { execFile as execFile6 } from "node:child_process";
-import { promisify as promisify5 } from "node:util";
+import { execFile as execFile7 } from "node:child_process";
+import { promisify as promisify6 } from "node:util";
 async function readHarnessVersion() {
   if (cachedHarnessVersion !== null) return cachedHarnessVersion;
   try {
@@ -56032,7 +56864,7 @@ async function harnessManifest(env = process.env) {
 }
 async function git5(cwd, args) {
   try {
-    const { stdout } = await execFileAsync5("git", ["-C", cwd, ...args], {
+    const { stdout } = await execFileAsync6("git", ["-C", cwd, ...args], {
       maxBuffer: 32 * 1024 * 1024,
       windowsHide: true
     });
@@ -56074,7 +56906,7 @@ function activeTaskContractSnapshot() {
     return void 0;
   }
 }
-var HARNESS_VERSION_FALLBACK, ADAPTER_IDS, cachedHarnessVersion, execFileAsync5;
+var HARNESS_VERSION_FALLBACK, ADAPTER_IDS, cachedHarnessVersion, execFileAsync6;
 var init_completionProofProbe = __esm({
   "src/cli/kraken/completionProofProbe.ts"() {
     "use strict";
@@ -56082,14 +56914,14 @@ var init_completionProofProbe = __esm({
     HARNESS_VERSION_FALLBACK = "2.13.0";
     ADAPTER_IDS = ["node", "python", "rust", "go", "java", "dotnet"];
     cachedHarnessVersion = null;
-    execFileAsync5 = promisify5(execFile6);
+    execFileAsync6 = promisify6(execFile7);
   }
 });
 
 // src/cli/kraken/completionProofAttestation.ts
-import { createHash as createHash16 } from "node:crypto";
+import { createHash as createHash17 } from "node:crypto";
 function sha256Hex3(data) {
-  return createHash16("sha256").update(data, "utf8").digest("hex");
+  return createHash17("sha256").update(data, "utf8").digest("hex");
 }
 function canonicalJson(value) {
   return JSON.stringify(canonicalValue(value));
@@ -56549,21 +57381,21 @@ var init_askUserTimeout = __esm({
 });
 
 // src/cli/state/fileStateStore.ts
-import { createHash as createHash17, randomUUID as randomUUID5 } from "node:crypto";
-import { promises as fs26 } from "node:fs";
+import { createHash as createHash18, randomUUID as randomUUID5 } from "node:crypto";
+import { promises as fs27 } from "node:fs";
 import * as path65 from "node:path";
 function shortId() {
   return randomUUID5().replace(/-/g, "").slice(0, 12);
 }
 async function writeJsonAtomic(filePath, data) {
-  await fs26.mkdir(path65.dirname(filePath), { recursive: true });
+  await fs27.mkdir(path65.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  await fs26.writeFile(tmp, JSON.stringify(data, null, 2) + "\n", "utf8");
-  await fs26.rename(tmp, filePath);
+  await fs27.writeFile(tmp, JSON.stringify(data, null, 2) + "\n", "utf8");
+  await fs27.rename(tmp, filePath);
 }
 async function readJsonFile(filePath) {
   try {
-    const raw = await fs26.readFile(filePath, "utf8");
+    const raw = await fs27.readFile(filePath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -56601,7 +57433,7 @@ async function getStateStore(projectRoot, env = process.env) {
   }
 }
 function hashStablePrompt(stable) {
-  return createHash17("sha256").update(stable, "utf8").digest("hex").slice(0, 16);
+  return createHash18("sha256").update(stable, "utf8").digest("hex").slice(0, 16);
 }
 var DEFAULT_MATERIALIZE_CHARS, FileDurableStateStore, NoopDurableStateStore;
 var init_fileStateStore = __esm({
@@ -56622,8 +57454,8 @@ var init_fileStateStore = __esm({
         this.artifactsDir = path65.join(this.stateDir, "artifacts");
         this.headPath = path65.join(this.stateDir, "HEAD.json");
         this.indexPath = path65.join(this.stateDir, "index.jsonl");
-        await fs26.mkdir(this.commitsDir, { recursive: true });
-        await fs26.mkdir(this.artifactsDir, { recursive: true });
+        await fs27.mkdir(this.commitsDir, { recursive: true });
+        await fs27.mkdir(this.artifactsDir, { recursive: true });
       }
       async commit(input) {
         if (!input.force && input.verification.ran && !input.verification.ok) {
@@ -56636,9 +57468,9 @@ var init_fileStateStore = __esm({
         const id3 = shortId();
         const artifactRel = path65.join("artifacts", id3);
         const artifactAbs = path65.join(this.artifactsDir, id3);
-        await fs26.mkdir(artifactAbs, { recursive: true });
+        await fs27.mkdir(artifactAbs, { recursive: true });
         const summary = defaultSummary(input, discoveries);
-        await fs26.writeFile(path65.join(artifactAbs, "summary.md"), summary + "\n", "utf8");
+        await fs27.writeFile(path65.join(artifactAbs, "summary.md"), summary + "\n", "utf8");
         await writeJsonAtomic(path65.join(artifactAbs, "discoveries.json"), discoveries);
         await writeJsonAtomic(path65.join(artifactAbs, "verification.json"), input.verification);
         const meta3 = {
@@ -56661,7 +57493,7 @@ var init_fileStateStore = __esm({
         };
         await writeJsonAtomic(path65.join(this.commitsDir, `${id3}.json`), meta3);
         await writeJsonAtomic(this.headPath, { id: id3, updatedAt: meta3.createdAt });
-        await fs26.appendFile(this.indexPath, JSON.stringify({ id: id3, createdAt: meta3.createdAt, label: meta3.label }) + "\n", "utf8");
+        await fs27.appendFile(this.indexPath, JSON.stringify({ id: id3, createdAt: meta3.createdAt, label: meta3.label }) + "\n", "utf8");
         return stripStored(meta3);
       }
       async head() {
@@ -56676,7 +57508,7 @@ var init_fileStateStore = __esm({
       async list(limit = 20) {
         let raw;
         try {
-          raw = await fs26.readFile(this.indexPath, "utf8");
+          raw = await fs27.readFile(this.indexPath, "utf8");
         } catch {
           return [];
         }
@@ -57649,7 +58481,10 @@ async function countVerificationEvidenceInLog(mirror, sessionId2) {
   if (mirror.status !== "active" && mirror.status !== "closed") return -1;
   try {
     await mirror.flush().catch(() => void 0);
-    const report = await readSessionLog(path67.join(mirror.sessionsDir, sessionId2, "events.jsonl"));
+    const report = await readSessionLogCached(
+      path67.join(mirror.sessionsDir, sessionId2, "events.jsonl"),
+      mirror.replayCache
+    );
     return report.events.filter((e) => e.kind === "verification.evidence").length;
   } catch (err) {
     process.stderr.write(
@@ -57682,7 +58517,7 @@ async function openHeadlessSpine(opts) {
   if (spine.status === "active") {
     const budget = new BudgetRuntime(profileId, { enforcement: resolveResourceEnforcement() });
     if (spine.resumedFromSeq !== void 0 && spine.resumedFromSeq > 0) {
-      await restoreBudgetRuntimeFromSession(budget, opts.sessionId, opts.baseDir);
+      await restoreBudgetRuntimeFromSession(budget, opts.sessionId, opts.baseDir, spine.replayCache);
     }
     spine.attachBudgetRuntime(budget);
     const manifestSpecs = opts.toolSpecs?.filter((spec) => profileTools.includes(spec.name));
@@ -58442,11 +59277,11 @@ var init_planDetect = __esm({
 });
 
 // src/cli/memory/legacyImport.ts
-import { createHash as createHash18 } from "node:crypto";
-import { promises as fs27 } from "node:fs";
+import { createHash as createHash19 } from "node:crypto";
+import { promises as fs28 } from "node:fs";
 import * as path68 from "node:path";
 function sourceId(fact, line) {
-  return `jsonl:${fact.id ?? createHash18("sha256").update(line).digest("hex")}`;
+  return `jsonl:${fact.id ?? createHash19("sha256").update(line).digest("hex")}`;
 }
 function kind(metadata2) {
   const raw = metadata2.memoryKind;
@@ -58460,15 +59295,38 @@ function timestamp(value) {
   const parsed = Date.parse(value);
   return Number.isFinite(parsed) ? new Date(parsed).toISOString() : void 0;
 }
+function isPermanentSkip(error51) {
+  return error51 instanceof MemoryPolicyError || error51?.name === "ZodError";
+}
+async function isImportComplete(markerPath) {
+  try {
+    const marker = JSON.parse(await fs28.readFile(markerPath, "utf8"));
+    return typeof marker?.found === "number" && typeof marker?.at === "string";
+  } catch {
+    return false;
+  }
+}
+async function markImportComplete(markerPath, found) {
+  const temporary = `${markerPath}.tmp`;
+  try {
+    await fs28.writeFile(temporary, `${JSON.stringify({ found, at: (/* @__PURE__ */ new Date()).toISOString() })}
+`, "utf8");
+    await fs28.rename(temporary, markerPath);
+  } catch {
+  }
+}
 async function importLegacyMemoryLog(backend, service) {
   const result = { found: 0, imported: 0, skipped: 0, corrupt: 0 };
-  const logPath = path68.join(path68.dirname(backend.databasePath), "log.jsonl");
+  const memoryDir = path68.dirname(backend.databasePath);
+  const markerPath = path68.join(memoryDir, LEGACY_IMPORT_MARKER);
+  if (await isImportComplete(markerPath)) return result;
   let raw;
   try {
-    raw = await fs27.readFile(logPath, "utf8");
+    raw = await fs28.readFile(path68.join(memoryDir, "log.jsonl"), "utf8");
   } catch {
     return result;
   }
+  const rows = [];
   for (const line of raw.split(/\r?\n/)) {
     const trimmed = line.trim();
     if (!trimmed) continue;
@@ -58485,17 +59343,22 @@ async function importLegacyMemoryLog(backend, service) {
       result.corrupt += 1;
       continue;
     }
-    const importId = sourceId(fact, trimmed);
-    if (await backend.hasImport(importId)) {
+    rows.push({ fact, content, importId: sourceId(fact, trimmed) });
+  }
+  const known = rows.length > 0 ? await backend.hasImports([...new Set(rows.map((row) => row.importId))]) : /* @__PURE__ */ new Set();
+  const importedHere = /* @__PURE__ */ new Set();
+  let unresolved = 0;
+  for (const row of rows) {
+    if (known.has(row.importId) || importedHere.has(row.importId)) {
       result.skipped += 1;
       continue;
     }
-    const metadata2 = fact.metadata && typeof fact.metadata === "object" ? fact.metadata : {};
-    const createdAt = timestamp(fact.createdAt);
+    const metadata2 = row.fact.metadata && typeof row.fact.metadata === "object" ? row.fact.metadata : {};
+    const createdAt = timestamp(row.fact.createdAt);
     try {
       const node = await service.remember({
         kind: kind(metadata2),
-        content,
+        content: row.content,
         importance: typeof metadata2.importance === "number" ? metadata2.importance : 0.55,
         confidence: typeof metadata2.confidence === "number" ? metadata2.confidence : 0.65,
         source: {
@@ -58507,24 +59370,30 @@ async function importLegacyMemoryLog(backend, service) {
         ...createdAt ? { createdAt, recordedAt: createdAt } : {},
         metadata: {
           ...metadata2,
-          legacyId: fact.id,
-          legacyCreatedAt: fact.createdAt,
-          ...fact.graph ? { legacyGraph: fact.graph } : {}
+          legacyId: row.fact.id,
+          legacyCreatedAt: row.fact.createdAt,
+          ...row.fact.graph ? { legacyGraph: row.fact.graph } : {}
         },
         writeClass: "auto"
       });
-      await backend.recordImport(importId, node.id);
+      await backend.recordImport(row.importId, node.id);
+      importedHere.add(row.importId);
       result.imported += 1;
-    } catch {
+    } catch (error51) {
       result.skipped += 1;
+      if (!isPermanentSkip(error51)) unresolved += 1;
     }
   }
+  const everyRowResolved = result.imported + result.skipped + result.corrupt === result.found;
+  if (everyRowResolved && unresolved === 0) await markImportComplete(markerPath, result.found);
   return result;
 }
+var LEGACY_IMPORT_MARKER;
 var init_legacyImport = __esm({
   "src/cli/memory/legacyImport.ts"() {
     "use strict";
     init_memory();
+    LEGACY_IMPORT_MARKER = "legacy-import-done.json";
   }
 });
 
@@ -58944,8 +59813,8 @@ WHERE NOT EXISTS (SELECT 1 FROM memory_fts f WHERE f.node_id = n.id);
 });
 
 // src/cli/memory/sqliteBackend.ts
-import { createHash as createHash19, randomUUID as randomUUID6 } from "node:crypto";
-import { promises as fs28 } from "node:fs";
+import { createHash as createHash20, randomUUID as randomUUID6 } from "node:crypto";
+import { promises as fs29 } from "node:fs";
 import * as path70 from "node:path";
 function boundedLimit(value, fallback = 50) {
   return Math.max(1, Math.min(Math.floor(value ?? fallback), 1e5));
@@ -58959,9 +59828,9 @@ function withOptional(target, key, value) {
   return { ...target, [key]: value };
 }
 function contentHash(content) {
-  return createHash19("sha256").update(content).digest("hex");
+  return createHash20("sha256").update(content).digest("hex");
 }
-var NODE_COLUMNS, INSERT_NODE_SQL, SOURCE_COLUMNS, SQLiteMemoryBackend;
+var NODE_COLUMNS, INSERT_NODE_SQL, IMPORT_ID_CHUNK, SOURCE_COLUMNS, SQLiteMemoryBackend;
 var init_sqliteBackend = __esm({
   "src/cli/memory/sqliteBackend.ts"() {
     "use strict";
@@ -58975,6 +59844,7 @@ var init_sqliteBackend = __esm({
   valid_until, recorded_at, retracted_at, embedding_ref, metadata_json`;
     INSERT_NODE_SQL = `INSERT INTO memory_nodes (${NODE_COLUMNS})
 VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
+    IMPORT_ID_CHUNK = 500;
     SOURCE_COLUMNS = {
       agent: "agent",
       sessionId: "sessionId",
@@ -59006,7 +59876,7 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
       async init(projectRoot) {
         let resolved;
         try {
-          resolved = await fs28.realpath(projectRoot);
+          resolved = await fs29.realpath(projectRoot);
         } catch {
           resolved = path70.resolve(projectRoot);
         }
@@ -59021,21 +59891,21 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
         for (const candidate of [zelariDirectory, directory]) {
           let stat8;
           try {
-            stat8 = await fs28.lstat(candidate);
+            stat8 = await fs29.lstat(candidate);
           } catch (error51) {
             if (error51.code !== "ENOENT") throw error51;
             try {
-              await fs28.mkdir(candidate);
+              await fs29.mkdir(candidate);
             } catch (mkdirError) {
               if (mkdirError.code !== "EEXIST") throw mkdirError;
             }
-            stat8 = await fs28.lstat(candidate);
+            stat8 = await fs29.lstat(candidate);
           }
           if (stat8.isSymbolicLink() || !stat8.isDirectory()) {
             throw new Error(`Memory directory is not a real directory: ${candidate}`);
           }
         }
-        const canonicalDirectory = await fs28.realpath(directory);
+        const canonicalDirectory = await fs29.realpath(directory);
         const relativeDirectory = path70.relative(resolved, canonicalDirectory);
         if (relativeDirectory.startsWith("..") || path70.isAbsolute(relativeDirectory)) {
           throw new Error("SQLite memory directory resolves outside the active project.");
@@ -59538,14 +60408,24 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
           versions: versionRows.map(decodeVersion).filter((version2) => Boolean(version2))
         };
       }
-      async hasImport(sourceId2) {
+      /** Batched `hasImport`: one `IN` query per 500 ids instead of one RPC per row. */
+      async hasImports(ids) {
         this.assertReady();
-        const row = await this.rpc.statement({
-          sql: "SELECT source_id FROM memory_imports WHERE source_id=?",
-          params: [sourceId2],
-          mode: "get"
-        });
-        return Boolean(row);
+        const found = /* @__PURE__ */ new Set();
+        const unique = [...new Set(ids)];
+        for (let index = 0; index < unique.length; index += IMPORT_ID_CHUNK) {
+          const chunk = unique.slice(index, index + IMPORT_ID_CHUNK);
+          const rows = await this.rpc.statement({
+            sql: `SELECT source_id FROM memory_imports WHERE source_id IN (${chunk.map(() => "?").join(",")})`,
+            params: chunk,
+            mode: "all"
+          });
+          for (const row of rows) found.add(String(row.source_id));
+        }
+        return found;
+      }
+      async hasImport(sourceId2) {
+        return (await this.hasImports([sourceId2])).has(sourceId2);
       }
       async recordImport(sourceId2, memoryId) {
         this.assertReady();
@@ -59572,8 +60452,8 @@ __export(serviceFactory_exports, {
   isMemorySemanticEnabled: () => isMemorySemanticEnabled,
   isMemoryV2Enabled: () => isMemoryV2Enabled
 });
-import { createHash as createHash20 } from "node:crypto";
-import { promises as fs29 } from "node:fs";
+import { createHash as createHash21 } from "node:crypto";
+import { promises as fs30 } from "node:fs";
 import * as path71 from "node:path";
 function isMemoryV2Enabled(env = process.env) {
   if (env.ZELARI_MEMORY === "0") return false;
@@ -59593,13 +60473,13 @@ function semanticMinScore(env) {
 async function canonicalProjectId(projectRoot) {
   let canonical;
   try {
-    canonical = await fs29.realpath(projectRoot);
+    canonical = await fs30.realpath(projectRoot);
   } catch {
     canonical = path71.resolve(projectRoot);
   }
   canonical = canonical.replace(/\\/g, "/").replace(/\/$/, "");
   if (process.platform === "win32") canonical = canonical.toLocaleLowerCase("en-US");
-  return `project_${createHash20("sha256").update(canonical).digest("hex").slice(0, 24)}`;
+  return `project_${createHash21("sha256").update(canonical).digest("hex").slice(0, 24)}`;
 }
 async function getMemoryService(projectRoot, env = process.env, options = {}) {
   const projectId2 = await canonicalProjectId(projectRoot);
@@ -60222,32 +61102,32 @@ __export(loadDurableContext_exports, {
   loadDurableContext: () => loadDurableContext
 });
 function clearDurableContextCache() {
-  cache2 = null;
+  cache3 = null;
 }
 async function loadDurableContext(projectRoot, opts) {
   const env = opts?.env ?? process.env;
   if (!isStateEnabled(env)) return "";
   const cacheMs = opts?.cacheMs ?? DEFAULT_CACHE_MS;
   const now = Date.now();
-  if (cache2 && cache2.projectRoot === projectRoot && now - cache2.at < cacheMs) {
-    return cache2.text;
+  if (cache3 && cache3.projectRoot === projectRoot && now - cache3.at < cacheMs) {
+    return cache3.text;
   }
   try {
     const store6 = await getStateStore(projectRoot, env);
     const text = await store6.materializeContext(void 0, opts?.maxChars);
-    cache2 = { text: text || "", at: now, projectRoot };
-    return cache2.text;
+    cache3 = { text: text || "", at: now, projectRoot };
+    return cache3.text;
   } catch {
     return "";
   }
 }
-var DEFAULT_CACHE_MS, cache2;
+var DEFAULT_CACHE_MS, cache3;
 var init_loadDurableContext = __esm({
   "src/cli/state/loadDurableContext.ts"() {
     "use strict";
     init_fileStateStore();
     DEFAULT_CACHE_MS = 2e3;
-    cache2 = null;
+    cache3 = null;
   }
 });
 
@@ -62011,7 +62891,7 @@ __export(agentsMd_exports, {
   updateAgentsMd: () => updateAgentsMd
 });
 import { existsSync as existsSync44, readFileSync as readFileSync32, writeFileSync as writeFileSync20 } from "node:fs";
-import { createHash as createHash21 } from "node:crypto";
+import { createHash as createHash22 } from "node:crypto";
 import { join as join34 } from "node:path";
 import { readFile as readFile10 } from "node:fs/promises";
 async function readPackageJson3(projectRoot) {
@@ -62226,7 +63106,7 @@ async function updateAgentsMd(ctx, projectRoot) {
   return { changed: true, sections: changedSections };
 }
 function hash2(s) {
-  return createHash21("sha256").update(s).digest("hex").slice(0, 16);
+  return createHash22("sha256").update(s).digest("hex").slice(0, 16);
 }
 var AUTO_SECTIONS, MARKER_OPEN, MARKER_CLOSE, GENERATORS;
 var init_agentsMd = __esm({
@@ -62954,7 +63834,7 @@ __export(councilFeedback_exports, {
   FeedbackStore: () => FeedbackStore
 });
 import {
-  promises as fs30,
+  promises as fs31,
   existsSync as existsSync49,
   readFileSync as readFileSync37,
   writeFileSync as writeFileSync22,
@@ -63087,7 +63967,7 @@ var init_councilFeedback = __esm({
       /** Async variant of load for callers that prefer async IO. */
       async loadAsync() {
         try {
-          const raw = await fs30.readFile(this.file, "utf-8");
+          const raw = await fs31.readFile(this.file, "utf-8");
           const parsed = JSON.parse(raw);
           if (parsed && Array.isArray(parsed.entries)) {
             this.entries = parsed.entries.filter(
@@ -63407,7 +64287,7 @@ __export(fileBackend_exports, {
   isMemoryEnabled: () => isMemoryEnabled
 });
 import { randomUUID as randomUUID7 } from "node:crypto";
-import { promises as fs31 } from "node:fs";
+import { promises as fs32 } from "node:fs";
 import * as path75 from "node:path";
 function tokenize2(text) {
   return text.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((t) => t.length >= 3);
@@ -63463,7 +64343,7 @@ var init_fileBackend = __esm({
       async init(projectRoot) {
         this.memoryDir = path75.join(projectRoot, ".zelari", "memory");
         this.logPath = path75.join(this.memoryDir, "log.jsonl");
-        await fs31.mkdir(this.memoryDir, { recursive: true });
+        await fs32.mkdir(this.memoryDir, { recursive: true });
       }
       async add(content, metadata2 = {}, graph) {
         const fact = {
@@ -63473,7 +64353,7 @@ var init_fileBackend = __esm({
           ...graph ? { graph } : {},
           createdAt: (/* @__PURE__ */ new Date()).toISOString()
         };
-        await fs31.appendFile(this.logPath, JSON.stringify(fact) + "\n", "utf8");
+        await fs32.appendFile(this.logPath, JSON.stringify(fact) + "\n", "utf8");
         return fact.id;
       }
       async search(query, options = {}) {
@@ -63501,7 +64381,7 @@ var init_fileBackend = __esm({
       async readAll() {
         let raw;
         try {
-          raw = await fs31.readFile(this.logPath, "utf8");
+          raw = await fs32.readFile(this.logPath, "utf8");
         } catch {
           return [];
         }
@@ -63534,7 +64414,7 @@ var init_fileBackend = __esm({
 });
 
 // src/cli/traceStore.ts
-import { promises as fs32 } from "node:fs";
+import { promises as fs33 } from "node:fs";
 import * as path76 from "node:path";
 function traceDir(projectRoot) {
   return path76.join(projectRoot, ".zelari", "trace");
@@ -63544,13 +64424,13 @@ function tracePath(projectRoot, missionId) {
 }
 async function saveTrace(projectRoot, missionId, entries) {
   const dir = traceDir(projectRoot);
-  await fs32.mkdir(dir, { recursive: true });
+  await fs33.mkdir(dir, { recursive: true });
   const payload = {
     missionId,
     ts: Date.now(),
     entries
   };
-  await fs32.writeFile(
+  await fs33.writeFile(
     tracePath(projectRoot, missionId),
     JSON.stringify(payload, null, 2) + "\n",
     "utf8"
@@ -63581,7 +64461,7 @@ __export(zelariMission_exports, {
   runZelariMission: () => runZelariMission
 });
 import { randomUUID as randomUUID8 } from "node:crypto";
-import { promises as fs33 } from "node:fs";
+import { promises as fs34 } from "node:fs";
 import * as path77 from "node:path";
 function resolveMaxIterations(env = process.env) {
   const raw = env.ZELARI_MISSION_MAX_ITER;
@@ -63626,8 +64506,8 @@ function isMissionAutoStart(env = process.env) {
 }
 async function writeMissionState(projectRoot, state3) {
   const dir = path77.join(projectRoot, ".zelari");
-  await fs33.mkdir(dir, { recursive: true });
-  await fs33.writeFile(
+  await fs34.mkdir(dir, { recursive: true });
+  await fs34.writeFile(
     path77.join(dir, "mission-state.json"),
     JSON.stringify(state3, null, 2) + "\n",
     "utf8"
@@ -63641,7 +64521,7 @@ async function writeMissionState(projectRoot, state3) {
 }
 async function loadMissionState(projectRoot) {
   try {
-    const raw = await fs33.readFile(
+    const raw = await fs34.readFile(
       path77.join(projectRoot, ".zelari", "mission-state.json"),
       "utf8"
     );
@@ -66919,11 +67799,11 @@ var init_policy = __esm({
 });
 
 // src/cli/orchestration/facts.ts
-import { promises as fs43 } from "node:fs";
+import { promises as fs44 } from "node:fs";
 import path88 from "node:path";
 async function collectRepoFileCount(root = process.cwd()) {
   try {
-    await fs43.readdir(root);
+    await fs44.readdir(root);
   } catch {
     return void 0;
   }
@@ -66934,7 +67814,7 @@ async function collectRepoFileCount(root = process.cwd()) {
       const dir = queue.pop();
       let entries;
       try {
-        entries = await fs43.readdir(dir, { withFileTypes: true });
+        entries = await fs44.readdir(dir, { withFileTypes: true });
       } catch {
         continue;
       }
@@ -67212,8 +68092,8 @@ function contractFor(t) {
     blockers
   };
 }
-async function readHarnessState(sessionDir) {
-  const report = await readSessionLog(path89.join(sessionDir, "events.jsonl"));
+async function readHarnessState(sessionDir, cache4) {
+  const report = await readSessionLogCached(path89.join(sessionDir, "events.jsonl"), cache4);
   return deriveHarnessState(report.events);
 }
 var init_harnessState = __esm({
@@ -67514,7 +68394,7 @@ var init_controlBridge = __esm({
 function attachHeadlessLiveCancel(opts) {
   const abort = new AbortController();
   const controlQueue = new RuntimeControlQueue();
-  const cancel = () => {
+  const cancel = (_reason) => {
     if (!abort.signal.aborted) abort.abort();
     return true;
   };
@@ -67837,7 +68717,7 @@ var init_sandboxedFs = __esm({
 // src/cli/extensions/loader.ts
 import { join as join44 } from "node:path";
 import { readdirSync as readdirSync11, readFileSync as readFileSync43 } from "node:fs";
-import { createHash as createHash22 } from "node:crypto";
+import { createHash as createHash23 } from "node:crypto";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 function globalExtensionsDir() {
   return join44(zelariHome(), "extensions");
@@ -67846,7 +68726,7 @@ function projectExtensionsDir(projectRoot) {
   return join44(projectRoot, ".zelari", "extensions");
 }
 function sha256File(file2) {
-  return createHash22("sha256").update(readFileSync43(file2)).digest("hex");
+  return createHash23("sha256").update(readFileSync43(file2)).digest("hex");
 }
 function candidateFiles(dir) {
   let names;
@@ -67877,7 +68757,7 @@ async function loadExtensionsFromDirs(dirs, options = {}) {
     skipped
   };
   const fsRoot = options.fsRoot ?? process.cwd();
-  let fs48 = null;
+  let fs49 = null;
   const pending = [];
   for (const dir of dirs) {
     const files = candidateFiles(dir.path);
@@ -67932,9 +68812,9 @@ async function loadExtensionsFromDirs(dirs, options = {}) {
       skipped.push(`${file2}: missing ZelariExtension export`);
       continue;
     }
-    if (!fs48) fs48 = bindSandboxedFs(fsRoot);
+    if (!fs49) fs49 = bindSandboxedFs(fsRoot);
     try {
-      await runtime.registry.registerExtension(ext, { fs: fs48 });
+      await runtime.registry.registerExtension(ext, { fs: fs49 });
       runtime.loaded.push({ id: ext.id, file: file2, scope });
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -67992,7 +68872,7 @@ var init_loader = __esm({
 });
 
 // src/cli/headless/runOneTurn.ts
-import { promises as fs44 } from "node:fs";
+import { promises as fs45 } from "node:fs";
 import path92 from "node:path";
 function planModeFromOpts(opts) {
   return (opts.phase ?? "build") === "plan";
@@ -68072,10 +68952,10 @@ async function runOneTurn(opts, provider, model, providerStream, extras) {
   })() : void 0;
   const unregisterLiveTurnControl = process.env.ZELARI_SERVE_HARNESS === "1" ? registerLiveTurnControl({
     queue: controlQueue,
-    cancel: () => {
+    cancel: (reason) => {
       const cancelHook = harnessHolder.cancel;
       if (!cancelHook) return false;
-      cancelHook();
+      cancelHook(reason);
       return true;
     }
   }) : void 0;
@@ -68361,7 +69241,7 @@ async function runOneTurn(opts, provider, model, providerStream, extras) {
         memoryContextChars: 2e3
       } : {}
     });
-    harnessHolder.cancel = () => harness.cancel();
+    harnessHolder.cancel = (reason) => harness.cancel(reason);
     const readBuildProgress = () => {
       const getter = harness.getBuildProgress;
       return typeof getter === "function" ? getter.call(harness) : { mutationsAttempted: 0, mutationsSucceeded: 0 };
@@ -68548,11 +69428,11 @@ async function runOneTurn(opts, provider, model, providerStream, extras) {
     process.stdout.write(pass.textBuffer.join(""));
   }
   process.stdout.write("");
-  if (pass.finalReason !== "error" && opts.output === "json" && wantWrites && pass.successfulWrites === 0) {
+  if (pass.finalReason !== "error" && pass.finalReason !== "cancelled" && opts.output === "json" && wantWrites && pass.successfulWrites === 0) {
     emitEvent({ type: "log", message: "[headless] BUILD failed: zero successful mutations after liveness recovery" });
   }
   try {
-    const closeStatus = pass.finalReason === "error" ? "error" : strictExit !== 0 ? "stopped" : "completed";
+    const closeStatus = pass.finalReason === "error" ? "error" : pass.finalReason === "cancelled" ? "cancelled" : strictExit !== 0 ? "stopped" : "completed";
     await spine.close(closeStatus);
   } catch {
   }
@@ -68563,8 +69443,8 @@ async function runOneTurn(opts, provider, model, providerStream, extras) {
       if (json3) {
         if (opts.exportSessionPath === "-") process.stdout.write(json3 + "\n");
         else {
-          await fs44.mkdir(path92.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
-          await fs44.writeFile(opts.exportSessionPath, json3, "utf8");
+          await fs45.mkdir(path92.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+          await fs45.writeFile(opts.exportSessionPath, json3, "utf8");
         }
       }
     } catch {
@@ -69611,7 +70491,7 @@ __export(triggerLock_exports, {
   lockPath: () => lockPath,
   releaseLock: () => releaseLock
 });
-import { promises as fs45 } from "node:fs";
+import { promises as fs46 } from "node:fs";
 import * as path93 from "node:path";
 function lockPath(projectRoot) {
   return path93.join(projectRoot, ".zelari", "trigger.lock");
@@ -69628,9 +70508,9 @@ function isPidAlive(pid) {
 async function acquireLock(projectRoot, now = () => /* @__PURE__ */ new Date()) {
   const lp = lockPath(projectRoot);
   const dir = path93.dirname(lp);
-  await fs45.mkdir(dir, { recursive: true });
+  await fs46.mkdir(dir, { recursive: true });
   try {
-    const raw = await fs45.readFile(lp, "utf8");
+    const raw = await fs46.readFile(lp, "utf8");
     const existing = JSON.parse(raw);
     if (existing.pid && isPidAlive(existing.pid)) {
       return { acquired: false, heldBy: existing.pid, lockPath: lp };
@@ -69641,13 +70521,13 @@ async function acquireLock(projectRoot, now = () => /* @__PURE__ */ new Date())
     pid: process.pid,
     acquiredAt: now().toISOString()
   };
-  await fs45.writeFile(lp, JSON.stringify(payload, null, 2) + "\n", "utf8");
+  await fs46.writeFile(lp, JSON.stringify(payload, null, 2) + "\n", "utf8");
   return { acquired: true, lockPath: lp };
 }
 async function releaseLock(projectRoot) {
   const lp = lockPath(projectRoot);
   try {
-    await fs45.unlink(lp);
+    await fs46.unlink(lp);
   } catch {
   }
 }
@@ -69658,7 +70538,7 @@ var init_triggerLock = __esm({
 });
 
 // src/cli/runHeadless.ts
-import { promises as fs46 } from "node:fs";
+import { promises as fs47 } from "node:fs";
 import path94 from "node:path";
 import { randomUUID as randomUUID10 } from "node:crypto";
 async function runHeadless(opts) {
@@ -69730,12 +70610,42 @@ ${err.stack}` : "";
       return 1;
     }
     const { buildProviderStream: buildProviderStream2 } = await Promise.resolve().then(() => (init_resolveStream(), resolveStream_exports));
-    providerStream = buildProviderStream2({
+    const primaryStream = buildProviderStream2({
       providerId: provider,
       apiKey: key.apiKey,
       baseUrl: key.baseUrl,
       model
     });
+    const { isHeadlessFailoverEnabled: isHeadlessFailoverEnabled2, wrapWithHeadlessFailover: wrapWithHeadlessFailover2 } = await Promise.resolve().then(() => (init_crossProviderFailover(), crossProviderFailover_exports));
+    if (isHeadlessFailoverEnabled2()) {
+      const { PROVIDERS: PROVIDERS2 } = await Promise.resolve().then(() => (init_keyStore(), keyStore_exports));
+      const { providerConfigFor: providerConfigFor2 } = await Promise.resolve().then(() => (init_openai_compatible(), openai_compatible_exports));
+      providerStream = await wrapWithHeadlessFailover2({
+        primary: primaryStream,
+        primaryProviderId: provider,
+        validProviderIds: PROVIDERS2.map((p3) => p3.id),
+        lookupFallbackConfig: async (id3) => providerConfigFor2(id3),
+        buildStream: (config2) => buildProviderStream2(config2),
+        onWarning: (warning) => {
+          try {
+            process.stderr.write(`[zelari-code --headless] ${warning}
+`);
+          } catch {
+          }
+        },
+        onFailover: (info) => {
+          try {
+            process.stderr.write(
+              `[zelari-code --headless] [failover] ${info.phase}${info.label ? ` \u2192 ${info.label}` : ""}: ${info.message}
+`
+            );
+          } catch {
+          }
+        }
+      });
+    } else {
+      providerStream = primaryStream;
+    }
   }
   return dispatchHeadlessTurn(opts, provider, model, providerStream, {
     // H10-fix3: the gate already ran above on the SAME input (no chdir in
@@ -69907,7 +70817,7 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
       log(`loading pre-flight plan: ${planPath}`);
       let raw;
       try {
-        raw = await fs46.readFile(planPath, "utf8");
+        raw = await fs47.readFile(planPath, "utf8");
       } catch (e) {
         log(`plan file not found: ${planPath} (${e.message})`);
         exitCode = 1;
@@ -69948,8 +70858,8 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
       const planId = randomUUID10();
       const planDir = path94.join(cwd, ".zelari", "radio");
       const planPath = path94.join(planDir, `plan-${planId}.json`);
-      await fs46.mkdir(planDir, { recursive: true });
-      await fs46.writeFile(
+      await fs47.mkdir(planDir, { recursive: true });
+      await fs47.writeFile(
         planPath,
         JSON.stringify(
           { id: graph.id, nodes: [...graph.nodes.values()] },
@@ -70338,8 +71248,8 @@ async function runHeadlessCouncilBody(opts, provider, model, providerStream, ext
       if (json3) {
         if (opts.exportSessionPath === "-") process.stdout.write(json3 + "\n");
         else {
-          await fs46.mkdir(path94.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
-          await fs46.writeFile(opts.exportSessionPath, json3, "utf8");
+          await fs47.mkdir(path94.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+          await fs47.writeFile(opts.exportSessionPath, json3, "utf8");
         }
       }
     } catch {
@@ -70810,8 +71720,8 @@ ${ragContext}` : slicePrompt;
         if (json3) {
           if (opts.exportSessionPath === "-") process.stdout.write(json3 + "\n");
           else {
-            await fs46.mkdir(path94.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
-            await fs46.writeFile(opts.exportSessionPath, json3, "utf8");
+            await fs47.mkdir(path94.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+            await fs47.writeFile(opts.exportSessionPath, json3, "utf8");
           }
         }
       } catch {
@@ -72282,7 +73192,7 @@ import {
   writeFileSync as writeFileSync26
 } from "node:fs";
 import { join as join47 } from "node:path";
-import { createHash as createHash23, randomBytes as randomBytes7, timingSafeEqual } from "node:crypto";
+import { createHash as createHash24, randomBytes as randomBytes7, timingSafeEqual } from "node:crypto";
 function getZelariHome() {
   return zelariHome();
 }
@@ -72350,16 +73260,16 @@ function loadOrCreateToken(explicit) {
   const token = randomBytes7(24).toString("base64url");
   writeFileSync26(path101, token + "\n", "utf8");
   try {
-    const fs48 = __require("node:fs");
-    fs48.chmodSync?.(path101, 384);
+    const fs49 = __require("node:fs");
+    fs49.chmodSync?.(path101, 384);
   } catch {
   }
   return { token, created: true };
 }
 function tokenMatches(expected, provided) {
   if (!provided) return false;
-  const a = createHash23("sha256").update(expected).digest();
-  const b = createHash23("sha256").update(provided).digest();
+  const a = createHash24("sha256").update(expected).digest();
+  const b = createHash24("sha256").update(provided).digest();
   try {
     return timingSafeEqual(a, b);
   } catch {
@@ -72628,7 +73538,7 @@ var init_askUserBridge = __esm({
 });
 
 // src/cli/serve/spineLockSweep.ts
-import { promises as fs47 } from "node:fs";
+import { promises as fs48 } from "node:fs";
 import path96 from "node:path";
 async function sweepOrphanSpineLocks(sessionsDir2, options = {}) {
   const dir = sessionsDir2 ?? resolveSessionsDir();
@@ -72642,14 +73552,14 @@ async function sweepOrphanSpineLocks(sessionsDir2, options = {}) {
   const result = { swept: 0, kept: 0, errors: 0 };
   let entries;
   try {
-    entries = await fs47.readdir(dir);
+    entries = await fs48.readdir(dir);
   } catch {
     return result;
   }
   for (const sessionId2 of entries) {
     const lockPath2 = path96.join(dir, sessionId2, "writer.lock");
     try {
-      const raw = await fs47.readFile(lockPath2, "utf-8");
+      const raw = await fs48.readFile(lockPath2, "utf-8");
       let lockInfo = {};
       try {
         lockInfo = JSON.parse(raw);
@@ -72666,7 +73576,7 @@ async function sweepOrphanSpineLocks(sessionsDir2, options = {}) {
         result.kept += 1;
         continue;
       }
-      await fs47.rm(lockPath2, { force: true });
+      await fs48.rm(lockPath2, { force: true });
       result.swept += 1;
       onSwept(sessionId2, verdict.reason);
     } catch (err) {
@@ -72886,7 +73796,8 @@ function startHarnessServer(options = {}) {
           };
         }
         if (isCancel) {
-          const delivered = live.cancel();
+          const reason = typeof params.reason === "string" && params.reason.trim().length > 0 ? params.reason.trim() : void 0;
+          const delivered = live.cancel(reason);
           if (delivered) {
             write(JSON.stringify(controlAppliedEvent(controlId, "cancel", "cancel")));
           }
@@ -77973,107 +78884,8 @@ init_metrics3();
 init_modelPricing();
 init_openai_compatible();
 init_resolveStream();
-import { useState as useState6, useRef as useRef4, useCallback as useCallback2 } from "react";
-
-// src/cli/providerFailover.ts
-var DEFAULT_IS_TRANSIENT = (delta) => delta.kind === "error";
-function providerFailover(options) {
-  const isTransient = options.isTransientFailure ?? DEFAULT_IS_TRANSIENT;
-  const primaryFailedMsg = options.fallbackLabel ? `[failover] primary failed, switching to ${options.fallbackLabel}` : "[failover] primary failed, switching to fallback";
-  const primaryThrewMsg = options.fallbackLabel ? `[failover] primary threw, switching to ${options.fallbackLabel}: ` : "[failover] primary threw: ";
-  const fallbackFailedMsg = options.fallbackLabel ? `[failover] fallback (${options.fallbackLabel}) also failed: ` : "[failover] fallback also failed: ";
-  return async function* (params) {
-    const triedFallback = { value: false };
-    try {
-      for await (const delta of options.primary(params)) {
-        if (isTransient(delta)) {
-          yield delta;
-          triedFallback.value = true;
-          yield {
-            kind: "error",
-            message: primaryFailedMsg
-          };
-          break;
-        }
-        yield delta;
-      }
-    } catch (err) {
-      triedFallback.value = true;
-      yield {
-        kind: "error",
-        message: `${primaryThrewMsg}${err instanceof Error ? err.message : String(err)}`
-      };
-    }
-    if (triedFallback.value) {
-      try {
-        for await (const delta of options.fallback(params)) {
-          yield delta;
-        }
-      } catch (err) {
-        yield {
-          kind: "error",
-          message: `${fallbackFailedMsg}${err instanceof Error ? err.message : String(err)}`
-        };
-        return;
-      }
-    }
-  };
-}
-
-// src/cli/crossProviderFailover.ts
-async function resolveFailoverStream(options) {
-  if (!options.failoverEnabled) {
-    return {
-      fallback: options.primary,
-      fallbackLabel: void 0,
-      warning: "",
-      reason: "disabled"
-    };
-  }
-  const requested = options.envValue?.trim();
-  if (!requested || requested.length === 0) {
-    return {
-      fallback: options.primary,
-      fallbackLabel: void 0,
-      warning: "",
-      reason: "unset"
-    };
-  }
-  const valid = new Set(options.validProviderIds);
-  if (!valid.has(requested)) {
-    return {
-      fallback: options.primary,
-      fallbackLabel: void 0,
-      warning: `[failover] ANATHEMA_FAILOVER_PROVIDER="${requested}" is not a known provider. Falling back to v3-G same-provider behavior. Available: ${options.validProviderIds.join(", ")}.`,
-      reason: "unknown"
-    };
-  }
-  if (requested === options.primaryProviderId) {
-    return {
-      fallback: options.primary,
-      fallbackLabel: void 0,
-      warning: "",
-      reason: "same-as-primary"
-    };
-  }
-  const fallbackConfig = await options.lookupFallbackConfig(requested);
-  if (!fallbackConfig) {
-    return {
-      fallback: options.primary,
-      fallbackLabel: void 0,
-      warning: `[failover] No API key configured for provider "${requested}". Falling back to v3-G same-provider behavior.`,
-      reason: "missing-key"
-    };
-  }
-  return {
-    fallback: options.buildStream(fallbackConfig),
-    fallbackLabel: requested,
-    warning: "",
-    reason: "resolved"
-  };
-}
-
-// src/cli/hooks/useChatTurn.ts
+init_providerFailover();
+init_crossProviderFailover();
 init_shellResolver();
 init_keyStore();
 init_providerConfig();
@@ -78090,6 +78902,7 @@ init_completionProof();
 init_verifyStatus();
 init_nativeVerification();
 init_spineTelemetry();
+import { useState as useState6, useRef as useRef4, useCallback as useCallback2 } from "react";
 
 // src/cli/hooks/permissionPicker.ts
 init_toolPermissions();
@@ -81335,11 +82148,11 @@ function handleCacheStats(ctx) {
 // src/cli/slashHandlers/memory.ts
 init_messageHelpers();
 init_serviceFactory();
-import { promises as fs35 } from "node:fs";
+import { promises as fs36 } from "node:fs";
 import * as path80 from "node:path";
 
 // src/cli/memory/promotion.ts
-import { promises as fs34 } from "node:fs";
+import { promises as fs35 } from "node:fs";
 import * as path79 from "node:path";
 var START = "<!-- zelari:memory-promotions:start -->";
 var END = "<!-- zelari:memory-promotions:end -->";
@@ -81356,17 +82169,17 @@ async function promoteMemoryToAgentsMd(projectRoot, node) {
   if (!DURABLE_KINDS.has(node.kind)) {
     return { added: false, path: path79.join(projectRoot, "AGENTS.md"), reason: `${node.kind} is not a durable instruction kind` };
   }
-  const root = await fs34.realpath(projectRoot).catch(() => path79.resolve(projectRoot));
+  const root = await fs35.realpath(projectRoot).catch(() => path79.resolve(projectRoot));
   const target = path79.join(root, "AGENTS.md");
   try {
-    const stat8 = await fs34.lstat(target);
+    const stat8 = await fs35.lstat(target);
     if (stat8.isSymbolicLink() || !stat8.isFile()) throw new Error("AGENTS.md must be a regular project file.");
   } catch (error51) {
     if (error51.code !== "ENOENT") throw error51;
   }
   let current = "";
   try {
-    current = await fs34.readFile(target, "utf8");
+    current = await fs35.readFile(target, "utf8");
   } catch (error51) {
     if (error51.code !== "ENOENT") throw error51;
   }
@@ -81389,11 +82202,11 @@ ${END}
 `;
   }
   const temporary = `${target}.tmp-${process.pid}-${Date.now()}`;
-  await fs34.writeFile(temporary, updated, { encoding: "utf8", flag: "wx" });
+  await fs35.writeFile(temporary, updated, { encoding: "utf8", flag: "wx" });
   try {
-    await fs34.rename(temporary, target);
+    await fs35.rename(temporary, target);
   } catch (error51) {
-    await fs34.unlink(temporary).catch(() => void 0);
+    await fs35.unlink(temporary).catch(() => void 0);
     throw error51;
   }
   return { added: true, path: target };
@@ -81427,7 +82240,7 @@ function isInside(root, target) {
 }
 async function safeExportPath(cwd, requested) {
   const lexicalRoot = path80.resolve(cwd);
-  const root = await fs35.realpath(lexicalRoot).catch(() => lexicalRoot);
+  const root = await fs36.realpath(lexicalRoot).catch(() => lexicalRoot);
   const fallback = path80.join(root, ".zelari", "memory", `export-${Date.now()}.json`);
   const target = requested?.trim() ? path80.resolve(root, requested.trim()) : fallback;
   if (!isInside(root, target)) {
@@ -81439,7 +82252,7 @@ async function safeExportPath(cwd, requested) {
   for (const segment of relativeParent.split(path80.sep).filter(Boolean)) {
     cursor = path80.join(cursor, segment);
     try {
-      const stat8 = await fs35.lstat(cursor);
+      const stat8 = await fs36.lstat(cursor);
       if (stat8.isSymbolicLink()) {
         throw new Error("Export path must not traverse a symbolic link.");
       }
@@ -81449,7 +82262,7 @@ async function safeExportPath(cwd, requested) {
     }
   }
   try {
-    if ((await fs35.lstat(target)).isSymbolicLink()) {
+    if ((await fs36.lstat(target)).isSymbolicLink()) {
       throw new Error("Export target must not be a symbolic link.");
     }
   } catch (error51) {
@@ -81609,13 +82422,13 @@ ${message}` : message
       }
       case "export": {
         const target = await safeExportPath(ctx.cwd, args.join(" ").trim() || void 0);
-        await fs35.mkdir(path80.dirname(target), { recursive: true });
-        const root = await fs35.realpath(ctx.cwd).catch(() => path80.resolve(ctx.cwd));
-        const realParent = await fs35.realpath(path80.dirname(target));
+        await fs36.mkdir(path80.dirname(target), { recursive: true });
+        const root = await fs36.realpath(ctx.cwd).catch(() => path80.resolve(ctx.cwd));
+        const realParent = await fs36.realpath(path80.dirname(target));
         if (!isInside(root, realParent)) {
           throw new Error("Export path resolves outside the active project.");
         }
-        await fs35.writeFile(target, JSON.stringify(await memory.export(), null, 2) + "\n", "utf8");
+        await fs36.writeFile(target, JSON.stringify(await memory.export(), null, 2) + "\n", "utf8");
         emit(`[memory] export written to ${target}`);
         return;
       }
@@ -81820,12 +82633,12 @@ ${digest}
 init_auditLogger();
 init_toolRegistry();
 init_messageHelpers();
-import { promises as fs37 } from "node:fs";
+import { promises as fs38 } from "node:fs";
 
 // src/cli/tools/krakenCsvFanout.ts
 init_zod();
 init_taskTool();
-import { promises as fs36 } from "node:fs";
+import { promises as fs37 } from "node:fs";
 import path81 from "node:path";
 import { randomBytes as randomBytes6 } from "node:crypto";
 var CsvFanoutArgsSchema = external_exports.object({
@@ -81847,7 +82660,7 @@ var CsvFanoutArgsSchema = external_exports.object({
   max_runtime_seconds: external_exports.number().int().positive().optional()
 });
 async function readCsv(filePath) {
-  const text = await fs36.readFile(filePath, "utf8");
+  const text = await fs37.readFile(filePath, "utf8");
   return parseCsv(text);
 }
 function parseCsv(text) {
@@ -81977,7 +82790,7 @@ async function runCsvFanout(args, deps, opts) {
         errored += 1;
         errors.push(`${row[args.id_column] ?? i}: ${res.error}`);
       }
-      await fs36.mkdir(path81.dirname(absOut), { recursive: true });
+      await fs37.mkdir(path81.dirname(absOut), { recursive: true });
       await queueWrite(serializeCsv(outHeaders, outputRecords));
     }
   }
@@ -81999,8 +82812,8 @@ async function runCsvFanout(args, deps, opts) {
 }
 async function atomicWrite(file2, contents) {
   const tmp = `${file2}.${process.pid}.${Date.now()}.${randomBytes6(6).toString("hex")}.tmp`;
-  await fs36.writeFile(tmp, contents, "utf8");
-  await fs36.rename(tmp, file2);
+  await fs37.writeFile(tmp, contents, "utf8");
+  await fs37.rename(tmp, file2);
 }
 
 // src/cli/slashHandlers/krakenFanout.ts
@@ -82098,7 +82911,7 @@ async function handleKrakenFanout(ctx, raw) {
   }
   const absCsv = isAbsolute3(parsed.args.csv_path) ? parsed.args.csv_path : joinPath(ctx.cwd, parsed.args.csv_path);
   try {
-    await fs37.access(absCsv);
+    await fs38.access(absCsv);
   } catch {
     appendSystem(ctx.setMessages, `[kraken fanout] source CSV not found: ${absCsv}`);
     return;
@@ -82171,7 +82984,7 @@ function splitArgs(s) {
 
 // src/cli/slashHandlers/krakenWorkbench.ts
 init_messageHelpers();
-import { promises as fs38 } from "node:fs";
+import { promises as fs39 } from "node:fs";
 import path82 from "node:path";
 
 // src/cli/kraken/workbenchView.ts
@@ -82293,11 +83106,11 @@ async function handleKrakenWorkbench(ctx) {
   let latest = null;
   let latestMtime = 0;
   try {
-    const files = await fs38.readdir(dir);
+    const files = await fs39.readdir(dir);
     for (const f of files) {
       if (!f.startsWith("workbench-") || !f.endsWith(".md")) continue;
       const full = path82.join(dir, f);
-      const stat8 = await fs38.stat(full);
+      const stat8 = await fs39.stat(full);
       if (stat8.mtimeMs > latestMtime) {
         latestMtime = stat8.mtimeMs;
         latest = full;
@@ -82309,7 +83122,7 @@ async function handleKrakenWorkbench(ctx) {
     appendSystem(ctx.setMessages, "[kraken workbench] no workbench file found (.zelari/radio/workbench-*.md)");
     return;
   }
-  const content = await fs38.readFile(latest, "utf8");
+  const content = await fs39.readFile(latest, "utf8");
   const parsed = parseWorkbench(content);
   const rendered = formatWorkbenchForTerminal(parsed);
   if (!rendered.trim()) {
@@ -82623,20 +83436,20 @@ ${result.output.split("\n").slice(-8).join("\n")}` : "";
 // src/cli/slashHandlers/promoteMember.ts
 init_messageHelpers();
 init_paths();
-import { promises as fs39 } from "node:fs";
+import { promises as fs40 } from "node:fs";
 import path85 from "node:path";
 async function handlePromoteMember(ctx, memberId) {
   try {
     const { promoteMember: promoteMember2 } = await Promise.resolve().then(() => (init_council(), council_exports));
     const { skill, markdown } = promoteMember2(memberId);
     const skillDir = skillsDir();
-    await fs39.mkdir(skillDir, { recursive: true });
+    await fs40.mkdir(skillDir, { recursive: true });
     const filePath = path85.join(skillDir, `${skill.id}.md`);
-    const previous = await fs39.readFile(filePath, "utf8").catch(() => null);
-    const { createHash: createHash24 } = await import("node:crypto");
-    const sha = (s) => createHash24("sha256").update(s, "utf8").digest("hex");
+    const previous = await fs40.readFile(filePath, "utf8").catch(() => null);
+    const { createHash: createHash25 } = await import("node:crypto");
+    const sha = (s) => createHash25("sha256").update(s, "utf8").digest("hex");
     const lineage = `<!-- lineage: genome=sha256:${sha(markdown)} parent=${previous ? `sha256:${sha(previous)}` : "none"} promotedBy=user promotedAt=${(/* @__PURE__ */ new Date()).toISOString()} -->`;
-    await fs39.writeFile(filePath, `${markdown}
+    await fs40.writeFile(filePath, `${markdown}
 ${lineage}
 `, "utf8");
     appendSystem(
@@ -82656,7 +83469,7 @@ ${lineage}
 
 // src/cli/branchManager.ts
 init_paths();
-import { promises as fs40, existsSync as existsSync55, readFileSync as readFileSync41, writeFileSync as writeFileSync24, mkdirSync as mkdirSync21, statSync as statSync7, rmSync as rmSync3 } from "node:fs";
+import { promises as fs41, existsSync as existsSync55, readFileSync as readFileSync41, writeFileSync as writeFileSync24, mkdirSync as mkdirSync21, statSync as statSync7, rmSync as rmSync3 } from "node:fs";
 import path86 from "node:path";
 var META_FILENAME = "meta.json";
 var SESSIONS_SUBDIR = "sessions";
@@ -82704,7 +83517,7 @@ function writeBranchMeta(name, baseDir, meta3) {
 async function countSessions(name, baseDir) {
   const sessionsPath = sessionsPathFor(name, baseDir);
   try {
-    const entries = await fs40.readdir(sessionsPath);
+    const entries = await fs41.readdir(sessionsPath);
     return entries.filter((e) => e.endsWith(".jsonl")).length;
   } catch (err) {
     if (err.code === "ENOENT") return 0;
@@ -82757,7 +83570,7 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
   const branchSessionsPath = sessionsPathFor(name, baseDir);
   mkdirSync21(branchSessionsPath, { recursive: true });
   const destPath = path86.join(branchSessionsPath, `${fromSessionId}.jsonl`);
-  await fs40.copyFile(sourcePath, destPath);
+  await fs41.copyFile(sourcePath, destPath);
   const meta3 = {
     name,
     createdAt: Date.now(),
@@ -82775,7 +83588,7 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
 async function listBranches(baseDir = getBranchesBaseDir()) {
   let entries;
   try {
-    entries = await fs40.readdir(baseDir);
+    entries = await fs41.readdir(baseDir);
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw err;
@@ -82859,7 +83672,7 @@ async function handleBranchCheckout(ctx, branchName) {
 
 // src/cli/slashHandlers/workspace.ts
 init_messageHelpers();
-import { promises as fs41 } from "node:fs";
+import { promises as fs42 } from "node:fs";
 import path87 from "node:path";
 async function handleWorkspaceShow(ctx, what) {
   try {
@@ -82869,7 +83682,7 @@ async function handleWorkspaceShow(ctx, what) {
       case "plan": {
         const planPath = path87.join(zelari, "plan.md");
         try {
-          content = await fs41.readFile(planPath, "utf-8");
+          content = await fs42.readFile(planPath, "utf-8");
         } catch {
           content = "(no plan.md yet \u2014 run a council session first)";
         }
@@ -82878,7 +83691,7 @@ async function handleWorkspaceShow(ctx, what) {
       case "decisions": {
         const decisionsDir = path87.join(zelari, "decisions");
         try {
-          const files = (await fs41.readdir(decisionsDir)).filter((f) => f.endsWith(".md")).sort();
+          const files = (await fs42.readdir(decisionsDir)).filter((f) => f.endsWith(".md")).sort();
           if (files.length === 0) {
             content = "(no ADRs yet \u2014 invoke /council to generate some)";
           } else {
@@ -82886,7 +83699,7 @@ async function handleWorkspaceShow(ctx, what) {
 `];
             const { parseFrontmatter: parseFrontmatter2 } = await Promise.resolve().then(() => (init_storage(), storage_exports));
             for (const f of files) {
-              const raw = await fs41.readFile(path87.join(decisionsDir, f), "utf-8");
+              const raw = await fs42.readFile(path87.join(decisionsDir, f), "utf-8");
               const { meta: meta3, body } = parseFrontmatter2(raw);
               const title = meta3.title ?? body.split("\n")[0]?.replace(/^#\s*/, "").trim() ?? f;
               lines.push(`- **${f.replace(/\.md$/, "")}** [${meta3.status ?? "unknown"}] ${title}`);
@@ -82901,7 +83714,7 @@ async function handleWorkspaceShow(ctx, what) {
       case "risks": {
         const risksPath = path87.join(zelari, "risks.md");
         try {
-          content = await fs41.readFile(risksPath, "utf-8");
+          content = await fs42.readFile(risksPath, "utf-8");
         } catch {
           content = "(no risks.md yet)";
         }
@@ -82910,7 +83723,7 @@ async function handleWorkspaceShow(ctx, what) {
       case "agents": {
         const agentsPath = path87.join(process.cwd(), "AGENTS.MD");
         try {
-          content = await fs41.readFile(agentsPath, "utf-8");
+          content = await fs42.readFile(agentsPath, "utf-8");
         } catch {
           content = "(no AGENTS.MD yet at project root \u2014 run `/workspace sync` after a council session)";
         }
@@ -82919,7 +83732,7 @@ async function handleWorkspaceShow(ctx, what) {
       case "docs": {
         const docsDir = path87.join(zelari, "docs");
         try {
-          const files = (await fs41.readdir(docsDir)).filter((f) => f.endsWith(".md")).sort();
+          const files = (await fs42.readdir(docsDir)).filter((f) => f.endsWith(".md")).sort();
           content = files.length ? `# Docs (${files.length})
 
 ` + files.map((f) => `- ${f}`).join("\n") : "(no docs drafts yet)";
@@ -82960,7 +83773,7 @@ async function handleWorkspaceReset(ctx, force) {
   }
   try {
     const target = path87.join(process.cwd(), ".zelari");
-    await fs41.rm(target, { recursive: true, force: true });
+    await fs42.rm(target, { recursive: true, force: true });
     appendSystem(ctx.setMessages, "[workspace] .zelari/ removed");
   } catch (err) {
     appendSystem(ctx.setMessages, `[workspace reset error] ${err instanceof Error ? err.message : String(err)}`);
@@ -82971,13 +83784,13 @@ async function handleWorkspaceReset(ctx, force) {
 init_provider2();
 
 // src/cli/skillHistory.ts
-import { promises as fs42, existsSync as existsSync56, statSync as statSync8, renameSync as renameSync6, appendFileSync as appendFileSync5, mkdirSync as mkdirSync22 } from "node:fs";
+import { promises as fs43, existsSync as existsSync56, statSync as statSync8, renameSync as renameSync6, appendFileSync as appendFileSync5, mkdirSync as mkdirSync22 } from "node:fs";
 init_paths();
 var SKILL_HISTORY_ROTATE_BYTES = 10 * 1024 * 1024;
 async function readSkillHistory(file2) {
   let raw = "";
   try {
-    raw = await fs42.readFile(file2, "utf-8");
+    raw = await fs43.readFile(file2, "utf-8");
   } catch {
     return [];
   }