zelari-code 2.2.0 → 2.4.0

package/dist/cli/main.bundled.js

@@ -595,8 +595,8 @@ async function runGrokOAuthFlow(options = {}) {
     );
   } catch {
   }
-  const timeoutMs = options.timeoutMs ?? DEFAULT_OAUTH_TIMEOUT_MS;
-  const effectiveTimeout = Math.min(timeoutMs, deviceAuth.expiresIn * 1e3);
+  const timeoutMs2 = options.timeoutMs ?? DEFAULT_OAUTH_TIMEOUT_MS;
+  const effectiveTimeout = Math.min(timeoutMs2, deviceAuth.expiresIn * 1e3);
   return pollForDeviceToken({
     clientId: clientId2,
     deviceCode: deviceAuth.deviceCode,
@@ -739,7 +739,7 @@ function generateOAuthState() {
 }
 async function waitForLoopbackCallback(options) {
   const host = options.host ?? "127.0.0.1";
-  const timeoutMs = options.timeoutMs ?? 3e5;
+  const timeoutMs2 = options.timeoutMs ?? 3e5;
   const expectedPath = options.path.startsWith("/") ? options.path : `/${options.path}`;
   return new Promise((resolve3, reject) => {
     let settled = false;
@@ -759,12 +759,12 @@ async function waitForLoopbackCallback(options) {
       const ok = Boolean(result.code) && !result.error;
       res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
       res.end(oauthResultHtml(ok, result.errorDescription ?? result.error));
-      finish(result);
+      finish2(result);
     });
     const timer = setTimeout(() => {
-      finish(void 0, new Error(`Timed out waiting for OAuth callback on http://${host}:${options.port}`));
-    }, timeoutMs);
-    const finish = (value, err) => {
+      finish2(void 0, new Error(`Timed out waiting for OAuth callback on http://${host}:${options.port}`));
+    }, timeoutMs2);
+    const finish2 = (value, err) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
@@ -773,7 +773,7 @@ async function waitForLoopbackCallback(options) {
         else resolve3(value ?? {});
       });
     };
-    server.on("error", (err) => finish(void 0, err));
+    server.on("error", (err) => finish2(void 0, err));
     server.listen(options.port, host);
   });
 }
