claudish 7.51.0 → 7.52.0

package/bin/claudish.cjs

@@ -3,8 +3,38 @@
 // Launcher script: checks for Bun runtime before starting claudish.
 // Claudish uses Bun-specific APIs (bun:ffi for TUI, Bun.spawn, etc.)
 // so it cannot run under Node.js directly.
+//
+// ── Why this is spawn() and not spawnSync() ──────────────────────────────────
+//
+// This process is a THIN WRAPPER around the real CLI, and it is the process
+// every caller's signal actually lands on. It used to run the child with
+// `spawnSync(bun, ..., { stdio: "inherit" })`, which made the whole tree
+// unkillable in a way that looked like the child was ignoring signals:
+//
+//   · `spawnSync` blocks the event loop, so this process cannot forward
+//     anything while the child runs.
+//   · `stdio: "inherit"` gives the Bun child THIS process's fd 0/1/2. When a
+//     caller pipes our stdout, the Bun child holds the write end of that pipe.
+//   · So SIGTERM killed only this launcher. The Bun child was ORPHANED, not
+//     killed — it kept running, kept billing, and kept the caller's pipe open,
+//     writing into it long after the caller had given up.
+//
+// Measured 2026-08-15 with a repro of this exact topology: SIGTERM to the
+// launcher pid leaked 330 B of post-kill output, and so did SIGKILL — because
+// the problem is signalling the wrong process, not a stubborn one. It cost a
+// real `team` run: a model declared TIMEOUT with 0 B wrote a complete 40,699 B
+// answer into the response file 375 s later, and was scored as empty.
+//
+// Now: async spawn, forward the signals a supervisor actually sends, and exit
+// with the child's own status. A caller that terminates `claudish` terminates
+// claudish.
+//
+// This does NOT cover being SIGKILLed ourselves — nothing running in this
+// process can. Callers that need a hard guarantee should spawn claudish
+// `detached` and signal the process GROUP, which reaches the Bun child (and its
+// own descendants) directly; `team-orchestrator.ts` does exactly that.
 
