zelari-code 2.3.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;
@@ -19419,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 {
@@ -23327,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)}`);
@@ -23345,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,
@@ -23357,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();
           });
@@ -23384,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",
@@ -27962,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) {
@@ -27982,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
   };
@@ -27992,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");
@@ -29237,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";
@@ -29260,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"));
           });
@@ -30198,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",
@@ -33281,7 +33281,7 @@ var init_registry2 = __esm({
         if (!parsed.success) {
           return typedErr(`Invalid input: ${parsed.error.message}`);
         }
-        const timeoutMs = options.timeoutMs ?? tool.timeoutMs ?? 3e4;
+        const timeoutMs2 = options.timeoutMs ?? tool.timeoutMs ?? 3e4;
         const parentSignal = options.signal;
         const controller = new AbortController();
         let timer;
@@ -33331,8 +33331,8 @@ var init_registry2 = __esm({
               timer = setTimeout(() => {
                 if (!controller.signal.aborted)
                   controller.abort();
-                reject(new Error(`Tool "${name}" timed out after ${timeoutMs}ms`));
-              }, timeoutMs);
+                reject(new Error(`Tool "${name}" timed out after ${timeoutMs2}ms`));
+              }, timeoutMs2);
             })
           ]);
           if (result.ok) {
@@ -33678,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 [];
@@ -35184,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.",
@@ -35241,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");
@@ -38792,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({
@@ -38832,7 +38832,7 @@ function runSsh(target, remoteCommand, timeoutMs = 6e4) {
         stdout,
         stderr: stderr + "\n[ssh] timeout"
       });
-    }, timeoutMs);
+    }, timeoutMs2);
     child.on("error", (err) => {
       clearTimeout(timer);
       resolve3({
@@ -39061,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], {
@@ -39073,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 });
@@ -39083,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 {
@@ -39092,7 +39092,7 @@ function runShell(command, cwd, timeoutMs, signal) {
         } catch {
         }
         clearTimeout(timer);
-        finish(130);
+        finish2(130);
         return;
       }
       signal.addEventListener(
@@ -39103,7 +39103,7 @@ function runShell(command, cwd, timeoutMs, signal) {
           } catch {
           }
           clearTimeout(timer);
-          finish(130);
+          finish2(130);
         },
         { once: true }
       );
@@ -39118,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);
     });
   });
 }
@@ -39144,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;
@@ -39858,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));
@@ -39892,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);
@@ -39957,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({
@@ -39966,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({
@@ -39976,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);
@@ -40202,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 });
@@ -40470,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;
@@ -40640,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) {
@@ -40674,7 +40680,8 @@ function parseHeadlessFlags(argv) {
       ...strictDone ? { strictDone: true } : {},
       ...krakenGraph ? { krakenGraph } : {},
       ...planOnly ? { planOnly: true } : {},
-      ...runPlan ? { runPlan } : {}
+      ...runPlan ? { runPlan } : {},
+      ...gauntlet ? { gauntlet: true } : {}
     }
   };
 }
@@ -41985,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);
@@ -43559,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) {
@@ -43732,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]`
@@ -43753,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`));
@@ -43764,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) {
@@ -44841,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)" };
   }
@@ -44874,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);
@@ -44882,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");
     });
@@ -44898,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,
@@ -44910,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,
@@ -46519,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") {
@@ -46528,8 +46535,8 @@ function startPermissionBroker(socketPath, handlers, opts) {
               res();
             }
           };
-          server.close(() => finish());
-          setTimeout(finish, 1e3).unref?.();
+          server.close(() => finish2());
+          setTimeout(finish2, 1e3).unref?.();
         })
       });
     });
@@ -46966,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;
@@ -46998,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(
@@ -49381,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",
@@ -49413,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 {
@@ -50182,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, {
@@ -50956,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" } };
@@ -50975,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",
@@ -50995,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" } };
@@ -51013,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);
@@ -55861,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"))
   );
@@ -56164,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();
@@ -56173,7 +57038,7 @@ ${detail}
       resolve3(ok);
     };
     cancelAskTimeout = armPickerTimeout(
-      () => finish(
+      () => finish2(
         false,
         `[permission] ask for "${req.toolName}" timed out after ${Math.round(
           askTimeoutMs / 1e3
@@ -56202,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).`
           );
@@ -56216,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)
     });
   });
 }
@@ -56547,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();
@@ -56563,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
           );
@@ -56571,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({
@@ -57361,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();
@@ -57377,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
     );
@@ -57385,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");
@@ -57530,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);
@@ -57540,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
     })) {
@@ -58146,7 +59011,7 @@ function usePermissionBroker(opts) {
       }
       let settled = false;
       let cancelWaitTimeout;
-      const finish = (value) => {
+      const finish2 = (value) => {
         if (settled) return;
         settled = true;
         cancelWaitTimeout?.();
@@ -58162,7 +59027,7 @@ function usePermissionBroker(opts) {
           )}s \u2014 richiesta annullata.`,
           Date.now()
         );
-        finish(null);
+        finish2(null);
       }, waitTimeoutMs);
       appendSystem(
         setMessages,
@@ -58174,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, {
@@ -62280,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) {
@@ -62294,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 };
   };
@@ -62451,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);
   }
@@ -62667,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.