@@ -971,8 +971,8 @@ async function pollChatgptDeviceAuth(options) {
   const clientId2 = options.clientId || process.env.CHATGPT_OAUTH_CLIENT_ID || DEFAULT_CHATGPT_CLIENT_ID;
   const fetchImpl = options.fetchImpl ?? fetch;
   const sleep = options.sleepImpl ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
-  const timeoutMs = options.timeoutMs ?? 3e5;
-  const deadline = Date.now() + timeoutMs;
+  const timeoutMs2 = options.timeoutMs ?? 3e5;
+  const deadline = Date.now() + timeoutMs2;
   let interval = options.interval ?? 5;
   let authorizationCode;
   let codeVerifier;
@@ -18246,14 +18246,15 @@ var init_filesystem = __esm({
     init_toolTypes();
     ReadFileArgsSchema = external_exports.object({
       path: external_exports.string().min(1),
-      startLine: external_exports.number().int().nonnegative().optional(),
-      endLine: external_exports.number().int().positive().optional(),
+      startLine: external_exports.number().int().nonnegative().optional().describe("0-based first line to include. Range is applied to the full file before maxBytes."),
+      endLine: external_exports.number().int().positive().optional().describe("Exclusive 0-based end line. Omit to read through EOF (still capped by maxBytes)."),
       maxBytes: external_exports.number().int().positive().max(1e7).default(1e6)
     });
     readFileTool = {
       name: "read_file",
-      description: "Read a file with optional line range. Returns content + metadata. Use before edit_file.",
+      description: "Read a file with optional 0-based line range (endLine exclusive). maxBytes caps the selected range, not a prefix of the file. Returns content + metadata. Use before edit_file.",
       permissions: ["read"],
+      sideEffect: "none",
       timeoutMs: 5e3,
       inputSchema: ReadFileArgsSchema,
       execute: async (args, ctx) => {
@@ -18262,24 +18263,31 @@ var init_filesystem = __esm({
           const buf = await fs4.readFile(absPath, { encoding: "utf-8", signal: ctx.signal });
           const content = typeof buf === "string" ? buf : buf.toString("utf-8");
           const allLines = content.split("\n");
-          const truncated = content.length > args.maxBytes ? content.slice(0, args.maxBytes) : content;
-          const lines = truncated === content ? allLines : truncated.split("\n");
           const totalLines = allLines.length;
           const start = args.startLine ?? 0;
-          const end = Math.min(args.endLine ?? lines.length, lines.length);
-          const wasTruncated = truncated !== content;
+          const endExclusive = Math.min(args.endLine ?? totalLines, totalLines);
           const empty = content.length === 0;
-          const status = empty ? "empty" : wasTruncated ? "partial" : "complete";
+          const rangeEmpty = !empty && (start >= totalLines || endExclusive <= start);
+          const selected = rangeEmpty ? [] : allLines.slice(start, endExclusive);
+          let text = selected.join("\n");
+          const wasTruncated = text.length > args.maxBytes;
+          if (wasTruncated)
+            text = text.slice(0, args.maxBytes);
+          const returnedLines = text.length === 0 ? 0 : text.split("\n").length;
+          const readEnd = returnedLines === 0 ? Math.max(0, start - 1) : start + returnedLines - 1;
+          const status = empty || rangeEmpty ? "empty" : wasTruncated ? "partial" : "complete";
           const warnings = [];
           if (empty)
             warnings.push("EMPTY_FILE");
+          if (rangeEmpty)
+            warnings.push("LINE_RANGE_EMPTY");
           if (wasTruncated)
             warnings.push("MAX_BYTES_TRUNCATED");
           return typedOk({
             path: absPath,
-            content: lines.slice(start, end).join("\n"),
+            content: text,
             totalLines,
-            readLines: { start, end: end - 1 },
+            readLines: { start, end: readEnd },
             sizeBytes: content.length
           }, {
             status,
@@ -18305,6 +18313,7 @@ var init_filesystem = __esm({
       name: "write_file",
       description: "Write or create a file. Use createDirs=true to auto-create parent directories.",
       permissions: ["write"],
+      sideEffect: "local",
       timeoutMs: 1e4,
       inputSchema: WriteFileArgsSchema,
       execute: async (args, ctx) => {
@@ -18330,6 +18339,7 @@ var init_filesystem = __esm({
       name: "edit_file",
       description: "Replace exact string match in a file. Idempotent: returns 0 occurrences if no match.",
       permissions: ["write"],
+      sideEffect: "local",
       timeoutMs: 1e4,
       inputSchema: EditFileArgsSchema,
       execute: async (args, ctx) => {
@@ -18561,6 +18571,7 @@ var init_shell = __esm({
       name: "bash",
       description: "Run a shell command. On Windows uses Git Bash when available (POSIX semantics: ls, $VAR, && work); falls back to cmd.exe otherwise. Streams stdout/stderr. Respects timeout and cancellation. Returns exit code. stdin is CLOSED (non-interactive): any command that prompts for input will fail or be cancelled \u2014 always pass non-interactive flags (--yes, -y, --template), and if a scaffolder insists on prompting (e.g. create-vite in a non-empty directory), create the files manually with write_file instead.",
       permissions: ["execute"],
+      sideEffect: "local",
       timeoutMs: 6e4,
       inputSchema: BashArgsSchema,
       execute: async (args, ctx) => {
@@ -18870,6 +18881,7 @@ var init_search = __esm({
       name: "grep_content",
       description: 'Regex search for content in a file OR recursively in a directory. When path is a directory, include/exclude globs filter which files are searched (default: all files, excluding node_modules/dist/.git/etc.). Glob semantics: "*" matches ONE path segment only ("*.ts" does NOT match "sub/file.ts"); use "**" for recursive matching ("**/*.ts" matches at any depth). include/exclude accept a single glob string (e.g. "*.ts") OR an array of globs. Returns matches with line numbers and context, plus filesWalked/filesInTree counts and a warning when the include globs matched suspiciously few files.',
       permissions: ["read"],
+      sideEffect: "none",
       timeoutMs: 3e4,
       inputSchema: GrepContentArgsSchema,
       execute: async (args, ctx) => {
@@ -18987,6 +18999,7 @@ var init_listFiles = __esm({
       name: "list_files",
       description: "List files and directories in the given path (defaults to the working directory). Returns names with types (file/directory). Use this to discover the project structure before reading specific files. Supports a maxDepth for recursive listing and excludes common dependency/build directories by default.",
       permissions: ["read"],
+      sideEffect: "none",
       timeoutMs: 15e3,
       inputSchema: ListFilesArgsSchema,
       execute: async (args, ctx) => {
@@ -19241,6 +19254,7 @@ var init_diff = __esm({
       name: "show_diff",
       description: "Show unified diff between current file content and proposed content. Read-only \u2014 does NOT modify the file. Use this to preview edits before applying with edit_file or apply_diff.",
       permissions: ["read"],
+      sideEffect: "none",
       timeoutMs: 15e3,
       inputSchema: ShowDiffArgsSchema,
       execute: async (args, ctx) => {
@@ -19343,6 +19357,7 @@ var init_diff = __esm({
       name: "apply_diff",
       description: "Apply a unified diff patch to a file. Parses ---/+++/@@ headers and applies each hunk sequentially. With fuzzyMatch=true, tolerates whitespace differences. With dryRun=true, returns the final content without writing. Atomic: if any hunk fails, no partial write occurs.",
       permissions: ["write"],
+      sideEffect: "local",
       timeoutMs: 15e3,
       inputSchema: ApplyDiffArgsSchema,
       execute: async (args, ctx) => {
@@ -19404,9 +19419,9 @@ function assertHttpUrl(raw) {
   }
   return url2;
 }
-async function fetchWithTimeout(url2, init, outerSignal, timeoutMs) {
+async function fetchWithTimeout(url2, init, outerSignal, timeoutMs2) {
   const ctrl = new AbortController();
-  const timer = setTimeout(() => ctrl.abort(new Error(`timeout after ${timeoutMs}ms`)), timeoutMs);
+  const timer = setTimeout(() => ctrl.abort(new Error(`timeout after ${timeoutMs2}ms`)), timeoutMs2);
   const onOuterAbort = () => ctrl.abort(outerSignal?.reason);
   outerSignal?.addEventListener("abort", onOuterAbort, { once: true });
   try {
@@ -21471,6 +21486,42 @@ var init_types = __esm({
   }
 });
 
+// packages/core/dist/core/tools/concurrency.js
+function taskAgent(args) {
+  if (!args || typeof args !== "object")
+    return "explore";
+  const agent = args.agent;
+  return typeof agent === "string" && agent.trim() ? agent : "explore";
+}
+function classifyToolConcurrency(input) {
+  const env = input.env ?? process.env;
+  if (env.ZELARI_PARALLEL_TOOLS === "0")
+    return "exclusive";
+  const name = input.toolName;
+  if (name === "task") {
+    return taskAgent(input.args) === "general" ? "exclusive" : "parallel-safe";
+  }
+  if (input.registered === false) {
+    if (name.startsWith("mcp_")) {
+      const lower = name.toLowerCase();
+      if (lower.includes("write") || lower.includes("edit") || lower.includes("delete")) {
+        return "exclusive";
+      }
+      return "parallel-safe";
+    }
+    return "exclusive";
+  }
+  const perms = input.permissions ?? [];
+  if (perms.includes("write") || perms.includes("execute"))
+    return "exclusive";
+  return "parallel-safe";
+}
+var init_concurrency = __esm({
+  "packages/core/dist/core/tools/concurrency.js"() {
+    "use strict";
+  }
+});
+
 // packages/core/dist/core/contextGrowth.js
 function emptyContextGrowthStats() {
   return {
@@ -22022,6 +22073,7 @@ var init_AgentHarness = __esm({
   "packages/core/dist/core/AgentHarness.js"() {
     "use strict";
     init_events();
+    init_concurrency();
     init_toolTypes();
     init_contextGrowth();
     init_requestSnapshot();
@@ -22106,30 +22158,19 @@ var init_AgentHarness = __esm({
         };
       }
       /**
-       * v1.8.0: true when a tool may run concurrently with other parallel-safe
-       * tools. Write/execute tools stay serial (preserve file/order safety).
-       * `task` is parallel-safe (read-only sub-agents). Opt out: ZELARI_PARALLEL_TOOLS=0.
+       * v1.8.0 / 2.x F: true when a tool may run concurrently with other
+       * parallel-safe tools. Write/execute stay serial. `task agent=general`
+       * is exclusive (it writes); explore/verify tentacles stay parallel-safe.
+       * Opt out: ZELARI_PARALLEL_TOOLS=0.
        */
-      isParallelSafeTool(toolName) {
-        if (process.env.ZELARI_PARALLEL_TOOLS === "0")
-          return false;
-        if (toolName === "task")
-          return true;
+      isParallelSafeTool(toolName, args) {
         const def = this.config.toolRegistry?.get(toolName);
-        if (!def) {
-          if (toolName.startsWith("mcp_")) {
-            const lower = toolName.toLowerCase();
-            if (lower.includes("write") || lower.includes("edit") || lower.includes("delete")) {
-              return false;
-            }
-            return true;
-          }
-          return false;
-        }
-        const perms = def.permissions ?? [];
-        if (perms.includes("write") || perms.includes("execute"))
-          return false;
-        return true;
+        return classifyToolConcurrency({
+          toolName,
+          args,
+          permissions: def?.permissions,
+          registered: Boolean(def) || toolName === "task"
+        }) === "parallel-safe";
       }
       /**
        * Execute buffered native tool calls: consecutive parallel-safe tools run
@@ -22234,13 +22275,13 @@ ${shared2.content}`,
         let i = 0;
         while (i < pending.length) {
           const p3 = pending[i];
-          if (p3.skipped || p3.cached !== void 0 || !this.isParallelSafeTool(p3.toolName)) {
+          if (p3.skipped || p3.cached !== void 0 || !this.isParallelSafeTool(p3.toolName, p3.args)) {
             out[i] = toOut(p3, await invokeOne(p3));
             i += 1;
             continue;
           }
           let j = i;
-          while (j < pending.length && !pending[j].skipped && pending[j].cached === void 0 && this.isParallelSafeTool(pending[j].toolName)) {
+          while (j < pending.length && !pending[j].skipped && pending[j].cached === void 0 && this.isParallelSafeTool(pending[j].toolName, pending[j].args)) {
             j += 1;
           }
           for (let off = i; off < j; off += maxParallel) {
@@ -23286,8 +23327,8 @@ var init_lifecycleHookRunner = __esm({
       /** Execute a single hook, swallowing every failure into an allow. */
       async runHookSafely(hook, payload) {
         try {
-          const timeoutMs = hook.timeoutMs ?? this.defaultTimeoutMs;
-          const raw = hook.url ? await this.postHttp(hook.url, payload, timeoutMs) : await this.execCommand(hook.command ?? "", payload, timeoutMs, hook.cwd);
+          const timeoutMs2 = hook.timeoutMs ?? this.defaultTimeoutMs;
+          const raw = hook.url ? await this.postHttp(hook.url, payload, timeoutMs2) : await this.execCommand(hook.command ?? "", payload, timeoutMs2, hook.cwd);
           const decision = parseJson(raw);
           if (!decision) {
             this.logger(`hook "${hook.name}" returned invalid JSON (fail-open): ${raw.slice(0, 200)}`);
@@ -23304,7 +23345,7 @@ var init_lifecycleHookRunner = __esm({
         }
       }
       /** Spawn `command`, write JSON payload to stdin, read stdout until close. */
-      execCommand(command, payload, timeoutMs, cwd) {
+      execCommand(command, payload, timeoutMs2, cwd) {
         return new Promise((resolve3, reject) => {
           const child = spawn2(command, {
             shell: true,
@@ -23316,8 +23357,8 @@ var init_lifecycleHookRunner = __esm({
           let stderr = "";
           const timer = setTimeout(() => {
             child.kill("SIGKILL");
-            reject(new Error(`timed out after ${timeoutMs}ms`));
-          }, timeoutMs);
+            reject(new Error(`timed out after ${timeoutMs2}ms`));
+          }, timeoutMs2);
           child.stdout?.on("data", (d) => {
             stdout += d.toString();
           });
@@ -23343,9 +23384,9 @@ var init_lifecycleHookRunner = __esm({
         });
       }
       /** POST JSON payload; resolve with the response body text. */
-      async postHttp(url2, payload, timeoutMs) {
+      async postHttp(url2, payload, timeoutMs2) {
         const ctrl = new AbortController();
-        const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+        const timer = setTimeout(() => ctrl.abort(), timeoutMs2);
         try {
           const res = await fetch(url2, {
             method: "POST",
@@ -27921,7 +27962,7 @@ function deepFreeze(value) {
   return Object.freeze(value);
 }
 async function runInSandbox(opts) {
-  const { bundleCode, sdk, timeoutMs } = opts;
+  const { bundleCode, sdk, timeoutMs: timeoutMs2 } = opts;
   if (!opts.skipFootgunScan) {
     const footguns = scanForFootguns(bundleCode);
     if (footguns.length > 0) {
@@ -27941,7 +27982,7 @@ async function runInSandbox(opts) {
   });
   const start = Date.now();
   const vmOpts = {
-    timeout: Math.max(1, timeoutMs),
+    timeout: Math.max(1, timeoutMs2),
     displayErrors: true,
     breakOnSigint: true
   };
@@ -27951,7 +27992,7 @@ async function runInSandbox(opts) {
   } catch (err) {
     const msg = err && typeof err === "object" && "message" in err ? String(err.message ?? "") : String(err);
     if (/timed out/i.test(msg)) {
-      throw new PlanError("budget_exceeded", `script exceeded ${timeoutMs}ms budget`);
+      throw new PlanError("budget_exceeded", `script exceeded ${timeoutMs2}ms budget`);
     }
     if (opts.signal?.aborted) {
       throw new PlanError("cancelled", "script aborted by host");
@@ -28263,6 +28304,8 @@ var init_types8 = __esm({
       "assistant.message",
       "tool.call",
       "tool.result",
+      // 2.x B (crash-safe recovery): dangling call classified. State-only.
+      "tool.interrupted",
       "context.injected",
       "session.compacted",
       "task.created",
@@ -28515,6 +28558,82 @@ var init_writer = __esm({
   }
 });
 
+// packages/core/dist/session/recovery.js
+function sideEffectForTool(tool, declared) {
+  if (declared)
+    return declared;
+  if (EXTERNAL.has(tool))
+    return "external";
+  if (READ_ONLY.has(tool))
+    return "none";
+  return "local";
+}
+function retrySafetyForSideEffect(sideEffect) {
+  return sideEffect === "none" ? "safe" : "inspect-first";
+}
+function toolNameOf(call) {
+  return typeof call.data.tool === "string" && call.data.tool.trim() ? call.data.tool : "unknown";
+}
+function callIdOf(call) {
+  return typeof call.data.callId === "string" ? call.data.callId : `seq:${call.seq}`;
+}
+function classifyInterruptedTools(events, sideEffects = /* @__PURE__ */ new Map()) {
+  const alreadyClassified = new Set(events.filter((e) => e.kind === "tool.interrupted").map((e) => typeof e.data.callId === "string" ? e.data.callId : void 0).filter((id) => Boolean(id)));
+  const out = [];
+  for (const pair of pairToolCalls(events)) {
+    if (pair.result)
+      continue;
+    const callId = callIdOf(pair.call);
+    if (alreadyClassified.has(callId))
+      continue;
+    const tool = toolNameOf(pair.call);
+    const sideEffect = sideEffectForTool(tool, sideEffects.get(tool));
+    const retrySafety = retrySafetyForSideEffect(sideEffect);
+    out.push({
+      toolCallSeq: pair.call.seq,
+      callId,
+      tool,
+      state: retrySafety === "safe" ? "not-started" : "started-outcome-unknown",
+      retrySafety,
+      sideEffect
+    });
+  }
+  return out;
+}
+function interruptedEventData(item) {
+  return {
+    toolCallSeq: item.toolCallSeq,
+    callId: item.callId,
+    tool: item.tool,
+    state: item.state,
+    retrySafety: item.retrySafety,
+    sideEffect: item.sideEffect
+  };
+}
+var READ_ONLY, EXTERNAL;
+var init_recovery = __esm({
+  "packages/core/dist/session/recovery.js"() {
+    "use strict";
+    init_modelSurface();
+    READ_ONLY = /* @__PURE__ */ new Set([
+      "read_file",
+      "list_files",
+      "grep_content",
+      "show_diff",
+      "web_search",
+      "fetch_url",
+      "lsp_definition",
+      "lsp_references",
+      "lsp_hover",
+      "lsp_symbols",
+      "ast_outline",
+      "ast_find_symbol",
+      "semantic_search"
+    ]);
+    EXTERNAL = /* @__PURE__ */ new Set(["fetch_url", "web_search"]);
+  }
+});
+
 // packages/core/dist/session/replay.js
 import { promises as fs10 } from "node:fs";
 async function readSessionLog(filePath) {
@@ -28599,7 +28718,8 @@ function buildProjection(events, issues = []) {
     missionPhases: [],
     missionAdvice: [],
     replans: 0,
-    issues
+    issues,
+    interruptedTools: classifyInterruptedTools(events)
   };
   for (const e of events) {
     switch (e.kind) {
@@ -28650,6 +28770,7 @@ var init_replay = __esm({
     "use strict";
     init_types8();
     init_modelSurface();
+    init_recovery();
   }
 });
 
@@ -28789,12 +28910,20 @@ async function forkSession(store6, parentSessionId, options = {}) {
 }
 async function resumeSession(store6, sessionId2) {
   const opened = await store6.open(sessionId2);
+  const classified = [];
+  for (const item of classifyInterruptedTools(opened.report.events)) {
+    classified.push(await opened.writer.append({
+      kind: "tool.interrupted",
+      actor: ACTOR_SYSTEM,
+      data: interruptedEventData(item)
+    }));
+  }
   const resumed = await opened.writer.append({
     kind: "session.resumed",
     actor: ACTOR_SYSTEM,
     data: { fromSeq: opened.projection.lastSeq }
   });
-  const projection = buildProjection([...opened.report.events, resumed]);
+  const projection = buildProjection([...opened.report.events, ...classified, resumed]);
   return { writer: opened.writer, projection };
 }
 async function lineageOf(store6, sessionId2) {
@@ -28822,6 +28951,7 @@ var init_lineage = __esm({
     "use strict";
     init_types8();
     init_replay();
+    init_recovery();
   }
 });
 
@@ -28862,6 +28992,104 @@ var init_exportSession = __esm({
   }
 });
 
+// packages/core/dist/session/invariants.js
+function asSeq(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+}
+function collectEvidenceSeqs(events) {
+  const out = [];
+  const walk2 = (ownerSeq, value) => {
+    if (Array.isArray(value)) {
+      for (const item of value)
+        walk2(ownerSeq, item);
+      return;
+    }
+    if (!value || typeof value !== "object")
+      return;
+    const rec = value;
+    const seq = asSeq(rec.seq);
+    if (seq !== void 0 && ("digest" in rec || "tier" in rec || "ref" in rec)) {
+      out.push({ ownerSeq, refSeq: seq });
+    }
+    for (const v of Object.values(rec))
+      walk2(ownerSeq, v);
+  };
+  for (const e of events)
+    walk2(e.seq, e.data);
+  return out;
+}
+function validateSessionTrace(events, mode = "minimal") {
+  const violations = [];
+  let expected = 1;
+  for (const e of events) {
+    if (e.seq !== expected) {
+      violations.push({
+        code: "SEQ_NOT_MONOTONIC",
+        seq: e.seq,
+        message: `expected seq ${expected}, got ${e.seq}`
+      });
+    }
+    expected = e.seq + 1;
+  }
+  const pairs = pairToolCalls(events);
+  const resultCounts = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.kind !== "tool.result")
+      continue;
+    const callId = typeof e.data.callId === "string" ? e.data.callId : `seq:${e.seq}`;
+    resultCounts.set(callId, (resultCounts.get(callId) ?? 0) + 1);
+  }
+  for (const [callId, n] of resultCounts) {
+    if (n > 1) {
+      violations.push({
+        code: "DUPLICATE_TOOL_RESULT",
+        message: `callId ${callId} has ${n} tool.result events`
+      });
+    }
+  }
+  const interruptedCallIds = new Set(events.filter((e) => e.kind === "tool.interrupted").map((e) => typeof e.data.callId === "string" ? e.data.callId : void 0).filter((id) => Boolean(id)));
+  for (const pair of pairs) {
+    if (pair.result)
+      continue;
+    const callId = typeof pair.call.data.callId === "string" ? pair.call.data.callId : `seq:${pair.call.seq}`;
+    if (interruptedCallIds.has(callId))
+      continue;
+    if (mode === "strict") {
+      violations.push({
+        code: "DANGLING_TOOL_CALL",
+        seq: pair.call.seq,
+        message: `tool.call ${callId} has no tool.result and no tool.interrupted`
+      });
+    }
+  }
+  const knownSeq = new Set(events.map((e) => e.seq));
+  for (const ref of collectEvidenceSeqs(events)) {
+    if (!knownSeq.has(ref.refSeq)) {
+      violations.push({
+        code: "EVIDENCE_SEQ_MISSING",
+        seq: ref.ownerSeq,
+        message: `EvidenceRef.seq ${ref.refSeq} is not an event in this trace`
+      });
+    }
+  }
+  const firstVerification = events.find((e) => e.kind === "verification.run");
+  const firstEnded = events.find((e) => e.kind === "session.ended");
+  if (firstVerification && firstEnded && firstEnded.seq < firstVerification.seq) {
+    violations.push({
+      code: "COMPLETION_BEFORE_VERIFICATION",
+      seq: firstEnded.seq,
+      message: `session.ended seq ${firstEnded.seq} precedes verification.run seq ${firstVerification.seq}`
+    });
+  }
+  return violations;
+}
+var init_invariants = __esm({
+  "packages/core/dist/session/invariants.js"() {
+    "use strict";
+    init_modelSurface();
+  }
+});
+
 // packages/core/dist/session/index.js
 var init_session = __esm({
   "packages/core/dist/session/index.js"() {
@@ -28874,6 +29102,8 @@ var init_session = __esm({
     init_store();
     init_lineage();
     init_exportSession();
+    init_invariants();
+    init_recovery();
   }
 });
 
@@ -29007,7 +29237,7 @@ var init_nodeProviders = __esm({
       async exec(command, options = {}) {
         const started = Date.now();
         const cwd = this.workspace.resolve(options.cwd ?? ".");
-        const timeoutMs = options.timeoutMs ?? this.defaults.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+        const timeoutMs2 = options.timeoutMs ?? this.defaults.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
         const maxChars = options.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
         const isWindows = process.platform === "win32";
         const file2 = isWindows ? "cmd.exe" : "/bin/sh";
@@ -29030,7 +29260,7 @@ var init_nodeProviders = __esm({
           const timer = setTimeout(() => {
             timedOut = true;
             killTree(child);
-          }, timeoutMs);
+          }, timeoutMs2);
           child.stdout?.on("data", (d) => {
             stdout = append(stdout, d.toString("utf-8"));
           });
@@ -29486,6 +29716,72 @@ var init_types9 = __esm({
   }
 });
 
+// packages/core/dist/verification/scopeDiscipline.js
+function normalize(p3) {
+  return p3.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function isGeneratedPath(file2) {
+  const n = normalize(file2);
+  return GENERATED_NAME.test(n) || GENERATED_DIR.test(n);
+}
+function parseNameOnlyDiff(stdout) {
+  return stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean).map(normalize);
+}
+function analyzeScope(input) {
+  const changed = input.changedFiles.map(normalize);
+  if (changed.length === 0) {
+    return {
+      status: "unknown",
+      expected: [],
+      unexpected: [],
+      generated: [],
+      reasons: ["no changed files observed"]
+    };
+  }
+  const expectedSet = new Set((input.expectedFiles ?? []).map(normalize));
+  const generatedExtra = new Set((input.generatedFiles ?? []).map(normalize));
+  const generated = [];
+  const unexpected = [];
+  const expectedHit = [];
+  for (const file2 of changed) {
+    if (generatedExtra.has(file2) || isGeneratedPath(file2)) {
+      generated.push(file2);
+      continue;
+    }
+    if (expectedSet.size === 0) {
+      expectedHit.push(file2);
+      continue;
+    }
+    if (expectedSet.has(file2))
+      expectedHit.push(file2);
+    else
+      unexpected.push(file2);
+  }
+  const reasons = [];
+  if (unexpected.length > 0) {
+    reasons.push(`${unexpected.length} file(s) outside expected scope: ${unexpected.join(", ")}`);
+  }
+  if (generated.length > 0) {
+    reasons.push(`${generated.length} generated/lockfile path(s) ignored for the concern`);
+  }
+  let status = "pass";
+  if (expectedSet.size === 0) {
+    status = "unknown";
+    reasons.push("no expected-files allowlist \u2014 cannot judge scope");
+  } else if (unexpected.length > 0) {
+    status = "concern";
+  }
+  return { status, expected: expectedHit, unexpected, generated, reasons };
+}
+var GENERATED_NAME, GENERATED_DIR;
+var init_scopeDiscipline = __esm({
+  "packages/core/dist/verification/scopeDiscipline.js"() {
+    "use strict";
+    GENERATED_NAME = /(?:^|\/)(?:package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb|Cargo\.lock|go\.sum|poetry\.lock|composer\.lock)$/i;
+    GENERATED_DIR = /(?:^|\/)(?:dist|build|out|coverage|\.next|node_modules)\//;
+  }
+});
+
 // packages/core/dist/verification/engine.js
 import { createHash as createHash4 } from "node:crypto";
 function defaultSha256(input) {
@@ -29498,6 +29794,7 @@ var VerificationEngine;
 var init_engine = __esm({
   "packages/core/dist/verification/engine.js"() {
     "use strict";
+    init_scopeDiscipline();
     VerificationEngine = class {
       services;
       options;
@@ -29509,7 +29806,7 @@ var init_engine = __esm({
       async evaluate(criteria, context = {}) {
         const results = [];
         for (const criterion of criteria) {
-          results.push(await this.evaluateOne(criterion));
+          results.push(await this.evaluateOne(criterion, context.scope));
         }
         if (this.options.emit) {
           try {
@@ -29559,7 +29856,7 @@ var init_engine = __esm({
           return void 0;
         }
       }
-      async evaluateOne(criterion) {
+      async evaluateOne(criterion, scope) {
         const started = this.options.now?.() ?? Date.now();
         const base = {
           criterionId: criterion.id,
@@ -29571,6 +29868,15 @@ var init_engine = __esm({
           ...patch,
           durationMs: Math.max(0, (this.options.now?.() ?? Date.now()) - started)
         });
+        if (criterion.id === "quality.scope-discipline" && scope) {
+          const analysis = analyzeScope(scope);
+          const status = analysis.status === "pass" ? "pass" : "unknown";
+          return done({
+            status,
+            evidence: [],
+            detail: analysis.reasons.join("; ") || analysis.status
+          });
+        }
         const check2 = criterion.check;
         if (!check2 || check2.kind === "none") {
           return done({
@@ -29892,9 +30198,9 @@ var init_sessionEvidence = __esm({
 
 // packages/core/dist/verification/criteriaPack.v1.js
 function codingCriteriaPack(options = {}) {
-  const timeoutMs = options.commandTimeoutMs ?? 6e5;
+  const timeoutMs2 = options.commandTimeoutMs ?? 6e5;
   const withDefault = (o, d) => o === void 0 ? d : o;
-  const command = (command2) => command2 ? { kind: "command", command: command2, timeoutMs } : void 0;
+  const command = (command2) => command2 ? { kind: "command", command: command2, timeoutMs: timeoutMs2 } : void 0;
   const criteria = [
     {
       id: "correctness.error-signals",
@@ -30184,6 +30490,7 @@ var init_verification2 = __esm({
     init_criteriaPack_v1();
     init_metrics();
     init_verifier();
+    init_scopeDiscipline();
   }
 });
 
@@ -30448,6 +30755,7 @@ __export(dist_exports, {
   WorkspacePathEscapeError: () => WorkspacePathEscapeError,
   WorktreeWorkspace: () => WorktreeWorkspace,
   ZELARI_CODING_PACK_ID: () => ZELARI_CODING_PACK_ID,
+  analyzeScope: () => analyzeScope,
   applyCompletionRetry: () => applyCompletionRetry,
   applyDeterministicAutofix: () => applyDeterministicAutofix,
   applyImplementationWriteRetry: () => applyImplementationWriteRetry,
@@ -30478,6 +30786,7 @@ __export(dist_exports, {
   checkImplementationDelivery: () => checkImplementationDelivery,
   checkMemberToolEmissionSets: () => checkMemberToolEmissionSets,
   checkMemberToolEmissions: () => checkMemberToolEmissions,
+  classifyInterruptedTools: () => classifyInterruptedTools,
   classifyMission: () => classifyMission,
   classifyTaskScope: () => classifyTaskScope,
   cleanAgentContent: () => cleanAgentContent,
@@ -30545,6 +30854,7 @@ __export(dist_exports, {
   hasInteractiveClarification: () => hasInteractiveClarification,
   hashToolCall: () => hashToolCall,
   hookMatches: () => hookMatches,
+  interruptedEventData: () => interruptedEventData,
   isAnswerLeak: () => isAnswerLeak,
   isBrainAgentEndEvent: () => isBrainAgentEndEvent,
   isBrainAgentStartEvent: () => isBrainAgentStartEvent,
@@ -30568,6 +30878,7 @@ __export(dist_exports, {
   isConverged: () => isConverged,
   isEventBackedEvidence: () => isEventBackedEvidence,
   isExperimentalEnabled: () => isExperimentalEnabled,
+  isGeneratedPath: () => isGeneratedPath,
   isModelSurfaceEvent: () => isModelSurfaceEvent,
   isReviewerKind: () => isReviewerKind,
   isSettled: () => isSettled,
@@ -30594,6 +30905,7 @@ __export(dist_exports, {
   parseClarificationRequest: () => parseClarificationRequest,
   parseEvidenceTier: () => parseEvidenceTier,
   parseMinimaxStyleToolCalls: () => parseMinimaxStyleToolCalls,
+  parseNameOnlyDiff: () => parseNameOnlyDiff,
   parsePersonaVerdict: () => parsePersonaVerdict,
   parseProjectRootFromWorkspaceContext: () => parseProjectRootFromWorkspaceContext,
   parseTextToolCalls: () => parseTextToolCalls,
@@ -30631,6 +30943,7 @@ __export(dist_exports, {
   resolveVerifyRetryTool: () => resolveVerifyRetryTool,
   restrictImplementationWrites: () => restrictImplementationWrites,
   resumeSession: () => resumeSession,
+  retrySafetyForSideEffect: () => retrySafetyForSideEffect,
   runChairmanDeliveryLoop: () => runChairmanDeliveryLoop,
   runChairmanFixLoop: () => runChairmanFixLoop,
   runChairmanMicroGate: () => runChairmanMicroGate,
@@ -30647,6 +30960,7 @@ __export(dist_exports, {
   setWorkspaceStubs: () => setWorkspaceStubs,
   sha256Hex: () => sha256Hex,
   shouldRetryMember: () => shouldRetryMember,
+  sideEffectForTool: () => sideEffectForTool,
   slugify: () => slugify2,
   snapshotToCompletionEvaluation: () => snapshotToCompletionEvaluation,
   specificityFromAssumptions: () => specificityFromAssumptions,
@@ -30666,6 +30980,7 @@ __export(dist_exports, {
   utf8Bytes: () => utf8Bytes,
   validateCodingSkillRequires: () => validateCodingSkillRequires,
   validateGraph: () => validateGraph,
+  validateSessionTrace: () => validateSessionTrace,
   verificationCostRatio: () => verificationCostRatio,
   verifiedSolveRate: () => verifiedSolveRate,
   verifyCitations: () => verifyCitations,
@@ -32966,10 +33281,26 @@ var init_registry2 = __esm({
         if (!parsed.success) {
           return typedErr(`Invalid input: ${parsed.error.message}`);
         }
-        const timeoutMs = options.timeoutMs ?? tool.timeoutMs ?? 3e4;
-        const signal = options.signal;
+        const timeoutMs2 = options.timeoutMs ?? tool.timeoutMs ?? 3e4;
+        const parentSignal = options.signal;
+        const controller = new AbortController();
+        let timer;
+        let rejectRace;
+        const onParentAbort = () => {
+          if (timer !== void 0)
+            clearTimeout(timer);
+          if (!controller.signal.aborted)
+            controller.abort();
+          rejectRace?.(new Error(`Tool "${name}" aborted`));
+        };
+        if (parentSignal) {
+          if (parentSignal.aborted)
+            onParentAbort();
+          else
+            parentSignal.addEventListener("abort", onParentAbort);
+        }
         const ctx = {
-          signal: signal ?? new AbortController().signal,
+          signal: controller.signal,
           cwd: options.cwd ?? process.cwd(),
           audit: () => {
           },
@@ -32982,6 +33313,7 @@ var init_registry2 = __esm({
               cwd: ctx.cwd
             });
             if (!pre.ok) {
+              parentSignal?.removeEventListener("abort", onParentAbort);
               return typedErr(`[hook:${pre.hookName ?? "unknown"}] ${pre.reason ?? "denied"}`);
             }
           } catch (hookErr) {
@@ -32991,11 +33323,16 @@ var init_registry2 = __esm({
           const result = await Promise.race([
             tool.execute(parsed.data, ctx),
             new Promise((_, reject) => {
-              const timer = setTimeout(() => reject(new Error(`Tool "${name}" timed out after ${timeoutMs}ms`)), timeoutMs);
-              signal?.addEventListener("abort", () => {
-                clearTimeout(timer);
-                reject(new Error(`Tool "${name}" aborted`));
-              });
+              rejectRace = reject;
+              if (parentSignal?.aborted) {
+                onParentAbort();
+                return;
+              }
+              timer = setTimeout(() => {
+                if (!controller.signal.aborted)
+                  controller.abort();
+                reject(new Error(`Tool "${name}" timed out after ${timeoutMs2}ms`));
+              }, timeoutMs2);
             })
           ]);
           if (result.ok) {
@@ -33030,6 +33367,11 @@ var init_registry2 = __esm({
         } catch (err) {
           const error51 = err instanceof Error ? err.message : String(err);
           return typedErr(error51);
+        } finally {
+          rejectRace = void 0;
+          if (timer !== void 0)
+            clearTimeout(timer);
+          parentSignal?.removeEventListener("abort", onParentAbort);
         }
       }
       /** Return all tool definitions in OpenAI function-calling format (memoized). */
@@ -33336,11 +33678,11 @@ async function runDiagnosticsForFile(file2, options = {}) {
   const provider = providerForFile(file2, options.providers);
   if (!provider) return [];
   const cwd = options.cwd ?? process.cwd();
-  const timeoutMs = options.timeoutMs ?? 5e3;
+  const timeoutMs2 = options.timeoutMs ?? 5e3;
   const runner = options.runner ?? defaultRunner;
   try {
     const bin = options.runner ? provider.bin : resolveBin(provider.bin, cwd);
-    const result = await runner(bin, provider.args(file2), { cwd, timeoutMs });
+    const result = await runner(bin, provider.args(file2), { cwd, timeoutMs: timeoutMs2 });
     return provider.parse(result.stdout, file2);
   } catch {
     return [];
@@ -33829,7 +34171,7 @@ var init_candidateRegistry = __esm({
 });
 
 // src/cli/kraken/verifyReport.ts
-function normalize(text) {
+function normalize2(text) {
   return text.toLowerCase().replace(/\s+/g, " ").trim();
 }
 function extractVerifyReportBlocks(raw) {
@@ -33858,11 +34200,11 @@ function extractVerifyReportBlocks(raw) {
 function parseVerifyReport(raw, requiredChecks) {
   const byCriterion = /* @__PURE__ */ new Map();
   for (const block of extractVerifyReportBlocks(raw)) {
-    byCriterion.set(normalize(block.check), block);
+    byCriterion.set(normalize2(block.check), block);
   }
   const keys = [...byCriterion.keys()];
   return requiredChecks.map((check2) => {
-    const norm = normalize(check2);
+    const norm = normalize2(check2);
     let block = byCriterion.get(norm) ?? null;
     if (!block) {
       for (const key of keys) {
@@ -33901,18 +34243,18 @@ var init_verifyReport = __esm({
 });
 
 // src/cli/kraken/completionGate.ts
-function normalize2(text) {
+function normalize3(text) {
   return text.toLowerCase().replace(/\s+/g, " ").trim();
 }
 function classifyKrakenChecks(requiredChecks, results) {
   const byCriterion = /* @__PURE__ */ new Map();
   for (const result of results ?? []) {
-    byCriterion.set(normalize2(result.check), result);
+    byCriterion.set(normalize3(result.check), result);
   }
   const keys = [...byCriterion.keys()];
   const out = { passed: [], failed: [], unknown: [] };
   for (const check2 of requiredChecks) {
-    const norm = normalize2(check2);
+    const norm = normalize3(check2);
     let result = byCriterion.get(norm) ?? null;
     if (!result) {
       for (const key of keys) {
@@ -34137,69 +34479,79 @@ async function runSubAgent(harness, opts = {}) {
   let usage;
   const pendingTools = /* @__PURE__ */ new Map();
   const toolTrace = [];
-  if (signal?.aborted) return { result: "", aborted: true };
-  for await (const ev of harness.run()) {
-    if (signal?.aborted) {
-      return {
-        result: (lastCompleted || current).trim(),
-        ...error51 ? { error: error51 } : {},
-        aborted: true,
-        ...toolTrace.length > 0 ? { toolTrace } : {}
-      };
-    }
-    if (ev.type === "tool_execution_start") {
-      pendingTools.set(ev.toolCallId, { tool: ev.toolName, command: toolCommandHint(ev.args) });
-    } else if (ev.type === "tool_execution_end") {
-      const started = pendingTools.get(ev.toolCallId);
-      pendingTools.delete(ev.toolCallId);
-      toolTrace.push({
-        tool: started?.tool ?? "unknown",
-        callId: ev.toolCallId,
-        ok: !ev.isError,
-        ...started?.command ? { command: started.command } : {},
-        output: String(ev.result ?? "").slice(0, TOOL_TRACE_OUTPUT_MAX),
-        durationMs: ev.durationMs,
-        endedAt: Date.now()
-      });
-      if (toolTrace.length > TOOL_TRACE_RING) {
-        toolTrace.splice(0, toolTrace.length - TOOL_TRACE_RING);
+  const onAbort = () => harness.cancel?.();
+  if (signal?.aborted) {
+    onAbort();
+    return { result: "", aborted: true };
+  }
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    for await (const ev of harness.run()) {
+      if (signal?.aborted) {
+        onAbort();
+        return {
+          result: (lastCompleted || current).trim(),
+          ...error51 ? { error: error51 } : {},
+          aborted: true,
+          ...toolTrace.length > 0 ? { toolTrace } : {}
+        };
       }
-    }
-    switch (ev.type) {
-      case "message_start":
-        current = "";
-        break;
-      case "message_delta":
-        current += ev.delta;
-        break;
-      case "message_end":
-        if (current.trim()) lastCompleted = current;
-        if (ev.usage) {
-          usage = usage ? {
-            promptTokens: usage.promptTokens + ev.usage.promptTokens,
-            completionTokens: usage.completionTokens + ev.usage.completionTokens,
-            totalTokens: usage.totalTokens + ev.usage.totalTokens,
-            ...(usage.cachedPromptTokens ?? 0) + (ev.usage.cachedPromptTokens ?? 0) > 0 ? {
-              cachedPromptTokens: (usage.cachedPromptTokens ?? 0) + (ev.usage.cachedPromptTokens ?? 0)
-            } : {}
-          } : ev.usage;
+      if (ev.type === "tool_execution_start") {
+        pendingTools.set(ev.toolCallId, { tool: ev.toolName, command: toolCommandHint(ev.args) });
+      } else if (ev.type === "tool_execution_end") {
+        const started = pendingTools.get(ev.toolCallId);
+        pendingTools.delete(ev.toolCallId);
+        toolTrace.push({
+          tool: started?.tool ?? "unknown",
+          callId: ev.toolCallId,
+          ok: !ev.isError,
+          ...started?.command ? { command: started.command } : {},
+          output: String(ev.result ?? "").slice(0, TOOL_TRACE_OUTPUT_MAX),
+          durationMs: ev.durationMs,
+          endedAt: Date.now()
+        });
+        if (toolTrace.length > TOOL_TRACE_RING) {
+          toolTrace.splice(0, toolTrace.length - TOOL_TRACE_RING);
         }
-        current = "";
-        break;
-      case "error":
-        error51 = ev.message;
-        break;
-      default:
-        break;
+      }
+      switch (ev.type) {
+        case "message_start":
+          current = "";
+          break;
+        case "message_delta":
+          current += ev.delta;
+          break;
+        case "message_end":
+          if (current.trim()) lastCompleted = current;
+          if (ev.usage) {
+            usage = usage ? {
+              promptTokens: usage.promptTokens + ev.usage.promptTokens,
+              completionTokens: usage.completionTokens + ev.usage.completionTokens,
+              totalTokens: usage.totalTokens + ev.usage.totalTokens,
+              ...(usage.cachedPromptTokens ?? 0) + (ev.usage.cachedPromptTokens ?? 0) > 0 ? {
+                cachedPromptTokens: (usage.cachedPromptTokens ?? 0) + (ev.usage.cachedPromptTokens ?? 0)
+              } : {}
+            } : ev.usage;
+          }
+          current = "";
+          break;
+        case "error":
+          error51 = ev.message;
+          break;
+        default:
+          break;
+      }
     }
+    const result = (lastCompleted || current).trim();
+    return {
+      result,
+      ...error51 ? { error: error51 } : {},
+      ...usage ? { usage } : {},
+      ...toolTrace.length > 0 ? { toolTrace } : {}
+    };
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
   }
-  const result = (lastCompleted || current).trim();
-  return {
-    result,
-    ...error51 ? { error: error51 } : {},
-    ...usage ? { usage } : {},
-    ...toolTrace.length > 0 ? { toolTrace } : {}
-  };
 }
 async function runTentacle(opts) {
   const { deps, args, agent, thoroughness, parentCwd, sessionId: sessionId2 } = opts;
@@ -34429,7 +34781,7 @@ function createTaskTool(deps, policy = {}) {
     description: "Delegate a focused sub-task to an isolated sub-agent with its own context; returns only a concise conclusion (keeps parent context lean).\n- agent=explore (default): read-only research/search\n- agent=general: can edit files for one bounded unit of work\n- agent=verify: read + bash to run tests/checks\nProvide a fully self-contained `prompt` (sub-agent cannot see this conversation). Optional scope[] + acceptance[] contracts. After general, follow up with verify." + (restricted ? `
 RESTRICTED in this mode: only agent=${allowedAgents.join("|")} is allowed.` : ""),
     permissions: ["read", "network", "write", "execute"],
-    timeoutMs: 3e5,
+    timeoutMs: TASK_TOOL_TIMEOUT_MS,
     inputSchema: inputSchema2,
     execute: async (args, ctx) => {
       const agent = args.agent ?? "explore";
@@ -34532,7 +34884,7 @@ ${res.result}${res.footer}`,
     }
   };
 }
-var EXPLORE_PROMPT, GENERAL_PROMPT, VERIFY_PROMPT, TaskArgsSchema, TaskPurposeSchema, TaskArgsWithPurposeSchema, TOOL_TRACE_RING, TOOL_TRACE_OUTPUT_MAX;
+var TASK_TOOL_TIMEOUT_MS, EXPLORE_PROMPT, GENERAL_PROMPT, VERIFY_PROMPT, TaskArgsSchema, TaskPurposeSchema, TaskArgsWithPurposeSchema, TOOL_TRACE_RING, TOOL_TRACE_OUTPUT_MAX;
 var init_taskTool = __esm({
   "src/cli/tools/taskTool.ts"() {
     "use strict";
@@ -34544,6 +34896,7 @@ var init_taskTool = __esm({
     init_candidateRegistry();
     init_verifyReport();
     init_metrics3();
+    TASK_TOOL_TIMEOUT_MS = 9e5;
     EXPLORE_PROMPT = [
       "You are a focused EXPLORE tentacle of Kraken (parent super-agent).",
       "READ-ONLY tools only (read, list, grep, fetch). No edits, no shell.",
@@ -34831,7 +35184,7 @@ function renderVerdict(verdict, candidateCount) {
   return lines.join("\n");
 }
 function createKrakenSelectTool(deps) {
-  const timeoutMs = deps.timeoutMs ?? 12e4;
+  const timeoutMs2 = deps.timeoutMs ?? 12e4;
   return {
     name: "kraken_select",
     description: "Compare the candidate research reports spawned this turn (task purpose=candidate) and select the hypothesis best supported by OBSERVED EVIDENCE. A dedicated verifier call (default: the current model) judges grounded vs unsupported claims; degraded observations are never treated as proof of absence. Returns the selected candidate, a rationale, and requiredChecks the implementation must pass. Call it ONCE per turn, after candidate tentacles finished and BEFORE implementing. If it reports needs_more_evidence, either spawn ONE more differentiated candidate or proceed with your own judgment.",
@@ -34888,7 +35241,7 @@ function createKrakenSelectTool(deps) {
                 model: id.model,
                 provider: id.provider,
                 tools: [],
-                signal: AbortSignal.timeout(timeoutMs)
+                signal: AbortSignal.timeout(timeoutMs2)
               });
               judgingUsage = usage;
               if (raw.trim().length === 0) throw new Error("empty verifier response");
@@ -38439,7 +38792,7 @@ exec node "$(dirname "$0")/askpass.cjs"
   }
   return sh;
 }
-function runSsh(target, remoteCommand, timeoutMs = 6e4) {
+function runSsh(target, remoteCommand, timeoutMs2 = 6e4) {
   return new Promise((resolve3) => {
     if (target.auth === "password" && !getSshPassword(target.id)) {
       resolve3({
@@ -38479,7 +38832,7 @@ function runSsh(target, remoteCommand, timeoutMs = 6e4) {
         stdout,
         stderr: stderr + "\n[ssh] timeout"
       });
-    }, timeoutMs);
+    }, timeoutMs2);
     child.on("error", (err) => {
       clearTimeout(timer);
       resolve3({
@@ -38708,7 +39061,7 @@ async function readChecks(cwd) {
     return [];
   }
 }
-function runShell(command, cwd, timeoutMs, signal) {
+function runShell(command, cwd, timeoutMs2, signal) {
   return new Promise((resolve3) => {
     const isWin = process.platform === "win32";
     const child = spawn10(isWin ? "cmd.exe" : "/bin/sh", isWin ? ["/c", command] : ["-c", command], {
@@ -38720,7 +39073,7 @@ function runShell(command, cwd, timeoutMs, signal) {
     let stdout = "";
     let stderr = "";
     let settled = false;
-    const finish = (exitCode) => {
+    const finish2 = (exitCode) => {
       if (settled) return;
       settled = true;
       resolve3({ exitCode, stdout, stderr });
@@ -38730,8 +39083,8 @@ function runShell(command, cwd, timeoutMs, signal) {
         child.kill("SIGTERM");
       } catch {
       }
-      finish(124);
-    }, timeoutMs);
+      finish2(124);
+    }, timeoutMs2);
     if (signal) {
       if (signal.aborted) {
         try {
@@ -38739,7 +39092,7 @@ function runShell(command, cwd, timeoutMs, signal) {
         } catch {
         }
         clearTimeout(timer);
-        finish(130);
+        finish2(130);
         return;
       }
       signal.addEventListener(
@@ -38750,7 +39103,7 @@ function runShell(command, cwd, timeoutMs, signal) {
           } catch {
           }
           clearTimeout(timer);
-          finish(130);
+          finish2(130);
         },
         { once: true }
       );
@@ -38765,11 +39118,11 @@ function runShell(command, cwd, timeoutMs, signal) {
     });
     child.on("error", () => {
       clearTimeout(timer);
-      finish(1);
+      finish2(1);
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      finish(code ?? 1);
+      finish2(code ?? 1);
     });
   });
 }
@@ -38791,9 +39144,9 @@ async function runBacktest(cwd, signal) {
   const results = [];
   for (const c of checks) {
     const expectExit = c.expectExit ?? 0;
-    const timeoutMs = c.timeoutMs ?? 12e4;
+    const timeoutMs2 = c.timeoutMs ?? 12e4;
     const start = Date.now();
-    const { exitCode, stdout, stderr } = await runShell(c.command, cwd, timeoutMs, signal);
+    const { exitCode, stdout, stderr } = await runShell(c.command, cwd, timeoutMs2, signal);
     const combined = `${stdout}${stderr}`;
     const preview = combined.slice(0, 400);
     let ok = exitCode === expectExit;
@@ -39077,7 +39430,7 @@ import path38 from "node:path";
 function trustStorePath() {
   return _overrideStorePath ?? path38.join(homedir8(), ".zelari-code", "trust.json");
 }
-function normalize3(p3) {
+function normalize4(p3) {
   const resolved = path38.resolve(p3);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
@@ -39114,14 +39467,14 @@ function isFolderTrusted(folderPath) {
   const env = envTrustedFolder();
   if (env === "all") return true;
   if (env === "none") return false;
-  if (env) return normalize3(env) === normalize3(folderPath);
-  const target = normalize3(folderPath);
-  return readStore3().folders.some((f) => normalize3(f.path) === target);
+  if (env) return normalize4(env) === normalize4(folderPath);
+  const target = normalize4(folderPath);
+  return readStore3().folders.some((f) => normalize4(f.path) === target);
 }
 function trustFolder(folderPath) {
   const store6 = readStore3();
   const normalized = path38.resolve(folderPath);
-  if (!store6.folders.some((f) => normalize3(f.path) === normalize3(normalized))) {
+  if (!store6.folders.some((f) => normalize4(f.path) === normalize4(normalized))) {
     store6.folders.push({ path: normalized, trustedAt: (/* @__PURE__ */ new Date()).toISOString() });
     writeStore3(store6);
   }
@@ -39129,9 +39482,9 @@ function trustFolder(folderPath) {
 }
 function untrustFolder(folderPath) {
   const store6 = readStore3();
-  const target = normalize3(folderPath);
+  const target = normalize4(folderPath);
   const before = store6.folders.length;
-  store6.folders = store6.folders.filter((f) => normalize3(f.path) !== target);
+  store6.folders = store6.folders.filter((f) => normalize4(f.path) !== target);
   if (store6.folders.length === before) return { ok: true, removed: false };
   writeStore3(store6);
   return { ok: true, removed: true };
@@ -39505,8 +39858,9 @@ function createBuiltinToolRegistry(options = {}) {
   if (hooks) registry4.setLifecycleHooks(hooks);
   const readOnly = options.readOnly === true || options.planMode === true || profile === "explore";
   const verifyMode = profile === "verify";
-  const allowMutators = !readOnly && !verifyMode;
-  const allowBash = allowMutators || verifyMode;
+  const gauntletParent = options.gauntletParent === true;
+  const allowMutators = !readOnly && !verifyMode && !gauntletParent;
+  const allowBash = (allowMutators || verifyMode) && !gauntletParent;
   const permPolicy = options.permissionPolicy ?? defaultPermissionPolicy();
   const withPerm = (t) => wrapWithPermissions(t, permPolicy, options.onPermissionAsk);
   registry4.register(withPerm(safeReadFile));
@@ -39539,21 +39893,21 @@ function createBuiltinToolRegistry(options = {}) {
   if (allowBash) {
     registry4.register(withPerm(safeBash));
   }
-  const askUserTool = options.readOnly === true || profile === "explore" || profile === "verify" ? null : createAskUserTool(options.onAskUser);
+  const askUserTool = options.readOnly === true || profile === "explore" || profile === "verify" || gauntletParent ? null : createAskUserTool(options.onAskUser);
   if (askUserTool) {
     registry4.register(withPerm(askUserTool));
   }
-  const enableSkill = options.enableSkill !== false && options.readOnly !== true && profile !== "explore" && profile !== "verify";
+  const enableSkill = options.enableSkill !== false && options.readOnly !== true && !gauntletParent && profile !== "explore" && profile !== "verify";
   const skillTool = enableSkill ? withPerm(createSkillTool({ cwd: root })) : null;
   if (skillTool) {
     registry4.register(skillTool);
   }
-  const enableTodos = options.enableTodos !== false && options.readOnly !== true && profile === "full";
+  const enableTodos = options.enableTodos !== false && options.readOnly !== true && !gauntletParent && profile === "full";
   const todoWrite = enableTodos ? withPerm(createTodoWriteTool()) : null;
   const todoRead = enableTodos ? withPerm(createTodoReadTool()) : null;
   if (todoWrite) registry4.register(todoWrite);
   if (todoRead) registry4.register(todoRead);
-  const enablePlanTasks = options.enablePlanTasks !== false && options.readOnly !== true && (profile === "full" || options.planMode === true) && profile !== "explore" && profile !== "verify" && profile !== "general";
+  const enablePlanTasks = options.enablePlanTasks !== false && options.readOnly !== true && !gauntletParent && (profile === "full" || options.planMode === true) && profile !== "explore" && profile !== "verify" && profile !== "general";
   const planTaskToolsWrapped = (enablePlanTasks ? createPlanTaskTools({ projectRoot: root, onTaskEvent: options.onTaskEvent }) : []).map((t) => withPerm(t));
   for (const t of planTaskToolsWrapped) {
     registry4.register(t);
@@ -39604,7 +39958,7 @@ function createBuiltinToolRegistry(options = {}) {
       permissions: semanticTool.permissions ?? []
     });
   }
-  if (!readOnly && process.env.ZELARI_BROWSER !== "0") {
+  if (!readOnly && !gauntletParent && process.env.ZELARI_BROWSER !== "0") {
     const browserTool = createBrowserTool();
     registry4.register(browserTool);
     tools.push({
@@ -39613,7 +39967,7 @@ function createBuiltinToolRegistry(options = {}) {
       permissions: browserTool.permissions ?? []
     });
   }
-  if (!readOnly && process.env.ZELARI_SSH !== "0") {
+  if (!readOnly && !gauntletParent && process.env.ZELARI_SSH !== "0") {
     for (const t of createSshTools()) {
       registry4.register(t);
       tools.push({
@@ -39623,7 +39977,7 @@ function createBuiltinToolRegistry(options = {}) {
       });
     }
   }
-  if (!readOnly) {
+  if (!readOnly && !gauntletParent) {
     for (const t of createWorldModelTools()) {
       const safe = wrapWithAudit(t, audit, sessionId2);
       registry4.register(safe);
@@ -39849,10 +40203,10 @@ function wrapWithDiagnostics(original, root, runner) {
       const filePath = value && typeof value === "object" && typeof value.path === "string" ? value.path : void 0;
       if (!filePath) return result;
       try {
-        const timeoutMs = Number(process.env.ZELARI_DIAGNOSTICS_TIMEOUT_MS) || 5e3;
+        const timeoutMs2 = Number(process.env.ZELARI_DIAGNOSTICS_TIMEOUT_MS) || 5e3;
         const diags = await runDiagnosticsForFile(filePath, {
           cwd: root,
-          timeoutMs,
+          timeoutMs: timeoutMs2,
           ...runner ? { runner } : {}
         });
         const formatted = formatDiagnostics(diags, { relativeTo: root });
@@ -40117,6 +40471,7 @@ function parseHeadlessFlags(argv) {
   let krakenGraph;
   let planOnly = process.env.ZELARI_KRAKEN_PLAN_ONLY === "1" || process.env.ZELARI_KRAKEN_PLAN_ONLY === "true";
   let runPlan = process.env.ZELARI_KRAKEN_RUN_PLAN;
+  let gauntlet = process.env.ZELARI_GAUNTLET === "1" || process.env.ZELARI_GAUNTLET === "true";
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     if (arg === "--headless") continue;
@@ -40287,6 +40642,10 @@ function parseHeadlessFlags(argv) {
     } else if (arg === "--run-plan") {
       runPlan = argv[i + 1];
       i++;
+    } else if (arg === "--gauntlet") {
+      gauntlet = true;
+    } else if (arg === "--no-gauntlet") {
+      gauntlet = false;
     }
   }
   if (councilFlag && !modeExplicit) {
@@ -40321,7 +40680,8 @@ function parseHeadlessFlags(argv) {
       ...strictDone ? { strictDone: true } : {},
       ...krakenGraph ? { krakenGraph } : {},
       ...planOnly ? { planOnly: true } : {},
-      ...runPlan ? { runPlan } : {}
+      ...runPlan ? { runPlan } : {},
+      ...gauntlet ? { gauntlet: true } : {}
     }
   };
 }
@@ -41632,10 +41992,10 @@ __export(claudeProvider_exports, {
   createLocalCliProvider: () => createLocalCliProvider
 });
 import { spawn as spawn11 } from "node:child_process";
-function waitForExit(child, timeoutMs = 2e3) {
+function waitForExit(child, timeoutMs2 = 2e3) {
   return new Promise((resolve3) => {
     if (child.exitCode != null) return resolve3(child.exitCode);
-    const timer = setTimeout(() => resolve3(child.exitCode ?? null), timeoutMs);
+    const timer = setTimeout(() => resolve3(child.exitCode ?? null), timeoutMs2);
     timer.unref?.();
     child.once("exit", (code) => {
       clearTimeout(timer);
@@ -43206,10 +43566,10 @@ function distTagForVersion(version2) {
 function registryUrlForTag(tag = distTagForVersion(getCurrentVersion())) {
   return `https://registry.npmjs.org/zelari-code/${tag}`;
 }
-async function fetchLatestVersion(fetcher = fetch, registryUrl = REGISTRY_URL, timeoutMs = 5e3) {
+async function fetchLatestVersion(fetcher = fetch, registryUrl = REGISTRY_URL, timeoutMs2 = 5e3) {
   try {
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const timer = setTimeout(() => controller.abort(), timeoutMs2);
     const response = await fetcher(registryUrl, { signal: controller.signal });
     clearTimeout(timer);
     if (!response.ok) {
@@ -43379,11 +43739,11 @@ var init_mcpClient = __esm({
        * Call a tool. Returns the concatenated text content; non-text content
        * items are summarized by type. Throws when the server flags isError.
        */
-      async callTool(name, args, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+      async callTool(name, args, timeoutMs2 = DEFAULT_REQUEST_TIMEOUT_MS) {
         const res = await this.request(
           "tools/call",
           { name, arguments: args },
-          timeoutMs
+          timeoutMs2
         );
         const text = (res.content ?? []).map(
           (c) => c.type === "text" && typeof c.text === "string" ? c.text : `[${c.type ?? "unknown"} content]`
@@ -43400,7 +43760,7 @@ var init_mcpClient = __esm({
         this.child = null;
       }
       // ── JSON-RPC plumbing ────────────────────────────────────────────────
-      request(method, params, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+      request(method, params, timeoutMs2 = DEFAULT_REQUEST_TIMEOUT_MS) {
         const child = this.child;
         if (!child)
           return Promise.reject(new Error(`[mcp:${this.serverName}] not started`));
@@ -43411,10 +43771,10 @@ var init_mcpClient = __esm({
             this.pending.delete(id);
             reject(
               new Error(
-                `[mcp:${this.serverName}] ${method} timed out after ${timeoutMs}ms`
+                `[mcp:${this.serverName}] ${method} timed out after ${timeoutMs2}ms`
               )
             );
-          }, timeoutMs);
+          }, timeoutMs2);
           this.pending.set(id, { resolve: resolve3, reject, timer });
           child.stdin.write(payload + "\n", (err) => {
             if (err) {
@@ -44488,7 +44848,7 @@ function pickSmokeScript(scripts) {
   }
   return null;
 }
-async function runProjectSmoke(projectRoot, timeoutMs = DEFAULT_TIMEOUT_MS3) {
+async function runProjectSmoke(projectRoot, timeoutMs2 = DEFAULT_TIMEOUT_MS3) {
   if (process.env["ZELARI_SMOKE"] === "0") {
     return { ran: false, reason: "ZELARI_SMOKE=0 (disabled)" };
   }
@@ -44521,7 +44881,7 @@ async function runProjectSmoke(projectRoot, timeoutMs = DEFAULT_TIMEOUT_MS3) {
     let stdout = "";
     let stderr = "";
     let settled = false;
-    const finish = (result) => {
+    const finish2 = (result) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
@@ -44529,15 +44889,15 @@ async function runProjectSmoke(projectRoot, timeoutMs = DEFAULT_TIMEOUT_MS3) {
     };
     const timer = setTimeout(() => {
       child.kill("SIGTERM");
-      finish({
+      finish2({
         ran: true,
         ok: false,
         script,
         exitCode: -1,
         output: stdout + stderr,
-        reason: `smoke timeout after ${timeoutMs}ms`
+        reason: `smoke timeout after ${timeoutMs2}ms`
       });
-    }, timeoutMs);
+    }, timeoutMs2);
     child.stdout?.on("data", (chunk) => {
       stdout += chunk.toString("utf8");
     });
@@ -44545,7 +44905,7 @@ async function runProjectSmoke(projectRoot, timeoutMs = DEFAULT_TIMEOUT_MS3) {
       stderr += chunk.toString("utf8");
     });
     child.on("error", (err) => {
-      finish({
+      finish2({
         ran: true,
         ok: false,
         script,
@@ -44557,7 +44917,7 @@ async function runProjectSmoke(projectRoot, timeoutMs = DEFAULT_TIMEOUT_MS3) {
     child.on("close", (code) => {
       const exitCode = code ?? -1;
       const ok = exitCode === 0;
-      finish({
+      finish2({
         ran: true,
         ok,
         script,
@@ -46166,7 +46526,7 @@ function startPermissionBroker(socketPath, handlers, opts) {
           const closeAll = server.closeAllConnections;
           if (typeof closeAll === "function") closeAll.call(server);
           let done = false;
-          const finish = () => {
+          const finish2 = () => {
             if (done) return;
             done = true;
             if (process.platform !== "win32") {
@@ -46175,8 +46535,8 @@ function startPermissionBroker(socketPath, handlers, opts) {
               res();
             }
           };
-          server.close(() => finish());
-          setTimeout(finish, 1e3).unref?.();
+          server.close(() => finish2());
+          setTimeout(finish2, 1e3).unref?.();
         })
       });
     });
@@ -46613,13 +46973,13 @@ async function createDefaultLlmClient(opts) {
   const llm = await resolveLlm(opts);
   return {
     async complete({ system, user }) {
-      const timeoutMs = resolvePlannerTimeoutMs();
+      const timeoutMs2 = resolvePlannerTimeoutMs();
       const controller = new AbortController();
       let timedOut = false;
-      const t = timeoutMs > 0 ? setTimeout(() => {
+      const t = timeoutMs2 > 0 ? setTimeout(() => {
         timedOut = true;
         controller.abort();
-      }, timeoutMs) : void 0;
+      }, timeoutMs2) : void 0;
       try {
         const url2 = `${llm.baseUrl.replace(/\/$/, "")}/chat/completions`;
         let res;
@@ -46645,7 +47005,7 @@ async function createDefaultLlmClient(opts) {
         } catch (err) {
           if (timedOut) {
             throw new PlannerTransportError(
-              `Planner request timed out after ${Math.round(timeoutMs / 1e3)}s (no response). Raise ZELARI_KRAKEN_PLANNER_TIMEOUT_MS, or set ZELARI_KRAKEN_PLANNER_MODEL to a faster non-reasoning model.`
+              `Planner request timed out after ${Math.round(timeoutMs2 / 1e3)}s (no response). Raise ZELARI_KRAKEN_PLANNER_TIMEOUT_MS, or set ZELARI_KRAKEN_PLANNER_MODEL to a faster non-reasoning model.`
             );
           }
           throw new PlannerTransportError(
@@ -47538,7 +47898,7 @@ var init_executor = __esm({
     DEFAULT_MAX_REVIEW_ROUNDS = 1;
     DEFAULT_GRAPH_TIMEOUT_MS = 0;
     DEFAULT_NODE_TIMEOUT_MS = 3e5;
-    DEFAULT_WRITER_NODE_TIMEOUT_MS = 9e5;
+    DEFAULT_WRITER_NODE_TIMEOUT_MS = TASK_TOOL_TIMEOUT_MS;
     DEFAULT_CANCEL_GRACE_MS = 3e4;
     MAX_UPSTREAM_CHARS_PER_DEP = 2800;
     MAX_UPSTREAM_CHARS_TOTAL = 8e3;
@@ -49028,10 +49388,10 @@ async function validateApiKey(providerId, apiKey, options = {}) {
     return { ok: true, skipped: true, reason: "no_base_url" };
   }
   const probeUrl = options.probeUrl ?? `${spec.baseUrl.replace(/\/+$/, "")}/models`;
-  const timeoutMs = options.timeoutMs ?? 5e3;
+  const timeoutMs2 = options.timeoutMs ?? 5e3;
   const fetchImpl = options.fetchImpl ?? fetch;
   const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const timer = setTimeout(() => controller.abort(), timeoutMs2);
   try {
     const response = await fetchImpl(probeUrl, {
       method: "GET",
@@ -49060,7 +49420,7 @@ async function validateApiKey(providerId, apiKey, options = {}) {
     return {
       ok: false,
       reason: isAbort ? "network" : "network",
-      detail: isAbort ? `timeout after ${timeoutMs}ms` : msg,
+      detail: isAbort ? `timeout after ${timeoutMs2}ms` : msg,
       durationMs
     };
   } finally {
@@ -49829,6 +50189,864 @@ var init_atMentions = __esm({
   }
 });
 
+// src/cli/gauntlet/policy.ts
+var policy_exports = {};
+__export(policy_exports, {
+  DEFAULT_MAX_PARALLEL: () => DEFAULT_MAX_PARALLEL2,
+  DEFAULT_MAX_PIECES: () => DEFAULT_MAX_PIECES,
+  DEFAULT_MAX_ROUNDS: () => DEFAULT_MAX_ROUNDS,
+  DEFAULT_WALL_MS: () => DEFAULT_WALL_MS,
+  GAUNTLET_PARENT_BLOCKED_TOOLS: () => GAUNTLET_PARENT_BLOCKED_TOOLS,
+  isGauntletFlagOn: () => isGauntletFlagOn,
+  resolveGauntletCaps: () => resolveGauntletCaps,
+  shouldRunGauntletHostLoop: () => shouldRunGauntletHostLoop
+});
+function envInt(raw, fallback, min, max) {
+  if (raw === void 0 || raw === "") return fallback;
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n)) return fallback;
+  return Math.min(max, Math.max(min, n));
+}
+function isGauntletFlagOn(explicit, env = process.env) {
+  if (explicit === true) return true;
+  if (explicit === false) return false;
+  const raw = env.ZELARI_GAUNTLET;
+  if (!raw) return false;
+  return raw === "1" || raw.toLowerCase() === "true";
+}
+function resolveGauntletCaps(env = process.env) {
+  const wallRaw = env.ZELARI_GAUNTLET_WALL_MS;
+  let wallClockMs = DEFAULT_WALL_MS;
+  if (wallRaw !== void 0 && wallRaw !== "") {
+    const n = Number.parseInt(wallRaw, 10);
+    if (Number.isFinite(n) && n >= 0) wallClockMs = n;
+  }
+  return {
+    maxPieces: envInt(env.ZELARI_GAUNTLET_MAX_PIECES, DEFAULT_MAX_PIECES, 1, 16),
+    maxRounds: envInt(env.ZELARI_GAUNTLET_MAX_ROUNDS, DEFAULT_MAX_ROUNDS, 1, 8),
+    maxParallel: envInt(env.ZELARI_GAUNTLET_MAX_PARALLEL, DEFAULT_MAX_PARALLEL2, 1, 4),
+    wallClockMs
+  };
+}
+function shouldRunGauntletHostLoop(opts) {
+  if (!isGauntletFlagOn(opts.gauntlet)) return false;
+  if (opts.krakenGraph) return false;
+  if (opts.useCouncil || opts.mode === "council" || opts.mode === "zelari") return false;
+  const phase2 = opts.phase ?? "build";
+  return phase2 !== "plan";
+}
+var DEFAULT_MAX_PIECES, DEFAULT_MAX_ROUNDS, DEFAULT_MAX_PARALLEL2, DEFAULT_WALL_MS, GAUNTLET_PARENT_BLOCKED_TOOLS;
+var init_policy = __esm({
+  "src/cli/gauntlet/policy.ts"() {
+    "use strict";
+    DEFAULT_MAX_PIECES = 6;
+    DEFAULT_MAX_ROUNDS = 3;
+    DEFAULT_MAX_PARALLEL2 = 2;
+    DEFAULT_WALL_MS = 45 * 60 * 1e3;
+    GAUNTLET_PARENT_BLOCKED_TOOLS = [
+      "write_file",
+      "edit_file",
+      "apply_diff",
+      "bash"
+    ];
+  }
+});
+
+// src/cli/gauntlet/complete.ts
+function timeoutMs(env = process.env) {
+  const raw = env.ZELARI_GAUNTLET_DECOMPOSE_TIMEOUT_MS;
+  if (raw === void 0 || raw === "") return DEFAULT_TIMEOUT_MS4;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n >= 0 ? n : DEFAULT_TIMEOUT_MS4;
+}
+async function gauntletComplete(args, opts) {
+  const provider = opts.provider;
+  const meta3 = await resolveApiKeyWithMeta(provider);
+  if (!meta3?.apiKey) {
+    throw new Error(`No API key for provider '${provider}'`);
+  }
+  const baseUrl = resolveBaseUrl(provider);
+  if (!baseUrl) {
+    throw new Error(`No base URL for provider '${provider}'`);
+  }
+  const model = process.env.ZELARI_KRAKEN_PLANNER_MODEL?.trim() || opts.model || getModelForProvider(provider) || getProviderConfig().modelByProvider[provider] || "";
+  if (!model) throw new Error(`No model for provider '${provider}'`);
+  const ms = timeoutMs();
+  const controller = new AbortController();
+  const onParentAbort = () => controller.abort();
+  opts.signal?.addEventListener("abort", onParentAbort, { once: true });
+  let timedOut = false;
+  const timer = ms > 0 ? setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, ms) : void 0;
+  try {
+    const url2 = `${baseUrl.replace(/\/$/, "")}/chat/completions`;
+    const res = await fetch(url2, {
+      method: "POST",
+      signal: controller.signal,
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${meta3.apiKey}`
+      },
+      body: JSON.stringify({
+        model,
+        temperature: 0.2,
+        max_tokens: DEFAULT_MAX_TOKENS,
+        stream: false,
+        messages: [
+          { role: "system", content: args.system },
+          { role: "user", content: args.user }
+        ]
+      })
+    });
+    if (!res.ok) {
+      const errBody = await res.text().catch(() => "");
+      throw new Error(`decompose HTTP ${res.status}${errBody ? `: ${errBody.slice(0, 160)}` : ""}`);
+    }
+    const json2 = await res.json();
+    const msg = json2.choices?.[0]?.message;
+    const text = msg?.content?.trim() || msg?.reasoning_content?.trim() || "";
+    if (!text) throw new Error("decompose: empty model response");
+    return text;
+  } catch (err) {
+    if (timedOut) {
+      throw new Error(
+        `decompose timed out after ${Math.round(ms / 1e3)}s \u2014 using a single piece. Raise ZELARI_GAUNTLET_DECOMPOSE_TIMEOUT_MS or set ZELARI_KRAKEN_PLANNER_MODEL to a fast model.`
+      );
+    }
+    throw err instanceof Error ? err : new Error(String(err));
+  } finally {
+    if (timer) clearTimeout(timer);
+    opts.signal?.removeEventListener("abort", onParentAbort);
+  }
+}
+var DEFAULT_TIMEOUT_MS4, DEFAULT_MAX_TOKENS;
+var init_complete = __esm({
+  "src/cli/gauntlet/complete.ts"() {
+    "use strict";
+    init_providerConfig();
+    init_keyStore();
+    init_openai_compatible();
+    DEFAULT_TIMEOUT_MS4 = 6e4;
+    DEFAULT_MAX_TOKENS = 2048;
+  }
+});
+
+// src/cli/gauntlet/decompose.ts
+function fallbackPieces(goal) {
+  const prompt = goal.trim() || "Complete the user Goal.";
+  return [
+    {
+      id: "g1",
+      label: labelFromGoal(prompt),
+      prompt,
+      acceptance: []
+    }
+  ];
+}
+function labelFromGoal(goal) {
+  const line = goal.trim().split(/\r?\n/, 1)[0] ?? "Goal";
+  return line.slice(0, MAX_LABEL) || "Goal";
+}
+function parsePiecesJson(raw, maxPieces) {
+  if (!raw || typeof raw !== "object") return null;
+  const rec = raw;
+  const list = rec.pieces ?? rec.nodes;
+  if (!Array.isArray(list) || list.length === 0) return null;
+  const out = [];
+  for (let i = 0; i < list.length && out.length < maxPieces; i++) {
+    const item = list[i];
+    if (!item || typeof item !== "object") continue;
+    const row = item;
+    const prompt = typeof row.prompt === "string" ? row.prompt.trim() : typeof row.goal === "string" ? row.goal.trim() : "";
+    if (!prompt) continue;
+    const id = typeof row.id === "string" && row.id.trim() ? row.id.trim().slice(0, 32) : `g${out.length + 1}`;
+    const label = typeof row.label === "string" && row.label.trim() ? row.label.trim().slice(0, MAX_LABEL) : labelFromGoal(prompt);
+    const acceptance = Array.isArray(row.acceptance) ? row.acceptance.filter((a) => typeof a === "string" && a.trim().length > 0).map((a) => a.trim()).slice(0, MAX_ACCEPTANCE) : [];
+    const scope = Array.isArray(row.scope) ? row.scope.filter((s) => typeof s === "string" && s.trim().length > 0).map((s) => s.trim()).slice(0, 16) : void 0;
+    const bar = Array.isArray(row.bar) ? row.bar.filter((s) => typeof s === "string" && s.trim().length > 0).map((s) => s.trim()).slice(0, 4) : void 0;
+    out.push({
+      id: uniqueId2(id, out),
+      label,
+      prompt: prompt.slice(0, MAX_PROMPT),
+      acceptance,
+      ...scope && scope.length > 0 ? { scope } : {},
+      ...bar && bar.length > 0 ? { bar } : {}
+    });
+  }
+  return out.length > 0 ? out : null;
+}
+function formatHistoryNote(messages, maxMessages = 4, each = 400) {
+  const slice = messages.filter((m) => m.role === "user" || m.role === "assistant").slice(-maxMessages);
+  if (slice.length === 0) return "";
+  return slice.map((m) => {
+    const body = m.content.replace(/\s+/g, " ").trim().slice(0, each);
+    return `${m.role}: ${body}`;
+  }).join("\n");
+}
+function buildDecomposeUser(opts) {
+  const parts = [
+    `Max pieces: ${opts.maxPieces}`,
+    "",
+    "## Goal",
+    opts.goal.trim() || "(empty)"
+  ];
+  if (opts.historyNote?.trim()) {
+    parts.push("", "## Prior turns (context only \u2014 the Goal above is authoritative)", opts.historyNote.trim());
+  }
+  if (opts.workspace?.trim()) {
+    parts.push("", "## Workspace", opts.workspace.trim());
+  }
+  return parts.join("\n");
+}
+function piecesFromModelText(text, maxPieces) {
+  try {
+    const json2 = extractJsonObject(text, { requireKey: "pieces" });
+    return parsePiecesJson(json2, maxPieces);
+  } catch {
+    return null;
+  }
+}
+async function decomposeGoal(opts) {
+  const fallback = fallbackPieces(opts.goal);
+  if (!opts.complete) return { pieces: fallback, source: "fallback" };
+  try {
+    const text = await opts.complete({
+      system: GAUNTLET_DECOMPOSE_SYSTEM,
+      user: buildDecomposeUser(opts)
+    });
+    const parsed = piecesFromModelText(text, opts.maxPieces);
+    if (parsed && parsed.length > 0) return { pieces: parsed, source: "llm" };
+    return { pieces: fallback, source: "fallback", error: "decompose JSON unusable" };
+  } catch (err) {
+    return {
+      pieces: fallback,
+      source: "fallback",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function uniqueId2(id, existing) {
+  if (!existing.some((p3) => p3.id === id)) return id;
+  let n = 2;
+  while (existing.some((p3) => p3.id === `${id}-${n}`)) n += 1;
+  return `${id}-${n}`;
+}
+var MAX_LABEL, MAX_PROMPT, MAX_ACCEPTANCE, GAUNTLET_DECOMPOSE_SYSTEM;
+var init_decompose = __esm({
+  "src/cli/gauntlet/decompose.ts"() {
+    "use strict";
+    init_planner();
+    MAX_LABEL = 80;
+    MAX_PROMPT = 8e3;
+    MAX_ACCEPTANCE = 8;
+    GAUNTLET_DECOMPOSE_SYSTEM = [
+      "Decompose the user Goal into independently shippable Gauntlet pieces.",
+      "Return ONLY JSON (no markdown, no prose):",
+      '{ "pieces": [ { "id": string, "label": string, "prompt": string, "scope"?: string[], "acceptance"?: string[], "bar"?: string[] } ] }',
+      "Rules:",
+      "- 1 to N pieces (N is given in the user message). Prefer fewer. One piece is valid when the goal is atomic.",
+      '- "prompt" is self-contained: the builder will not see this conversation.',
+      '- "scope" is a path allowlist so disjoint pieces can run in parallel. Omit if unsure (forces sequential).',
+      '- "acceptance" is checkable (file, command, observable). Never subjective ("elegant").',
+      '- "bar" (optional) is on-disk reference path(s) the critic compares against blindly (gold file, screenshot, test).',
+      "- Use paths from the workspace listing. Do not invent a tree.",
+      "- Decompose the USER GOAL literally. Do not enlarge it into a different project."
+    ].join("\n");
+  }
+});
+
+// src/cli/gauntlet/events.ts
+function gauntletProgressEvent(sessionId2, progress) {
+  return {
+    type: "gauntlet_progress",
+    sessionId: sessionId2,
+    ts: Date.now(),
+    progress
+  };
+}
+function formatGauntletSummary(results, opts) {
+  if (results.length === 0) {
+    if (opts?.timedOut) return "Gauntlet stopped: wall clock. No pieces finished.";
+    if (opts?.cancelled) return "Gauntlet cancelled. No pieces finished.";
+    return "Gauntlet: no pieces ran.";
+  }
+  const head = opts?.timedOut ? "Gauntlet stopped: wall clock." : opts?.cancelled ? "Gauntlet cancelled." : "Gauntlet finished.";
+  const lines = [head, ""];
+  for (const r of results) {
+    const gap = r.gap ? ` \u2014 ${r.gap}` : "";
+    const win = r.winner ? ` [A/B ${r.winner}]` : "";
+    lines.push(`- ${r.label} (${r.id}): ${r.verdict} after ${r.rounds} round(s)${win}${gap}`);
+  }
+  return lines.join("\n");
+}
+var init_events3 = __esm({
+  "src/cli/gauntlet/events.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/gauntlet/blind.ts
+function assignBlindLabels(items, rand = Math.random) {
+  if (rand() < 0.5) {
+    return { A: items[0], B: items[1], firstLabel: "A" };
+  }
+  return { A: items[1], B: items[0], firstLabel: "B" };
+}
+function qualityBarSection(bars, rand = Math.random) {
+  if (!bars || bars.length === 0) return "";
+  if (bars.length === 1) {
+    return [
+      "## Quality bar (blind)",
+      "Inspect this reference on disk. PASS only if the work in Scope meets or beats it.",
+      "Do not assume the new files are better \u2014 compare concretely.",
+      `- ${bars[0]}`
+    ].join("\n");
+  }
+  const pair = assignBlindLabels([bars[0], bars[1]], rand);
+  return [
+    "## Blind A/B",
+    "Two unlabeled artifacts on disk. Compare them against the piece acceptance.",
+    'Do not assume which is newer or which you are "supposed" to prefer.',
+    `A: ${pair.A}`,
+    `B: ${pair.B}`,
+    "Also emit: WINNER: A | B | TIE"
+  ].join("\n");
+}
+function parseBlindWinner(text) {
+  const m = WINNER_RE.exec(text);
+  if (!m) return void 0;
+  const v = m[1].toUpperCase();
+  if (v === "A" || v === "B" || v === "TIE") return v;
+  return void 0;
+}
+var WINNER_RE;
+var init_blind = __esm({
+  "src/cli/gauntlet/blind.ts"() {
+    "use strict";
+    WINNER_RE = /\bWINNER:\s*(A|B|TIE)\b/i;
+  }
+});
+
+// src/cli/gauntlet/verdict.ts
+function parseGauntletVerdict(text, opts = {}) {
+  const evidence = (opts.toolTraceCount ?? 0) > 0;
+  if (opts.builderFailed) {
+    return {
+      kind: "GAP",
+      gap: (opts.builderError ?? "builder failed").trim() || "builder failed",
+      evidence
+    };
+  }
+  const raw = (text ?? "").trim();
+  if (!raw) {
+    return { kind: "BLOCKED", gap: "critic produced no output", evidence };
+  }
+  const explicit = VERDICT_RE.exec(raw);
+  let kind = explicit ? explicit[1].toUpperCase() : void 0;
+  const reports = [...raw.matchAll(REPORT_STATUS_RE)].map((m) => m[1].toLowerCase());
+  const anyFail = reports.includes("fail");
+  const anyUnknown = reports.includes("unknown");
+  const anyPass = reports.includes("pass");
+  if (!kind) {
+    if (anyFail) kind = "GAP";
+    else if (anyPass && !anyUnknown) kind = "PASS";
+    else if (anyUnknown && !anyPass) kind = "BLOCKED";
+    else kind = "BLOCKED";
+  }
+  const gapMatch = GAP_RE.exec(raw);
+  let gap = gapMatch ? gapMatch[1].trim() : void 0;
+  if (kind === "GAP" && !gap) {
+    gap = anyFail ? "a verify-report check failed" : "critic named a gap without a GAP: line";
+  }
+  if (kind === "PASS" && !evidence) {
+    return {
+      kind: "GAP",
+      gap: "unknown \u2260 pass: critic declared PASS without tool evidence",
+      evidence: false
+    };
+  }
+  if (kind === "PASS" && anyFail) {
+    return {
+      kind: "GAP",
+      gap: gap ?? "verify-report contains a fail",
+      evidence
+    };
+  }
+  return { kind, ...gap ? { gap } : {}, evidence };
+}
+var VERDICT_RE, GAP_RE, REPORT_STATUS_RE;
+var init_verdict2 = __esm({
+  "src/cli/gauntlet/verdict.ts"() {
+    "use strict";
+    VERDICT_RE = /\bVERDICT:\s*(PASS|GAP|BLOCKED)\b/i;
+    GAP_RE = /\bGAP:\s*(.+)/i;
+    REPORT_STATUS_RE = /^status:\s*(pass|fail|unknown)\b/gim;
+  }
+});
+
+// src/cli/gauntlet/prompts.ts
+function builderUserPrompt(piece, gap, briefing) {
+  const parts = [
+    `You are the BUILDER for one Gauntlet piece. Implement it on disk.`,
+    `Do not spawn sub-agents. Stay inside Scope if provided.`
+  ];
+  if (briefing?.trim()) {
+    parts.push("", "## Workspace briefing (do not treat as already-done work)", briefing.trim());
+  }
+  parts.push("", `## Piece: ${piece.label}`, piece.prompt.trim());
+  if (piece.scope && piece.scope.length > 0) {
+    parts.push("", "## Scope", ...piece.scope.map((s) => `- ${s}`));
+  }
+  if (piece.acceptance.length > 0) {
+    parts.push("", "## Acceptance", ...piece.acceptance.map((a) => `- ${a}`));
+  }
+  if (gap && gap.trim()) {
+    parts.push(
+      "",
+      "## Previous critic GAP (fix ONLY this)",
+      gap.trim(),
+      "Do not widen scope. Re-check the acceptance after the fix."
+    );
+  }
+  parts.push("", "Return: files touched, what changed, residual risks.");
+  return parts.join("\n");
+}
+function criticUserPrompt(piece, round, rand) {
+  const parts = [
+    `Round ${round}. Inspect the current tree against this piece.`,
+    "Do not edit files. Do not take the builder's word \u2014 open files / run checks.",
+    "",
+    `## Piece: ${piece.label}`,
+    piece.prompt.trim()
+  ];
+  if (piece.scope && piece.scope.length > 0) {
+    parts.push("", "## Scope", ...piece.scope.map((s) => `- ${s}`));
+  }
+  if (piece.acceptance.length > 0) {
+    parts.push("", "## Acceptance (check each)", ...piece.acceptance.map((a) => `- ${a}`));
+  } else {
+    parts.push(
+      "",
+      "## Acceptance",
+      "- The piece prompt is satisfied by files on disk.",
+      "- Relevant typecheck/tests pass when the project has them."
+    );
+  }
+  const bar = qualityBarSection(piece.bar, rand);
+  if (bar) parts.push("", bar);
+  return parts.join("\n");
+}
+var GAUNTLET_CRITIC_SYSTEM;
+var init_prompts = __esm({
+  "src/cli/gauntlet/prompts.ts"() {
+    "use strict";
+    init_blind();
+    GAUNTLET_CRITIC_SYSTEM = [
+      "You are a ruthless VERIFY critic in a Gauntlet Loop.",
+      "Inspect the REAL files and commands on disk. Do not trust a builder self-report.",
+      "You have no builder transcript \u2014 only the Goal, Scope, Acceptance, and the tree.",
+      "OBSERVATION INTEGRITY: unknown \u2260 pass. EMPTY/degraded tools are not evidence.",
+      "Name at most ONE biggest remaining gap. Do not write a laundry list.",
+      "You may read files and run test/build commands via bash. Prefer targeted checks.",
+      "",
+      "End with BOTH:",
+      "1. One <verify-report> block per acceptance criterion:",
+      "<verify-report>",
+      "check: <criterion text as given>",
+      "status: pass | fail | unknown",
+      "note: <one line of evidence (command or file + outcome)>",
+      "</verify-report>",
+      "2. A trailer on its own lines:",
+      "VERDICT: PASS | GAP | BLOCKED",
+      "GAP: <single biggest remaining gap; omit on PASS>",
+      "3. If a Blind A/B section is present, also emit WINNER: A | B | TIE"
+    ].join("\n");
+  }
+});
+
+// src/cli/gauntlet/schedule.ts
+function piecesCanRunInParallel(a, b) {
+  return disjointScopeSets(a.scope, b.scope);
+}
+function scheduleWaves(pieces, maxParallel) {
+  const cap3 = Math.max(1, maxParallel);
+  const remaining = [...pieces];
+  const waves = [];
+  while (remaining.length > 0) {
+    const wave = [];
+    const leftover = [];
+    for (const p3 of remaining) {
+      if (wave.length >= cap3) {
+        leftover.push(p3);
+        continue;
+      }
+      if (wave.length === 0 || wave.every((w) => piecesCanRunInParallel(w, p3))) {
+        wave.push(p3);
+      } else {
+        leftover.push(p3);
+      }
+    }
+    waves.push(wave);
+    remaining.splice(0, remaining.length, ...leftover);
+  }
+  return waves;
+}
+var init_schedule = __esm({
+  "src/cli/gauntlet/schedule.ts"() {
+    "use strict";
+    init_dist();
+  }
+});
+
+// src/cli/gauntlet/loop.ts
+async function runGauntletLoop(args) {
+  const { caps, deps } = args;
+  const pieces = args.pieces.slice(0, caps.maxPieces);
+  const started = (deps.now ?? Date.now)();
+  const results = [];
+  const emitProgress = (partial2) => {
+    const progress = {
+      ...partial2,
+      elapsedMs: (deps.now ?? Date.now)() - started
+    };
+    deps.emit(gauntletProgressEvent(deps.sessionId, progress));
+    deps.note?.("gauntlet.progress", progress);
+  };
+  const wall = caps.wallClockMs === void 0 ? DEFAULT_WALL_MS : caps.wallClockMs;
+  const expired = () => wall > 0 && (deps.now ?? Date.now)() - started >= wall;
+  const aborted2 = () => Boolean(deps.signal?.aborted);
+  const stop = () => aborted2() || expired();
+  const indexOf = (piece) => pieces.findIndex((p3) => p3.id === piece.id);
+  const runOnePiece = async (piece) => {
+    let last = {
+      kind: "BLOCKED",
+      gap: "no round ran",
+      evidence: false
+    };
+    let gap;
+    let winner;
+    let rounds = 0;
+    const i = Math.max(0, indexOf(piece));
+    for (let round = 1; round <= caps.maxRounds; round++) {
+      if (stop()) break;
+      rounds = round;
+      const phase2 = gap ? "repairing" : "building";
+      emitProgress({
+        phase: phase2,
+        pieceId: piece.id,
+        pieceLabel: piece.label,
+        pieceIndex: i,
+        pieceCount: pieces.length,
+        round,
+        maxRounds: caps.maxRounds
+      });
+      const built = await deps.runBuilder({
+        piece,
+        prompt: builderUserPrompt(piece, gap, deps.briefing),
+        round
+      });
+      if (stop()) break;
+      emitProgress({
+        phase: "critiquing",
+        pieceId: piece.id,
+        pieceLabel: piece.label,
+        pieceIndex: i,
+        pieceCount: pieces.length,
+        round,
+        maxRounds: caps.maxRounds
+      });
+      const criticized = await deps.runCritic({
+        piece,
+        prompt: criticUserPrompt(piece, round),
+        systemPrompt: GAUNTLET_CRITIC_SYSTEM,
+        round
+      });
+      last = parseGauntletVerdict(criticized.result, {
+        toolTraceCount: criticized.toolTraceCount ?? 0,
+        builderFailed: !built.ok,
+        builderError: built.error
+      });
+      winner = parseBlindWinner(criticized.result) ?? winner;
+      emitProgress({
+        phase: last.kind === "PASS" ? "settled" : last.kind === "BLOCKED" ? "blocked" : "repairing",
+        pieceId: piece.id,
+        pieceLabel: piece.label,
+        pieceIndex: i,
+        pieceCount: pieces.length,
+        round,
+        maxRounds: caps.maxRounds,
+        verdict: last.kind,
+        gap: last.gap,
+        winner
+      });
+      if (last.kind === "PASS" || last.kind === "BLOCKED") break;
+      gap = last.gap;
+    }
+    return {
+      id: piece.id,
+      label: piece.label,
+      verdict: last,
+      rounds,
+      ...winner ? { winner } : {}
+    };
+  };
+  for (const wave of scheduleWaves(pieces, caps.maxParallel)) {
+    if (stop()) return finish(results, { cancelled: aborted2(), timedOut: expired() });
+    if (wave.length === 1) {
+      results.push(await runOnePiece(wave[0]));
+    } else {
+      const waveResults = await Promise.all(wave.map((p3) => runOnePiece(p3)));
+      results.push(...waveResults);
+    }
+    if (stop()) return finish(results, { cancelled: aborted2(), timedOut: expired() });
+  }
+  return finish(results, { cancelled: aborted2(), timedOut: expired() });
+}
+function finish(results, flags) {
+  const cancelled = flags.timedOut ? false : flags.cancelled;
+  const timedOut = flags.timedOut;
+  const settled = !cancelled && !timedOut && results.length > 0 && results.every((r) => r.verdict.kind === "PASS");
+  return {
+    settled,
+    cancelled,
+    timedOut,
+    pieces: results,
+    summary: formatGauntletSummary(
+      results.map((r) => ({
+        id: r.id,
+        label: r.label,
+        verdict: r.verdict.kind,
+        rounds: r.rounds,
+        gap: r.verdict.gap,
+        winner: r.winner
+      })),
+      { timedOut, cancelled }
+    )
+  };
+}
+var init_loop = __esm({
+  "src/cli/gauntlet/loop.ts"() {
+    "use strict";
+    init_blind();
+    init_policy();
+    init_verdict2();
+    init_prompts();
+    init_schedule();
+    init_events3();
+  }
+});
+
+// src/cli/gauntlet/run.ts
+var run_exports = {};
+__export(run_exports, {
+  runHeadlessGauntlet: () => runHeadlessGauntlet
+});
+async function runHeadlessGauntlet(opts, provider, model) {
+  const sessionId2 = opts.resumeSessionId ?? crypto.randomUUID();
+  const spine = await openHeadlessSpine({
+    sessionId: sessionId2,
+    mode: opts.mode,
+    profile: opts.profile,
+    workspace: process.cwd()
+  });
+  emitEvent(sessionStartedEvent(spine));
+  const seeded = await seedHeadlessModelHistory(spine, opts.history);
+  if (opts.task) spine.userMessage(opts.task);
+  spine.note("gauntlet.start", { goal: opts.task.slice(0, 200) });
+  const abort = new AbortController();
+  const onSigint = () => {
+    emitEvent({ type: "log", message: "[gauntlet] SIGINT \u2014 cancelling" });
+    abort.abort();
+  };
+  process.once("SIGINT", onSigint);
+  const wallMs = resolveGauntletCaps().wallClockMs ?? 0;
+  const wallTimer = wallMs > 0 ? setTimeout(() => {
+    emitEvent({ type: "log", message: "[gauntlet] wall clock \u2014 aborting tentacles" });
+    abort.abort();
+  }, wallMs) : void 0;
+  const cwd = process.cwd();
+  const audit = new AuditLogger();
+  const createSubAgentContext = createKrakenSubAgentContextFactory({
+    root: cwd,
+    audit,
+    sessionId: sessionId2,
+    provider,
+    model
+  });
+  const deps = {
+    createSubAgentContext,
+    allowWorktree: false,
+    harnessFactory: (config2) => {
+      const harness = new AgentHarness(config2);
+      return {
+        async *run() {
+          for await (const ev of harness.run()) {
+            if (ev.type === "thinking_delta" || ev.type === "tool_execution_start" || ev.type === "tool_execution_end") {
+              emitEvent(ev);
+              spine.observe(ev);
+            }
+            yield ev;
+          }
+        },
+        cancel: () => harness.cancel()
+      };
+    }
+  };
+  const emit = (event) => {
+    if (opts.output === "json") emitEvent(event);
+    else if (typeof event.message === "string") {
+      process.stderr.write(`${event.message}
+`);
+    }
+  };
+  emitEvent({ type: "agent_start", model, provider, role: "gauntlet" });
+  emit({ type: "log", message: "[gauntlet] host loop \u2014 builder/critic rounds, parent cannot write" });
+  const caps = resolveGauntletCaps();
+  const workspace = buildWorkspaceSummary(cwd, { maxChars: 2500 });
+  const historyNote = formatHistoryNote(seeded.history);
+  emitEvent(
+    gauntletProgressEvent(sessionId2, {
+      phase: "decomposing",
+      pieceId: "",
+      pieceLabel: "Goal",
+      pieceIndex: 0,
+      pieceCount: 1,
+      round: 0,
+      maxRounds: caps.maxRounds,
+      elapsedMs: 0
+    })
+  );
+  try {
+    const decomposed = await decomposeGoal({
+      goal: opts.task,
+      maxPieces: caps.maxPieces,
+      workspace,
+      historyNote,
+      complete: (req) => gauntletComplete(req, { provider, model, signal: abort.signal })
+    });
+    spine.note("gauntlet.decompose", {
+      source: decomposed.source,
+      count: decomposed.pieces.length,
+      ...decomposed.error ? { error: decomposed.error.slice(0, 240) } : {}
+    });
+    emit({
+      type: "log",
+      message: `[gauntlet] ${decomposed.pieces.length} piece(s) from ${decomposed.source}${decomposed.error ? ` (${decomposed.error.slice(0, 80)})` : ""}`
+    });
+    const result = await runGauntletLoop({
+      pieces: decomposed.pieces,
+      caps,
+      deps: {
+        sessionId: sessionId2,
+        signal: abort.signal,
+        emit,
+        briefing: workspace.slice(0, 1200),
+        note: (text, data) => spine.note(text, data),
+        runBuilder: async ({ piece, prompt, round }) => {
+          emit({
+            type: "log",
+            message: `[gauntlet] ${piece.id} round ${round}/${caps.maxRounds} builder`
+          });
+          const tent = await runTentacle({
+            deps,
+            agent: "general",
+            thoroughness: "medium",
+            parentCwd: cwd,
+            sessionId: sessionId2,
+            signal: abort.signal,
+            args: {
+              description: `gauntlet-builder ${piece.id} r${round}`,
+              prompt,
+              ...piece.scope ? { scope: piece.scope } : {},
+              ...piece.acceptance.length > 0 ? { acceptance: piece.acceptance } : {}
+            }
+          });
+          if (!tent.ok) return { ok: false, result: "", error: tent.error };
+          return {
+            ok: true,
+            result: tent.result,
+            toolTraceCount: tent.toolTrace?.length ?? 0
+          };
+        },
+        runCritic: async ({ piece, prompt, systemPrompt, round }) => {
+          emit({
+            type: "log",
+            message: `[gauntlet] ${piece.id} round ${round}/${caps.maxRounds} critic`
+          });
+          const tent = await runTentacle({
+            deps,
+            agent: "verify",
+            thoroughness: "medium",
+            parentCwd: cwd,
+            sessionId: sessionId2,
+            signal: abort.signal,
+            systemPromptOverride: systemPrompt,
+            args: {
+              description: `gauntlet-critic ${piece.id} r${round}`,
+              prompt,
+              ...piece.scope ? { scope: piece.scope } : {},
+              ...piece.acceptance.length > 0 ? { acceptance: piece.acceptance } : {}
+            }
+          });
+          if (!tent.ok) {
+            return { ok: false, result: tent.error, error: tent.error, toolTraceCount: 0 };
+          }
+          return {
+            ok: true,
+            result: tent.result,
+            toolTraceCount: tent.toolTrace?.length ?? 0
+          };
+        }
+      }
+    });
+    emitEvent({ type: "message_start", role: "assistant" });
+    emitEvent({ type: "message_delta", delta: result.summary });
+    emitEvent({ type: "message_end", totalLength: result.summary.length });
+    emitEvent({
+      type: "agent_end",
+      reason: result.cancelled || result.timedOut ? "cancelled" : result.settled ? "completed" : "error"
+    });
+    if (result.timedOut) {
+      emit({ type: "log", message: `[gauntlet] wall clock (${Math.round(wallMs / 6e4)}m)` });
+      await spine.interrupt("gauntlet-wall-clock");
+      return 1;
+    }
+    if (result.cancelled) {
+      await spine.interrupt("gauntlet-cancelled");
+      return 1;
+    }
+    await spine.close(result.settled ? "gauntlet-pass" : "gauntlet-incomplete");
+    return result.settled ? 0 : 3;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    emitEvent({ type: "error", severity: "fatal", message: msg, code: "gauntlet" });
+    await spine.interrupt(`gauntlet-error: ${msg}`).catch(() => void 0);
+    return 2;
+  } finally {
+    if (wallTimer) clearTimeout(wallTimer);
+    process.removeListener("SIGINT", onSigint);
+  }
+}
+var init_run = __esm({
+  "src/cli/gauntlet/run.ts"() {
+    "use strict";
+    init_harness();
+    init_headless();
+    init_headlessSpine();
+    init_auditLogger();
+    init_toolRegistry();
+    init_taskTool();
+    init_complete();
+    init_decompose();
+    init_events3();
+    init_loop();
+    init_policy();
+    init_workspaceSummary();
+  }
+});
+
 // src/cli/triggerLock.ts
 var triggerLock_exports = {};
 __export(triggerLock_exports, {
@@ -50603,7 +51821,7 @@ function startPermissionMcpServer(opts) {
     }
     return { error: { code: -32601, message: `method not found: ${method}` } };
   }
-  async function callApprove(args, timeoutMs) {
+  async function callApprove(args, timeoutMs2) {
     const toolName = typeof args.tool_name === "string" ? args.tool_name : "";
     if (!toolName) {
       return { error: { code: -32602, message: "approve requires a string tool_name" } };
@@ -50622,7 +51840,7 @@ function startPermissionMcpServer(opts) {
           toolUseId: typeof args.tool_use_id === "string" ? args.tool_use_id : void 0,
           suggestions
         },
-        { requestTimeoutMs: timeoutMs }
+        { requestTimeoutMs: timeoutMs2 }
       );
       const result = res.behavior === "allow" ? {
         behavior: "allow",
@@ -50642,7 +51860,7 @@ function startPermissionMcpServer(opts) {
       );
     }
   }
-  async function callAskUser(args, timeoutMs) {
+  async function callAskUser(args, timeoutMs2) {
     const question = typeof args.question === "string" ? args.question : "";
     if (!question) {
       return { error: { code: -32602, message: "ask_user requires a string question" } };
@@ -50660,7 +51878,7 @@ function startPermissionMcpServer(opts) {
           choices,
           context
         },
-        { requestTimeoutMs: timeoutMs }
+        { requestTimeoutMs: timeoutMs2 }
       );
       const text = res.behavior === "allow" && typeof res.answer === "string" ? res.answer : res.message ?? "No answer was given \u2014 use your best judgment.";
       return textResult(text);
@@ -55508,8 +56726,8 @@ async function readPackageScripts(cwd = process.cwd()) {
     return {};
   }
 }
-function buildNativeCriteria(commands, timeoutMs) {
-  const pack = codingCriteriaPack({ ...commands, commandTimeoutMs: timeoutMs });
+function buildNativeCriteria(commands, timeoutMs2) {
+  const pack = codingCriteriaPack({ ...commands, commandTimeoutMs: timeoutMs2 });
   return pack.criteria.filter(
     (c) => !(c.required && (!c.check || c.check.kind === "none"))
   );
@@ -55543,11 +56761,11 @@ function criterionId(check2, index) {
   const slug = check2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
   return `check-${index + 1}-${slug || "criterion"}`;
 }
-function normalize4(text) {
+function normalize5(text) {
   return text.toLowerCase().replace(/\s+/g, " ").trim();
 }
 function matchResult(check2, byNormalized) {
-  const norm = normalize4(check2);
+  const norm = normalize5(check2);
   const direct = byNormalized.get(norm);
   if (direct) return direct;
   for (const key of byNormalized.keys()) {
@@ -55559,7 +56777,7 @@ function matchResult(check2, byNormalized) {
 }
 function krakenResultsToContract(requiredChecks, results, now = Date.now()) {
   const byNormalized = /* @__PURE__ */ new Map();
-  for (const r of results ?? []) byNormalized.set(normalize4(r.check), r);
+  for (const r of results ?? []) byNormalized.set(normalize5(r.check), r);
   const criteria = [];
   const verifications = [];
   requiredChecks.forEach((check2, i) => {
@@ -55595,16 +56813,16 @@ function sha256Hex2(input) {
   return createHash10("sha256").update(input).digest("hex");
 }
 function matchNoteToToolTrace(note, trace) {
-  const n = normalize4(note);
+  const n = normalize5(note);
   if (!n) return null;
   for (let i = trace.length - 1; i >= 0; i--) {
     const t = trace[i];
-    const cmd = t.command ? normalize4(t.command) : "";
+    const cmd = t.command ? normalize5(t.command) : "";
     if (cmd.length >= 4 && (n.includes(cmd) || cmd.includes(n))) return t;
   }
   for (let i = trace.length - 1; i >= 0; i--) {
     const t = trace[i];
-    const out = normalize4(t.output);
+    const out = normalize5(t.output);
     if (!out) continue;
     if (n.length >= 8 && out.includes(n)) return t;
     const fragments = n.match(/\S*\d[\d.,/%]*\S*/g) ?? [];
@@ -55811,7 +57029,7 @@ ${detail}
     let settled = false;
     const askTimeoutMs = askUserTimeoutMs();
     let cancelAskTimeout = () => void 0;
-    const finish = (ok, note) => {
+    const finish2 = (ok, note) => {
       if (settled) return;
       settled = true;
       cancelAskTimeout();
@@ -55820,7 +57038,7 @@ ${detail}
       resolve3(ok);
     };
     cancelAskTimeout = armPickerTimeout(
-      () => finish(
+      () => finish2(
         false,
         `[permission] ask for "${req.toolName}" timed out after ${Math.round(
           askTimeoutMs / 1e3
@@ -55849,12 +57067,12 @@ ${detail}
       onAnswer: (value) => {
         const v = value.trim().toLowerCase();
         if (v === "deny" || v.startsWith("deny")) {
-          finish(false);
+          finish2(false);
           return;
         }
         if (v === "always-tool" || v.includes("always") && v.includes("tool")) {
           grantSessionTool(req.toolName);
-          finish(
+          finish2(
             true,
             `[permission] Granted "${req.toolName}" for this session (tool).`
           );
@@ -55863,19 +57081,19 @@ ${detail}
         if (v === "always-cat" || v.includes("always") && !v.includes("tool")) {
           for (const c of cats) grantSessionCategory(c);
           grantSessionTool(req.toolName);
-          finish(
+          finish2(
             true,
             `[permission] Granted ${catLabel} (+ ${req.toolName}) for this session.`
           );
           return;
         }
         if (v === "allow" || v.startsWith("allow") || v === "yes" || v === "y" || v === "1") {
-          finish(true);
+          finish2(true);
           return;
         }
-        finish(false);
+        finish2(false);
       },
-      onCancel: () => finish(false)
+      onCancel: () => finish2(false)
     });
   });
 }
@@ -56194,7 +57412,7 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
           let settled = false;
           const askTimeoutMs = askUserTimeoutMs();
           let cancelAskTimeout = () => void 0;
-          const finish = (value) => {
+          const finish2 = (value) => {
             if (settled) return;
             settled = true;
             cancelAskTimeout();
@@ -56210,7 +57428,7 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
                 )}s \u2014 proseguo con assunzione documentata (ZELARI_ASK_USER_TIMEOUT_MS).`,
                 Date.now()
               );
-              finish(null);
+              finish2(null);
             },
             askTimeoutMs
           );
@@ -56218,8 +57436,8 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
             kind: "clarification",
             title: req.question,
             items: choices.map((c) => ({ value: c, label: c })),
-            onAnswer: (value) => finish(value),
-            onCancel: () => finish(null)
+            onAnswer: (value) => finish2(value),
+            onCancel: () => finish2(null)
           });
         }) : void 0;
         const onPermissionAsk = setPicker2 ? createPermissionAskHandler({
@@ -57008,7 +58226,7 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il membro riprende dop
     let settled = false;
     const askTimeoutMs = askUserTimeoutMs();
     let cancelAskTimeout = () => void 0;
-    const finish = (value) => {
+    const finish2 = (value) => {
       if (settled) return;
       settled = true;
       cancelAskTimeout();
@@ -57024,7 +58242,7 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il membro riprende dop
           )}s \u2014 il membro prosegue con assunzione documentata (ZELARI_ASK_USER_TIMEOUT_MS).`,
           Date.now()
         );
-        finish(null);
+        finish2(null);
       },
       askTimeoutMs
     );
@@ -57032,8 +58250,8 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il membro riprende dop
       kind: "clarification",
       title: req.question,
       items: choices.map((c) => ({ value: c, label: c })),
-      onAnswer: (value) => finish(value),
-      onCancel: () => finish(null)
+      onAnswer: (value) => finish2(value),
+      onCancel: () => finish2(null)
     });
   }) : void 0;
   let phaseRunMode = overrides.runMode ?? (workPhase === "plan" ? "design-phase" : "implementation");
@@ -57177,7 +58395,7 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il membro riprende dop
           Date.now()
         );
         let settled = false;
-        const finish = (value) => {
+        const finish2 = (value) => {
           if (settled) return;
           settled = true;
           setPicker2(null);
@@ -57187,8 +58405,8 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il membro riprende dop
           kind: "clarification",
           title: req.question,
           items: choices.map((c) => ({ value: c, label: c })),
-          onAnswer: (value) => finish(value),
-          onCancel: () => finish(null)
+          onAnswer: (value) => finish2(value),
+          onCancel: () => finish2(null)
         });
       }) : void 0
     })) {
@@ -57793,7 +59011,7 @@ function usePermissionBroker(opts) {
       }
       let settled = false;
       let cancelWaitTimeout;
-      const finish = (value) => {
+      const finish2 = (value) => {
         if (settled) return;
         settled = true;
         cancelWaitTimeout?.();
@@ -57809,7 +59027,7 @@ function usePermissionBroker(opts) {
           )}s \u2014 richiesta annullata.`,
           Date.now()
         );
-        finish(null);
+        finish2(null);
       }, waitTimeoutMs);
       appendSystem(
         setMessages,
@@ -57821,8 +59039,8 @@ function usePermissionBroker(opts) {
         kind: "clarification",
         title: req.question,
         items: choices.map((c) => ({ value: c, label: c })),
-        onAnswer: (value) => finish(value),
-        onCancel: () => finish(null)
+        onAnswer: (value) => finish2(value),
+        onCancel: () => finish2(null)
       });
     });
     void startPermissionBroker(socketPath, {
@@ -61927,7 +63145,7 @@ function verifierReviewEnabled(selection = loadVerifierModelSelection(), env = p
   if (v === "1" || v === "true" || v === "on") return true;
   return selection.mode === "fixed";
 }
-function makeVerifierCallModel(loadStream, identity, timeoutMs = 12e4) {
+function makeVerifierCallModel(loadStream, identity, timeoutMs2 = 12e4) {
   return async ({ system, user }) => {
     const stream = await loadStream(identity.provider, identity.model);
     if (!stream) {
@@ -61941,7 +63159,7 @@ function makeVerifierCallModel(loadStream, identity, timeoutMs = 12e4) {
       model: identity.model,
       provider: identity.provider,
       tools: [],
-      signal: AbortSignal.timeout(timeoutMs)
+      signal: AbortSignal.timeout(timeoutMs2)
     });
     return { text, provider: identity.provider, model: identity.model };
   };
@@ -62098,6 +63316,18 @@ ${err.stack}` : "";
   if (opts.krakenGraph) {
     return runHeadlessKrakenGraph(opts, provider, model);
   }
+  const { shouldRunGauntletHostLoop: shouldRunGauntletHostLoop2 } = await Promise.resolve().then(() => (init_policy(), policy_exports));
+  if (shouldRunGauntletHostLoop2(opts)) {
+    const { runHeadlessGauntlet: runHeadlessGauntlet2 } = await Promise.resolve().then(() => (init_run(), run_exports));
+    return runHeadlessGauntlet2(opts, provider, model);
+  }
+  if (opts.gauntlet) {
+    const why = opts.krakenGraph ? "kraken-graph owns dispatch" : (opts.phase ?? "build") === "plan" ? "PLAN is already write-stripped; host loop is BUILD-only" : "mode is not kraken-build";
+    const line = `[gauntlet] flag set but host loop skipped (${why})`;
+    if (opts.output === "json") emitEvent({ type: "log", message: line });
+    else process.stderr.write(`[zelari-code --headless] ${line}
+`);
+  }
   if (mode === "zelari") {
     return runHeadlessZelari(opts, provider, model, providerStream);
   }
@@ -62314,6 +63544,7 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
   resetKrakenTurnMetrics();
   const { registry: toolRegistry } = createBuiltinToolRegistry({
     planMode: planModeFromOpts(opts),
+    gauntletParent: Boolean(opts.gauntlet) && !planModeFromOpts(opts),
     // Fase 1 (ADR-0020): anchor tentacles to the provider/model THIS run
     // resolved (--provider/--model opts or Desktop's selector), mirroring
     // what the kraken-graph path already does for its executor.