-const { execFileSync, execSync } = require("node:child_process");
+const { execFileSync, execSync, spawn } = require("node:child_process");
 const { resolve } = require("node:path");
 
 /**
@@ -75,18 +105,64 @@ Learn more: https://bun.sh`);
     process.exit(1);
   }
 
-  // Exec into bun with the real entry point
   const entry = resolve(__dirname, "..", "dist", "index.js");
+
+  let child;
   try {
-    const result = require("node:child_process").spawnSync(bun, [entry, ...process.argv.slice(2)], {
+    child = spawn(bun, [entry, ...process.argv.slice(2)], {
       stdio: "inherit",
       env: process.env,
     });
-    process.exit(result.status ?? 1);
   } catch (err) {
     console.error("Failed to start claudish:", err.message);
     process.exit(1);
   }
+
+  // Forward the signals a supervisor, terminal, or parent process actually sends.
+  // SIGKILL is deliberately absent — it cannot be caught, which is the whole
+  // reason callers wanting a hard kill must target the process group instead.
+  //
+  // Handlers are installed only AFTER a successful spawn, so a signal arriving
+  // during startup keeps Node's default terminate-immediately behaviour rather
+  // than being swallowed by a forward to a child that does not exist yet.
+  const FORWARDED =
+    process.platform === "win32" ? ["SIGINT", "SIGTERM"] : ["SIGINT", "SIGTERM", "SIGHUP"];
+  for (const signal of FORWARDED) {
+    process.on(signal, () => {
+      // Best-effort: the child may have exited between the signal and this line.
+      try {
+        if (!child.killed) child.kill(signal);
+      } catch {}
+      // Do NOT exit here. Waiting for the child's own "exit" keeps our status
+      // honest and, more importantly, keeps this process alive as long as the
+      // child is — a caller watching OUR pid must not see us disappear while the
+      // real work is still running.
+    });
+  }
+
+  child.on("error", (err) => {
+    console.error("Failed to start claudish:", err.message);
+    process.exit(1);
+  });
+
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      // Re-raise the signal on ourselves so our parent observes the same cause
+      // of death the child had, rather than a synthesised exit code. The handler
+      // is removed first, or we would forward it straight back to a dead child.
+      process.removeAllListeners(signal);
+      try {
+        process.kill(process.pid, signal);
+        return;
+      } catch {
+        // Re-raise failed (unsupported signal on this platform) — fall back to
+        // the shell convention for "died from signal N".
+        const NUMBERS = { SIGINT: 2, SIGQUIT: 3, SIGKILL: 9, SIGTERM: 15, SIGHUP: 1 };
+        process.exit(128 + (NUMBERS[signal] ?? 0));
+      }
+    }
+    process.exit(code ?? 1);
+  });
 }
 
 // Running it as a program launches. Requiring it exposes the helpers so the

package/dist/index.js

@@ -729,7 +729,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.51.0";
+var VERSION = "7.52.0";
 
 // src/logger.ts
 var exports_logger = {};
@@ -30776,6 +30776,7 @@ class AntigravityProviderTransport {
       if (!data?.buckets?.length)
         return;
       const lines = [];
+      let sawThrottledModel = false;
       for (const bucket of data.buckets) {
         if (!bucket.modelId)
           continue;
@@ -30784,15 +30785,24 @@ class AntigravityProviderTransport {
           hour: "2-digit",
           minute: "2-digit"
         }) : "?";
-        lines.push(`  ${bucket.modelId}: ${pct} remaining (resets ${reset})`);
+        const mine = this.isThrottledModel(bucket.modelId);
+        if (mine)
+          sawThrottledModel = true;
+        lines.push(`  ${mine ? "> " : "  "}${bucket.modelId}: ${pct} remaining (resets ${reset})`);
       }
-      if (lines.length > 0) {
-        logStderr(`[Antigravity] Quota status:
+      if (lines.length === 0)
+        return;
+      const requested = this.servedModelName && this.servedModelName !== this.modelName ? `${this.modelName} (served as ${this.servedModelName})` : this.modelName;
+      const header = sawThrottledModel ? `[Antigravity] Quota status (> = ${requested}):` : `[Antigravity] Quota status \u2014 NOTE: ${requested} has no quota bucket below, ` + "so these figures do not explain its rate limit:";
+      logStderr(`${header}
 ${lines.join(`
 `)}`);
-      }
     } catch {}
   }
+  isThrottledModel(bucketModelId) {
+    const id = bucketModelId.toLowerCase();
+    return id === this.modelName.toLowerCase() || id === this.servedModelName.toLowerCase();
+  }
   async getQuotaRemaining(modelName) {
     if (!this.accessToken || !this.projectId)
       return;
@@ -32675,12 +32685,14 @@ var init_deepseek_model_dialect = __esm(() => {
     }
     applyNativeReasoning(request, originalRequest) {
       const effort = this.resolveEffortLevel(originalRequest);
-      if (effort && this.isV4Model()) {
+      if (effort && this.acceptsReasoningControls()) {
         if (effort === "none" || effort === "minimal") {
           request.thinking = { type: "disabled" };
           log(`[DeepSeekModelDialect] effort ${effort} -> thinking.type: disabled for ${this.modelId}`);
         } else {
-          const value = effort === "xhigh" || effort === "max" ? "max" : "high";
+          const reasoning = this.lookupReasoningCapability();
+          const clamped = reasoning?.control === "effort" && reasoning.efforts?.length ? this.clampToAdvertisedEffort(effort, reasoning) : undefined;
+          const value = clamped ?? (effort === "xhigh" || effort === "max" ? "max" : "high");
           request.reasoning_effort = value;
           log(`[DeepSeekModelDialect] effort ${effort} -> reasoning_effort: ${value} for ${this.modelId}`);
         }
@@ -32692,9 +32704,15 @@ var init_deepseek_model_dialect = __esm(() => {
       }
       return request;
     }
-    isV4Model() {
+    acceptsReasoningControls() {
+      const reasoning = this.lookupReasoningCapability();
+      if (reasoning)
+        return reasoning.supported === true && reasoning.control === "effort";
       const model = this.modelId.toLowerCase();
-      return model.includes("v4") || model.includes("deepseek-chat") || model.includes("deepseek-reasoner");
+      if (model.includes("deepseek-chat") || model.includes("deepseek-reasoner"))
+        return true;
+      const version2 = /(?:^|[^a-z0-9])v(\d+)/.exec(model);
+      return version2 ? Number(version2[1]) >= 4 : false;
     }
     shouldHandle(modelId) {
       return matchesModelFamily(modelId, "deepseek");
@@ -34105,11 +34123,87 @@ var init_glm_model_dialect = __esm(() => {
   };
 });
 
+// src/adapters/grok-effort-support.ts
+function acceptsReasoningEffort(modelId) {
+  const id = norm(modelId);
+  if (!id)
+    return false;
+  if (learnedRejects.has(id))
+    return false;
+  const reasoning = lookupModelReasoning(id) ?? lookupModelReasoning(modelId);
+  if (reasoning)
+    return reasoning.supported === true && reasoning.control === "effort";
+  return !SEED_REJECTS.some((re) => re.test(id));
+}
+function catalogReasoningFor(modelId) {
+  return lookupModelReasoning(norm(modelId)) ?? lookupModelReasoning(modelId);
+}
+function rememberReasoningEffortRejected(modelId) {
+  const id = norm(modelId);
+  if (!id || learnedRejects.has(id))
+    return;
+  learnedRejects.add(id);
+  log(`[GrokEffortSupport] ${id} rejected reasoning_effort \u2014 not sending it again this session.`);
+}
+function isReasoningEffortRejection(errorText) {
+  if (!errorText)
+    return false;
+  return /does not support parameter\s+`?reasoning[_]?effort`?/i.test(errorText);
+}
+function acceptsReasoningEffortValue(modelId, value) {
+  return !learnedValueRejects.has(pairKey(modelId, value));
+}
+function rememberReasoningEffortValueRejected(modelId, value) {
+  const key = pairKey(modelId, value);
+  if (learnedValueRejects.has(key))
+    return;
+  learnedValueRejects.add(key);
+  log(`[GrokEffortSupport] ${norm(modelId)} rejected reasoning_effort value "${value}" \u2014 ` + "falling back and not sending it again this session.");
+}
+function rejectedReasoningEffortValue(errorText) {
+  if (!errorText)
+    return null;
+  const m = /does not support\s+`?reasoning[_]?effort`?\s+value\s+`?([a-z]+)`?/i.exec(errorText);
+  return m ? m[1].toLowerCase() : null;
+}
+function fallbackReasoningEffortValue(value) {
+  switch (value.toLowerCase()) {
+    case "none":
+      return "low";
+    case "minimal":
+      return "low";
+    case "low":
+      return null;
+    case "medium":
+      return "low";
+    case "high":
+      return "medium";
+    default:
+      return null;
+  }
+}
+var SEED_REJECTS, learnedRejects, norm = (modelId) => modelId.trim().toLowerCase().replace(/^x-ai\//, ""), learnedValueRejects, pairKey = (modelId, value) => `${norm(modelId)}\x00${value.toLowerCase()}`;
+var init_grok_effort_support = __esm(() => {
+  init_logger();
+  init_model_catalog();
+  SEED_REJECTS = [
+    /non-reasoning/i,
+    /^grok-2/i,
+    /^grok-4(?![.\d])(?!.*fast-reasoning)/i,
+    /^grok-build-/i,
+    /^grok-code-/i,
+    /^grok-4\.20/i
+  ];
+  learnedRejects = new Set;
+  learnedValueRejects = new Set;
+});
+
 // src/adapters/grok-model-dialect.ts
 var GrokModelDialect;
 var init_grok_model_dialect = __esm(() => {
   init_logger();
   init_base_api_format();
+  init_grok_effort_support();
   init_model_catalog();
   GrokModelDialect = class GrokModelDialect extends BaseAPIFormat {
     xmlBuffer = "";
@@ -34172,34 +34266,78 @@ var init_grok_model_dialect = __esm(() => {
       return request;
     }
     effortToReasoningEffort(effort) {
-      const model = this.modelId.toLowerCase();
-      const isMini = model.includes("mini");
-      const isGrok43 = /grok-4\.3(\b|[-.]|$)/.test(model);
-      const isFastReasoning = model.includes("fast-reasoning");
-      if (!(isMini || isGrok43 || isFastReasoning)) {
+      if (!acceptsReasoningEffort(this.modelId)) {
         return;
       }
-      if (isMini) {
-        switch (effort) {
-          case "high":
-          case "xhigh":
-          case "max":
-            return "high";
-          default:
-            return "low";
+      let value;
+      const reasoning = catalogReasoningFor(this.modelId);
+      const clamped = reasoning ? this.clampToAdvertisedEffort(effort, reasoning) : undefined;
+      if (clamped) {
+        value = clamped;
+      } else {
+        const model = this.modelId.toLowerCase();
+        const isMini = model.includes("mini");
+        if (isMini) {
+          switch (effort) {
+            case "high":
+            case "xhigh":
+            case "max":
+              value = "high";
+              break;
+            default:
+              value = "low";
+          }
+        } else {
+          switch (effort) {
+            case "none":
+              value = "none";
+              break;
+            case "minimal":
+            case "low":
+              value = "low";
+              break;
+            case "medium":
+              value = "medium";
+              break;
+            default:
+              value = "high";
+          }
         }
       }
-      switch (effort) {
-        case "none":
-          return "none";
-        case "minimal":
-        case "low":
-          return "low";
-        case "medium":
-          return "medium";
-        default:
-          return "high";
+      let guard = 0;
+      while (!acceptsReasoningEffortValue(this.modelId, value) && guard++ < 8) {
+        const next = fallbackReasoningEffortValue(value);
+        if (!next)
+          return;
+        value = next;
+      }
+      return value;
+    }
+    recoverFromRejection(payload, errorText) {
+      if (!payload || payload.reasoning_effort === undefined)
+        return null;
+      if (isReasoningEffortRejection(errorText)) {
+        rememberReasoningEffortRejected(this.modelId);
+        const next = { ...payload };
+        delete next.reasoning_effort;
+        return { payload: next, note: `dropped reasoning_effort for ${this.modelId}` };
+      }
+      const rejected = rejectedReasoningEffortValue(errorText);
+      if (rejected) {
+        rememberReasoningEffortValueRejected(this.modelId, rejected);
+        const fallback = fallbackReasoningEffortValue(rejected);
+        const next = { ...payload };
+        if (fallback) {
+          next.reasoning_effort = fallback;
+          return {
+            payload: next,
+            note: `reasoning_effort "${rejected}" -> "${fallback}" for ${this.modelId}`
+          };
+        }
+        delete next.reasoning_effort;
+        return { payload: next, note: `dropped unsupported reasoning_effort for ${this.modelId}` };
       }
+      return null;
     }
     parseXmlParameters(xmlContent) {
       const params = {};
@@ -36079,6 +36217,45 @@ Do not invent a different filename, and do not derive one from the task. Claude
   PLAN_MODE_RULES = [planFilePathRule];
 });
 
+// src/behavior/rules/session-context.ts
+function hasInjectedSessionContext(systemText2, messages) {
+  const haystacks = [systemText2 ?? ""];
+  const first = Array.isArray(messages) ? messages[0] : undefined;
+  if (first && typeof first === "object") {
+    const content = first.content;
+    if (typeof content === "string") {
+      haystacks.push(content);
+    } else if (Array.isArray(content)) {
+      for (const block of content) {
+        const text = block?.text;
+        if (typeof text === "string")
+          haystacks.push(text);
+      }
+    }
+  }
+  return haystacks.some((h) => {
+    const lower = h.toLowerCase();
+    return SESSION_CONTEXT_MARKERS.some((m) => lower.includes(m));
+  });
+}
+var SESSION_CONTEXT_MARKERS, NOTE, noHarnessEchoRule, SESSION_CONTEXT_RULES;
+var init_session_context = __esm(() => {
+  SESSION_CONTEXT_MARKERS = ["sessionstart hook additional context", "hook additional context"];
+  NOTE = "Operational context note. This session may include text injected by the harness " + "itself \u2014 SessionStart hook output, coaching or insight blocks, tooling banners, " + "status lines. That material is addressed to you, not to the user, and it is not " + "part of the task. Never reproduce, summarise, or quote it in your answer, and never " + "let it open your response. Begin your answer with the requested deliverable and " + "nothing before it.";
+  noHarnessEchoRule = {
+    id: "session-context/no-harness-echo",
+    description: "Stop foreign models opening their answer with harness-injected session context " + "(SessionStart hook output, coaching/insight blocks).",
+    defaultSeverity: "fix",
+    appliesTo: ({ isNativeAnthropic }) => !isNativeAnthropic,
+    onRequest(ctx) {
+      if (!hasInjectedSessionContext(ctx.systemText, ctx.messages))
+        return [];
+      return [{ type: "injectSystemNote", text: NOTE }];
+    }
+  };
+  SESSION_CONTEXT_RULES = [noHarnessEchoRule];
+});
+
 // src/behavior/hooks.ts
 import { isAbsolute, resolve } from "path";
 function isBehaviorRule(value) {
@@ -36288,6 +36465,7 @@ var init_behavior = __esm(() => {
   init_config();
   init_engine();
   init_plan_mode();
+  init_session_context();
   init_engine();
   init_config();
   init_harness();
@@ -36297,7 +36475,7 @@ var init_behavior = __esm(() => {
   init_corpus();
   init_aggregate();
   init_upload();
-  BUILTIN_RULES = [...PLAN_MODE_RULES];
+  BUILTIN_RULES = [...PLAN_MODE_RULES, ...SESSION_CONTEXT_RULES];
   hookRules = [];
 });
 
@@ -40840,6 +41018,30 @@ class ComposedHandler {
     }
     log(`[${this.provider.displayName}] Response status: ${response.status}`);
     this.capturePlanUsage(response);
+    if (!response.ok) {
+      if (response.status >= 400 && response.status < 500 && this.modelAdapter?.recoverFromRejection) {
+        const errorText = await response.clone().text();
+        const recovery = this.modelAdapter.recoverFromRejection(requestPayload, errorText);
+        if (recovery) {
+          log(`[${this.provider.displayName}] Parameter rejected \u2014 retrying: ${recovery.note}`);
+          requestPayload = recovery.payload;
+          const retrySerialized = this.provider.serializeBody?.(requestPayload);
+          const retryHeaders = await this.provider.getHeaders();
+          retryHeaders["Content-Type"] = retrySerialized?.contentType ?? "application/json";
+          const retryResp = await fetch(endpoint, {
+            method: "POST",
+            headers: retryHeaders,
+            body: retrySerialized?.body ?? JSON.stringify(requestPayload),
+            ...this.provider.getRequestInit?.() || {}
+          });
+          if (retryResp.ok) {
+            response = retryResp;
+          } else {
+            log(`[${this.provider.displayName}] Retry after ${recovery.note} still failed ` + `(HTTP ${retryResp.status})`);
+          }
+        }
+      }
+    }
     if (!response.ok) {
       if (response.status === 401 && this.provider.forceRefreshAuth) {
         log(`[${this.provider.displayName}] Got 401, forcing auth refresh and retrying`);
@@ -44643,6 +44845,48 @@ var init_signal_watcher = __esm(() => {
   QUESTION_PATTERNS = [/\?\s*$/m, /\bchoose\b.*:/im, /\bselect\b.*:/im, /\benter\b.*:/im];
 });
 
+// src/process-tree.ts
+function signalProcessTree(proc, signal) {
+  if (KILL_PROCESS_GROUP && proc.pid) {
+    try {
+      process.kill(-proc.pid, signal);
+    } catch {}
+  }
+  try {
+    if (!proc.killed)
+      proc.kill(signal);
+  } catch {}
+}
+function waitForExit(proc, ms) {
+  if (proc.exitCode !== null || proc.signalCode !== null)
+    return Promise.resolve(true);
+  return new Promise((resolve2) => {
+    let settled = false;
+    const done = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      proc.off("exit", onExit);
+      resolve2(value);
+    };
+    const onExit = () => done(true);
+    proc.once("exit", onExit);
+    const t = setTimeout(() => done(false), ms);
+    t.unref?.();
+  });
+}
+async function terminateChildTree(proc, graceMs = TERMINATE_GRACE_MS) {
+  signalProcessTree(proc, "SIGTERM");
+  if (await waitForExit(proc, graceMs))
+    return true;
+  signalProcessTree(proc, "SIGKILL");
+  return waitForExit(proc, graceMs);
+}
+var KILL_PROCESS_GROUP, TERMINATE_GRACE_MS = 5000;
+var init_process_tree = __esm(() => {
+  KILL_PROCESS_GROUP = process.platform !== "win32";
+});
+
 // src/spawn-claudish.ts
 function resolveClaudishSpawn(env = process.env) {
   const bin = env[CLAUDISH_BIN_ENV]?.trim();
@@ -44699,7 +44943,8 @@ class SessionManager {
     const proc = spawn(spawnTarget.command, [...spawnTarget.prefixArgs, ...args], {
       cwd: opts.cwd ?? process.cwd(),
       stdio: ["pipe", "pipe", "pipe"],
-      shell: false
+      shell: false,
+      detached: KILL_PROCESS_GROUP
     });
     const scrollback = new ScrollbackBuffer(this.scrollbackCapacity);
     const watcher = new SignalWatcher(sessionId2, (sid, data) => {
@@ -44779,10 +45024,10 @@ class SessionManager {
     });
     entry.timeoutHandle = setTimeout(() => {
       if (!proc.killed) {
-        proc.kill("SIGTERM");
+        signalProcessTree(proc, "SIGTERM");
         entry.killHandle = setTimeout(() => {
           try {
-            proc.kill("SIGKILL");
+            signalProcessTree(proc, "SIGKILL");
           } catch {}
         }, KILL_GRACE_MS);
         entry.info.status = "timeout";
@@ -44840,10 +45085,10 @@ class SessionManager {
     entry.info.completedAt = new Date().toISOString();
     entry.watcher.forceState("cancelled", "Session cancelled");
     if (!entry.process.killed) {
-      entry.process.kill("SIGTERM");
+      signalProcessTree(entry.process, "SIGTERM");
       entry.killHandle = setTimeout(() => {
         try {
-          entry.process.kill("SIGKILL");
+          signalProcessTree(entry.process, "SIGKILL");
         } catch {}
       }, KILL_GRACE_MS);
     }
@@ -44874,11 +45119,11 @@ class SessionManager {
     const promises = [];
     for (const [, entry] of this.sessions) {
       if (!entry.process.killed) {
-        entry.process.kill("SIGTERM");
+        signalProcessTree(entry.process, "SIGTERM");
         promises.push(new Promise((resolve2) => {
           const timeout = setTimeout(() => {
             try {
-              entry.process.kill("SIGKILL");
+              signalProcessTree(entry.process, "SIGKILL");
             } catch {}
             resolve2();
           }, KILL_GRACE_MS);
@@ -44924,6 +45169,7 @@ class SessionManager {
 }
 var DEFAULT_MAX_SESSIONS = 20, DEFAULT_SCROLLBACK = 2000, DEFAULT_TIMEOUT = 600, MAX_TIMEOUT = 3600, KILL_GRACE_MS = 5000;
 var init_session_manager = __esm(() => {
+  init_process_tree();
   init_scrollback_buffer();
   init_signal_watcher();
 });
@@ -50810,6 +51056,7 @@ __export(exports_team_orchestrator, {
   runModels: () => runModels,
   resolveCaptureMode: () => resolveCaptureMode,
   parseJudgeVotes: () => parseJudgeVotes,
+  meaningfulStderr: () => meaningfulStderr,
   judgeResponses: () => judgeResponses,
   getStatus: () => getStatus,
   fisherYatesShuffle: () => fisherYatesShuffle,
@@ -50818,6 +51065,9 @@ __export(exports_team_orchestrator, {
   aggregateVerdict: () => aggregateVerdict,
   TEAM_CAPTURE_ENV_VAR: () => TEAM_CAPTURE_ENV_VAR,
   STDOUT_TAIL_LIMIT: () => STDOUT_TAIL_LIMIT,
+  GRACE_INTERVAL_MS: () => GRACE_INTERVAL_MS,
+  DRAIN_TIMEOUT_MS: () => DRAIN_TIMEOUT_MS,
+  DEFAULT_STALL_SECONDS: () => DEFAULT_STALL_SECONDS,
   DEFAULT_MIN_OUTPUT_BYTES: () => DEFAULT_MIN_OUTPUT_BYTES
 });
 import { spawn as spawn2 } from "child_process";
@@ -50890,6 +51140,13 @@ function classifyRunOutput(opts) {
   }
   return null;
 }
+function meaningfulStderr(stderr) {
+  if (!stderr)
+    return "";
+  return stderr.split(`
+`).filter((line) => line.trim().length > 0).filter((line) => !BENIGN_STDERR_PATTERNS.some((re) => re.test(line))).join(`
+`).trim();
+}
 function persistErrorLog(errorLogPath, header, stderr, stdoutTail) {
   const parts = [`=== ${redactSecrets(header)} ===`, ""];
   parts.push("--- stderr ---", stderr.trim() ? redactSecrets(stderr) : "(empty)", "");
@@ -51001,13 +51258,40 @@ async function runModels(sessionPath, opts = {}) {
   const minOutputBytes = opts.minOutputBytes ?? DEFAULT_MIN_OUTPUT_BYTES;
   const requirePattern = opts.requirePattern;
   const captureMode = resolveCaptureMode(opts.captureMode);
+  function reconcileTimedOutOutput(id, finalBytes, stdoutTail, stderr) {
+    const current = statusCache.models[id];
+    if (!current || current.state !== "TIMEOUT")
+      return;
+    if (finalBytes <= current.outputSize)
+      return;
+    const degraded = classifyRunOutput({
+      outputSize: finalBytes,
+      stdoutTail,
+      stderr,
+      minOutputBytes
+    });
+    if (degraded) {
+      updateModelStatus(id, { outputSize: finalBytes });
+      return;
+    }
+    updateModelStatus(id, {
+      state: "COMPLETED",
+      outputSize: finalBytes,
+      completedAt: new Date().toISOString(),
+      error: undefined
+    });
+    const note = `Recovered after the deadline: the child flushed ${finalBytes} B while shutting down, ` + "so its answer is complete and is being counted. The run still exceeded its timeout.";
+    const rt = runtimes.get(id);
+    if (rt)
+      persistErrorLog(rt.errorLogPath, `RECOVERED: ${note}`, stderr, stdoutTail);
+    opts.onStatusChange?.(id, statusCache.models[id]);
+  }
   mkdirSync12(statsDir(sessionPath), { recursive: true });
   const processes = new Map;
   const runtimes = new Map;
   const sigintHandler = () => {
     for (const [, proc] of processes) {
-      if (!proc.killed)
-        proc.kill("SIGTERM");
+      signalProcessTree(proc, "SIGTERM");
     }
     process.exit(1);
   };
@@ -51033,6 +51317,7 @@ async function runModels(sessionPath, opts = {}) {
     const proc = spawn2(teamSpawnTarget.command, [...teamSpawnTarget.prefixArgs, ...args], {
       stdio: ["pipe", "pipe", "pipe"],
       shell: false,
+      detached: KILL_PROCESS_GROUP,
       env: {
         ...process.env,
         CLAUDISH_TOKEN_FILE: tokenFileFor(sessionPath, anonId)
@@ -51093,6 +51378,7 @@ async function runModels(sessionPath, opts = {}) {
           return;
         if (statusCache.models[anonId].state === "TIMEOUT") {
           resolved = true;
+          reconcileTimedOutOutput(anonId, byteCount, stdoutTail, stderr);
           resolve4();
           return;
         }
@@ -51150,13 +51436,8 @@ async function runModels(sessionPath, opts = {}) {
       };
       outputStream.on("close", finish);
       proc.on("exit", (code) => {
-        const current = statusCache.models[anonId];
-        if (current?.state === "TIMEOUT") {
-          resolved = true;
-          resolve4();
-          return;
-        }
-        if (stderr) {
+        const timedOut = statusCache.models[anonId]?.state === "TIMEOUT";
+        if (!timedOut && meaningfulStderr(stderr)) {
           writeFileSync12(errorLogPath, redactSecrets(stderr), "utf-8");
         }
         exitCode = code;
@@ -51198,48 +51479,98 @@ async function runModels(sessionPath, opts = {}) {
   emitProgress();
   const progressHandle = setInterval(() => emitProgress("running"), POLL_MS);
   progressHandle.unref?.();
-  let timeoutHandle = null;
-  await Promise.race([
-    Promise.all(completionPromises),
-    new Promise((resolve4) => {
-      timeoutHandle = setTimeout(() => {
-        for (const [id, proc] of processes) {
-          const current = statusCache.models[id];
-          if (current.state === "RUNNING") {
-            if (!proc.killed)
-              proc.kill("SIGTERM");
-            const rt = runtimes.get(id);
-            rt?.flushPartial();
-            const stderr = rt?.getStderr() ?? "";
-            const stdoutTail = rt?.getStdoutTail() ?? "";
-            const bytes2 = rt?.getByteCount() ?? 0;
-            const detail = `Killed by the orchestrator after ${timeoutMs / 1000}s with ${bytes2} B of stdout. ` + "That figure counts the ANSWER, not the wire format, so 0 B means the child had " + `not produced an assistant message yet \u2014 "did not finish", not "produced nothing".`;
-            if (rt)
-              persistErrorLog(rt.errorLogPath, `TIMEOUT: ${detail}`, stderr, stdoutTail);
-            updateModelStatus(id, {
-              state: "TIMEOUT",
-              completedAt: new Date().toISOString(),
-              outputSize: bytes2,
-              error: rt ? {
-                model: id,
-                command: rt.command,
-                reason: "timeout",
-                detail,
-                stderrSnippet: stderr ? redactSecrets(stderr).slice(-2000) : undefined,
-                stdoutSnippet: stdoutTail ? redactSecrets(stdoutTail).slice(-2000) : undefined,
-                errorLogPath: rt.errorLogPath,
-                workDir: sessionPath
-              } : undefined
-            });
-            opts.onStatusChange?.(id, statusCache.models[id]);
-          }
+  const graceEnabled = opts.graceExtension ?? true;
+  const maxGraceMs = Math.max(0, (opts.maxGraceSeconds ?? timeoutMs / 1000) * 1000);
+  const stallMs = Math.max(0, (opts.stallSeconds ?? DEFAULT_STALL_SECONDS) * 1000);
+  const idleMsFor = (id) => {
+    const s = readTokenStats(sessionPath, id);
+    if (!s || typeof s.updated_at !== "number" || s.updated_at <= 0)
+      return null;
+    return Math.max(0, Date.now() - s.updated_at);
+  };
+  const graceStartedAt = new Map;
+  const graceUsedMs = (id, now) => {
+    const start = graceStartedAt.get(id);
+    return start === undefined ? 0 : Math.max(0, now - start);
+  };
+  const runningIds = () => [...processes.keys()].filter((id) => statusCache.models[id]?.state === "RUNNING");
+  const timeoutModel = async (id, why) => {
+    const proc = processes.get(id);
+    if (!proc || statusCache.models[id]?.state !== "RUNNING")
+      return;
+    const rt = runtimes.get(id);
+    rt?.flushPartial();
+    const stderr = rt?.getStderr() ?? "";
+    const stdoutTail = rt?.getStdoutTail() ?? "";
+    const bytes2 = rt?.getByteCount() ?? 0;
+    const grace = graceUsedMs(id, Date.now());
+    const detail = `Killed by the orchestrator after ${(timeoutMs + grace) / 1000}s ` + `(deadline ${timeoutMs / 1000}s${grace ? ` + ${grace / 1000}s grace` : ""}) ` + `with ${bytes2} B of stdout \u2014 ${why}. ` + "That figure counts the ANSWER, not the wire format, so 0 B means the child had " + `not produced an assistant message yet \u2014 "did not finish", not "produced nothing".`;
+    if (rt)
+      persistErrorLog(rt.errorLogPath, `TIMEOUT: ${detail}`, stderr, stdoutTail);
+    updateModelStatus(id, {
+      state: "TIMEOUT",
+      completedAt: new Date().toISOString(),
+      outputSize: bytes2,
+      error: rt ? {
+        model: id,
+        command: rt.command,
+        reason: "timeout",
+        detail,
+        stderrSnippet: stderr ? redactSecrets(stderr).slice(-2000) : undefined,
+        stdoutSnippet: stdoutTail ? redactSecrets(stdoutTail).slice(-2000) : undefined,
+        errorLogPath: rt.errorLogPath,
+        workDir: sessionPath
+      } : undefined
+    });
+    opts.onStatusChange?.(id, statusCache.models[id]);
+    const stopped = await terminateChildTree(proc);
+    if (!stopped) {
+      persistErrorLog(rt?.errorLogPath ?? join28(sessionPath, "errors", `${id}.log`), "TIMEOUT: child survived SIGKILL \u2014 it may still be running and billing", stderr, stdoutTail);
+    }
+  };
+  const allDone = Promise.all(completionPromises);
+  let settled = false;
+  allDone.then(() => {
+    settled = true;
+  }, () => {
+    settled = true;
+  });
+  const deadlineWatcher = (async () => {
+    await delay(timeoutMs);
+    for (;; ) {
+      if (settled)
+        return;
+      const running = runningIds();
+      if (running.length === 0)
+        return;
+      const extended = [];
+      const now = Date.now();
+      for (const id of running) {
+        const idleMs = idleMsFor(id);
+        const usedGrace = graceUsedMs(id, now);
+        if (!graceEnabled) {
+          await timeoutModel(id, "deadline reached (grace extension disabled)");
+        } else if (usedGrace >= maxGraceMs) {
+          await timeoutModel(id, `grace exhausted after ${Math.round(usedGrace / 1000)}s of extra time`);
+        } else if (idleMs === null) {
+          await timeoutModel(id, "deadline reached with no measurable progress to extend for");
+        } else if (idleMs >= stallMs) {
+          await timeoutModel(id, `no measurable progress for ${Math.round(idleMs / 1000)}s`);
+        } else {
+          if (!graceStartedAt.has(id))
+            graceStartedAt.set(id, now);
+          extended.push(id);
         }
-        resolve4();
-      }, timeoutMs);
-    })
-  ]);
-  if (timeoutHandle !== null)
-    clearTimeout(timeoutHandle);
+      }
+      if (extended.length === 0)
+        return;
+      emitProgress("running");
+      await delay(Math.min(GRACE_INTERVAL_MS, Math.max(1000, stallMs)));
+    }
+  })().catch(() => {});
+  await Promise.race([allDone, deadlineWatcher]);
+  if (!settled)
+    await Promise.race([allDone, delay(DRAIN_TIMEOUT_MS)]);
   clearInterval(progressHandle);
   emitProgress("settled");
   process.off("SIGINT", sigintHandler);
@@ -51425,14 +51756,19 @@ function formatVerdict(verdict, sessionPath) {
   }
   return output;
 }
-var TEAM_CAPTURE_ENV_VAR = "CLAUDISH_TEAM_CAPTURE", STDOUT_TAIL_LIMIT = 4000, API_ERROR_RE, BG_CEILING_RE, DEFAULT_MIN_OUTPUT_BYTES = 0, SENTINEL_MODELS;
+var TEAM_CAPTURE_ENV_VAR = "CLAUDISH_TEAM_CAPTURE", STDOUT_TAIL_LIMIT = 4000, API_ERROR_RE, BG_CEILING_RE, DEFAULT_MIN_OUTPUT_BYTES = 0, DRAIN_TIMEOUT_MS = 1e4, GRACE_INTERVAL_MS = 60000, DEFAULT_STALL_SECONDS = 90, delay = (ms) => new Promise((resolve4) => {
+  const t = setTimeout(resolve4, ms);
+  t.unref?.();
+}), BENIGN_STDERR_PATTERNS, SENTINEL_MODELS;
 var init_team_orchestrator = __esm(() => {
   init_prehydrate();
+  init_process_tree();
   init_redact();
   init_team_stats();
   init_team_stream_capture();
   API_ERROR_RE = /\[API Error:\s*([^\]]{0,300})\]/i;
   BG_CEILING_RE = /Background tasks still running after (\d+)s; terminating/i;
+  BENIGN_STDERR_PATTERNS = [/^\s*\[claude-code:unrecognized_model\]/];
   SENTINEL_MODELS = new Set([
     "internal",
     "default",
@@ -52976,6 +53312,11 @@ function findMagmuxBinary() {
   throw new Error(`magmux not found. Install it:
   brew install MadAppGang/tap/magmux`);
 }
+function withoutControlPanes(evt) {
+  if (!Array.isArray(evt.panes))
+    return evt;
+  return { ...evt, panes: evt.panes.filter((p) => p?.control !== true) };
+}
 async function subscribeToMagmux(sockPath, onEvent) {
   let client = null;
   for (let attempt = 0;attempt < 40; attempt++) {
@@ -53012,7 +53353,7 @@ async function subscribeToMagmux(sockPath, onEvent) {
           const evt = JSON.parse(line);
           onEvent?.(evt);
           if (evt.type === "results") {
-            finalResults = evt;
+            finalResults = withoutControlPanes(evt);
           }
         } catch {}
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "7.51.0",
+  "version": "7.52.0",
   "description": "Run Claude Code with any model - OpenRouter, Ollama, LM Studio & local models",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,10 +60,10 @@
     "ai"
   ],
   "optionalDependencies": {
-    "@claudish/magmux-darwin-arm64": "7.51.0",
-    "@claudish/magmux-darwin-x64": "7.51.0",
-    "@claudish/magmux-linux-arm64": "7.51.0",
-    "@claudish/magmux-linux-x64": "7.51.0"
+    "@claudish/magmux-darwin-arm64": "7.52.0",
+    "@claudish/magmux-darwin-x64": "7.52.0",
+    "@claudish/magmux-linux-arm64": "7.52.0",
+    "@claudish/magmux-linux-x64": "7.52.0"
   },
   "author": "Jack Rudenko <i@madappgang.com>",
   "license": "MIT",