claudish 10.6.3 → 10.7.1

package/dist/index.js

@@ -901,7 +901,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "10.6.3";
+var VERSION = "10.7.1";
 
 // src/logger.ts
 import { appendFile, existsSync as existsSync2, mkdirSync, readdirSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
@@ -18828,6 +18828,10 @@ function lookupModelReasoningStatus(modelId, cachePath) {
   const entry = findCacheEntry(modelId, cachePath);
   return entry ? reasoningStatusOf(entry) : undefined;
 }
+function lookupModelMaxOutputTokens(modelId, cachePath) {
+  const value = findCacheEntry(modelId, cachePath)?.maxOutputTokens;
+  return typeof value === "number" && value > 0 ? value : undefined;
+}
 function lookupRouteReasoningMode(modelId, provider, cachePath) {
   return findCacheEntry(modelId, cachePath)?.aggregators?.find((aggregator) => catalogRouteMatchesProvider(aggregator.route, provider))?.reasoning?.mode;
 }
@@ -20945,6 +20949,7 @@ ${merged}`;
 var AnthropicAPIFormat;
 var init_anthropic_api_format = __esm(() => {
   init_base_api_format();
+  init_model_catalog();
   AnthropicAPIFormat = class AnthropicAPIFormat extends BaseAPIFormat {
     constructor(modelId, _providerName) {
       super(modelId);
@@ -20985,14 +20990,24 @@ var init_anthropic_api_format = __esm(() => {
     convertTools(claudeRequest, _summarize) {
       return claudeRequest.tools || [];
     }
+    outputLimitFor(claudeRequest) {
+      const inbound = claudeRequest?.max_tokens;
+      if (typeof inbound === "number")
+        return inbound;
+      if (this.modelId.includes("@"))
+        return;
+      return lookupModelMaxOutputTokens(this.modelId);
+    }
     buildPayload(claudeRequest, messages, tools) {
       const { messages: cleanMessages, hoisted } = hoistInlineSystem(messages);
       const payload = {
         model: this.modelId,
         messages: cleanMessages,
-        max_tokens: claudeRequest.max_tokens || 4096,
         stream: true
       };
+      const maxTokens = this.outputLimitFor(claudeRequest);
+      if (maxTokens !== undefined)
+        payload.max_tokens = maxTokens;
       const system = mergeSystem(claudeRequest.system, hoisted);
       if (system !== undefined) {
         payload.system = system;
@@ -31135,6 +31150,7 @@ function resolveConnection(provider, modelName, cachePath = ALL_MODELS_CACHE_PAT
       wire: found.connection.wire,
       profile,
       generationId: cache.routeRegistry.generationId,
+      ...typeof found.entry.maxOutputTokens === "number" && found.entry.maxOutputTokens > 0 ? { maxOutputTokens: found.entry.maxOutputTokens } : {},
       ...ownerWire ? { ownerWire } : {}
     }
   };
@@ -32575,6 +32591,19 @@ function wireChoicesFromClaudeRequest(claudeRequest, pinnedEffort) {
     maxTokens: typeof claudeRequest?.max_tokens === "number" ? claudeRequest.max_tokens : undefined
   };
 }
+function outputLimitToSend(wire, choices, result) {
+  if (typeof choices.maxTokens === "number")
+    return choices.maxTokens;
+  if (!LIMIT_REQUIRED_APIS.has(wire.api))
+    return;
+  const ceiling = choices.catalogMaxOutputTokens;
+  if (typeof ceiling === "number" && ceiling > 0) {
+    result.notes.push(`request has no output limit: sent the catalog's maxOutputTokens ${ceiling}`);
+    return ceiling;
+  }
+  result.notes.push("request has no output limit and the catalog publishes no maxOutputTokens: none sent");
+  return;
+}
 function shapeRequestFromWire(body, wire, choices, owner) {
   const result = { headers: [], notes: [], borrowed: [] };
   stripWireDecisions(body, wire.api);
@@ -32585,12 +32614,13 @@ function shapeRequestFromWire(body, wire, choices, owner) {
       result.borrowed.push(path);
   };
   const sameApiOwner = owner && owner !== wire && owner.api === wire.api ? owner : undefined;
+  const maxTokens = outputLimitToSend(wire, choices, result);
   if (typeof wire.tokenParam === "string") {
-    if (typeof choices.maxTokens === "number")
-      body[wire.tokenParam] = choices.maxTokens;
+    if (typeof maxTokens === "number")
+      body[wire.tokenParam] = maxTokens;
   } else if (wire.api !== "gemini") {
-    if (wire.tokenParam.status === "unknown" && sameApiOwner && typeof sameApiOwner.tokenParam === "string" && typeof choices.maxTokens === "number") {
-      borrow(`/${sameApiOwner.tokenParam}`, choices.maxTokens);
+    if (wire.tokenParam.status === "unknown" && sameApiOwner && typeof sameApiOwner.tokenParam === "string" && typeof maxTokens === "number") {
+      borrow(`/${sameApiOwner.tokenParam}`, maxTokens);
       result.notes.push(`tokenParam ${wire.tokenParam.status}: trying the owner's ${sameApiOwner.tokenParam}`);
     } else {
       result.notes.push(`tokenParam ${wire.tokenParam.status}: no output limit sent`);
@@ -32641,7 +32671,7 @@ function mergeWireHeaders(headers, extra) {
       headers[key] = `${existing},${header.value}`;
   }
 }
-var WIRE_EFFORT_ORDER, WIRE_SPEEDS, TOKEN_LIMIT_FIELDS, DECISION_POINTERS;
+var WIRE_EFFORT_ORDER, WIRE_SPEEDS, TOKEN_LIMIT_FIELDS, DECISION_POINTERS, LIMIT_REQUIRED_APIS;
 var init_wire_request = __esm(() => {
   WIRE_EFFORT_ORDER = [
     "none",
@@ -32673,6 +32703,7 @@ var init_wire_request = __esm(() => {
     "/service_tier",
     "/speed"
   ];
+  LIMIT_REQUIRED_APIS = new Set(["anthropic-messages"]);
 });
 
 // src/providers/wire-markers.ts
@@ -32921,7 +32952,7 @@ var init_vision_proxy = __esm(() => {
   init_catalog_query();
 });
 
-// src/channel/home-dir.ts
+// src/mcp-session/home-dir.ts
 import { homedir as homedir23 } from "os";
 import { join as join23 } from "path";
 function userHomeFrom(env, homedirFn = homedir23) {
@@ -33251,8 +33282,8 @@ class SessionEventRegistry {
 }
 var MISS_TTL_MS = 5000, MAX_MISSES = 5, IDLE_SWEEP_MS, sessionEvents;
 var init_session_events = __esm(() => {
-  init_home_dir();
   init_logger();
+  init_home_dir();
   init_event_translator();
   init_transcript_tailer();
   IDLE_SWEEP_MS = 30 * 60 * 1000;
@@ -37481,6 +37512,7 @@ class ComposedHandler {
     if (wire?.status === "known") {
       const choices = {
         ...wireChoicesFromClaudeRequest(claudeRequest, this.options.effortOverride),
+        catalogMaxOutputTokens: this.options.connection?.maxOutputTokens,
         acceptServedModelChange: process.env.CLAUDISH_ACCEPT_SERVED_MODEL === "1"
       };
       const markers = wireMarkerContext.getStore();
@@ -43917,67 +43949,7 @@ var init_prehydrate = __esm(() => {
   init_op_source();
 });
 
-// src/channel/diagnostics.ts
-import { appendFileSync as appendFileSync5 } from "fs";
-function traceEnabled() {
-  return process.env[TRACE_ENV] === "1";
-}
-function emit(line) {
-  const formatted = `[channel-trace] ${line}
-`;
-  process.stderr.write(formatted);
-  const filePath = process.env[TRACE_FILE_ENV];
-  if (filePath) {
-    try {
-      appendFileSync5(filePath, formatted);
-    } catch {}
-  }
-}
-function wrapStateChange(fn) {
-  if (!traceEnabled())
-    return fn;
-  return (sessionId, event) => {
-    emit(`fired sid=${sessionId} type=${event.type} model=${event.model} elapsed=${event.elapsedSeconds}s`);
-    try {
-      fn(sessionId, event);
-      emit(`callback returned sid=${sessionId} type=${event.type}`);
-    } catch (err) {
-      emit(`callback THREW sid=${sessionId} type=${event.type} err=${err?.message ?? err}`);
-      throw err;
-    }
-  };
-}
-function watchNotificationResult(result, context) {
-  if (!traceEnabled())
-    return;
-  if (result && typeof result.then === "function") {
-    result.catch((err) => {
-      emit(`notification REJECTED sid=${context.sessionId} type=${context.eventType} err=${err?.message ?? err}`);
-    });
-  }
-}
-function installWireTap() {
-  if (!traceEnabled())
-    return;
-  if (wireTapInstalled)
-    return;
-  wireTapInstalled = true;
-  const originalWrite = process.stdout.write.bind(process.stdout);
-  process.stdout.write = (chunk, ...rest) => {
-    try {
-      const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf-8");
-      if (text.includes('"notifications/claude/channel"')) {
-        emit(`WIRE-OUT ${text.trim()}`);
-      }
-    } catch {}
-    return originalWrite(chunk, ...rest);
-  };
-  emit("wire tap installed");
-}
-var TRACE_ENV = "CLAUDISH_CHANNEL_TRACE", TRACE_FILE_ENV = "CLAUDISH_CHANNEL_TRACE_FILE", wireTapInstalled = false;
-var init_diagnostics = () => {};
-
-// src/channel/scrollback-buffer.ts
+// src/mcp-session/scrollback-buffer.ts
 class ScrollbackBuffer {
   lines;
   head;
@@ -44098,8 +44070,116 @@ var init_contract = __esm(() => {
   };
 });
 
+// src/pane/reason-detail.ts
+import { closeSync as closeSync6, fstatSync, openSync as openSync6, readSync as readSync2 } from "fs";
+function reasonDetail(input, upstreamRecords = []) {
+  if (!isTerminalState(input.state) || input.state === "COMPLETED")
+    return null;
+  if (input.reason === "api_error") {
+    const last = upstreamRecords.length ? upstreamRecords[upstreamRecords.length - 1] : undefined;
+    const upstream = last === undefined ? null : upstreamMessage(last);
+    if (upstream)
+      return oneLine4(upstream);
+    const child = firstLine(input.detail);
+    return child ? oneLine4(apiErrorText(child)) : null;
+  }
+  const first = firstLine(input.detail);
+  return first ? oneLine4(first) : null;
+}
+function upstreamRecordsFor(input, upstreamLogPath) {
+  if (!upstreamLogPath || input.reason !== "api_error" || !isTerminalState(input.state))
+    return [];
+  return readTailLines(upstreamLogPath, UPSTREAM_TAIL_BYTES);
+}
+function firstLine(text) {
+  if (!text)
+    return null;
+  const line = text.split(/\r?\n/).find((l) => l.trim().length > 0);
+  return line ? line.trim() : null;
+}
+function oneLine4(text) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  if (!flat)
+    return null;
+  return flat.length > REASON_DETAIL_MAX_CHARS ? `${flat.slice(0, REASON_DETAIL_MAX_CHARS - 1).trimEnd()}\u2026` : flat;
+}
+function apiErrorText(detail) {
+  const text = detail.split(" \xB7 ")[0].replace(/^The turn ended in an API error(?:\s*\(status \d+\))?:\s*/i, "").replace(/^API Error:?\s*(?:\d{3}\b)?\s*/i, "").trim();
+  if (/^[[{]/.test(text))
+    return messageOfJsonText(text) ?? "";
+  return text;
+}
+function upstreamMessage(record) {
+  let parsed;
+  try {
+    parsed = JSON.parse(record);
+  } catch {
+    return null;
+  }
+  if (!isObject3(parsed))
+    return null;
+  const body = parsed.body;
+  if (typeof body === "string")
+    return messageOfJsonText(body);
+  return messageOf(body);
+}
+function messageOfJsonText(text) {
+  try {
+    return messageOf(JSON.parse(text));
+  } catch {
+    const m = /"error"\s*:\s*\{[^{}]*?"message"\s*:\s*"((?:[^"\\]|\\.)*)"/.exec(text);
+    if (!m)
+      return null;
+    try {
+      return nonEmpty2(JSON.parse(`"${m[1]}"`));
+    } catch {
+      return null;
+    }
+  }
+}
+function messageOf(value) {
+  const v = Array.isArray(value) ? value[0] : value;
+  if (!isObject3(v) || !isObject3(v.error))
+    return null;
+  return nonEmpty2(v.error.message);
+}
+function nonEmpty2(v) {
+  return typeof v === "string" && v.trim().length > 0 ? v : null;
+}
+function isObject3(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function readTailLines(path, maxBytes) {
+  let fd = null;
+  try {
+    fd = openSync6(path, "r");
+    const size = fstatSync(fd).size;
+    const start = Math.max(0, size - maxBytes);
+    const buf = Buffer.alloc(size - start);
+    readSync2(fd, buf, 0, buf.length, start);
+    const lines = buf.toString("utf-8").split(`
+`);
+    if (start > 0)
+      lines.shift();
+    return lines.filter((l) => l.trim().length > 0);
+  } catch {
+    return [];
+  } finally {
+    if (fd !== null) {
+      try {
+        closeSync6(fd);
+      } catch {}
+    }
+  }
+}
+var REASON_DETAIL_MAX_CHARS = 160, UPSTREAM_TAIL_BYTES;
+var init_reason_detail = __esm(() => {
+  init_contract();
+  UPSTREAM_TAIL_BYTES = 16 * 1024;
+});
+
 // src/pane/slot-row.ts
-function toSlotRow(id, snap, acct, now = Date.now()) {
+function toSlotRow(id, snap, acct, now = Date.now(), upstreamRecords = []) {
   const terminal = isTerminalState(snap.state);
   let idle = null;
   if (!terminal && snap.lastActivityAt) {
@@ -44113,6 +44193,7 @@ function toSlotRow(id, snap, acct, now = Date.now()) {
     provider: acct.provider,
     state: snap.state,
     reason: snap.state === "COMPLETED" || !terminal ? null : snap.reason,
+    reason_detail: reasonDetail({ state: snap.state, reason: snap.reason, detail: snap.detail }, upstreamRecords),
     tokens_in: acct.tokensIn,
     tokens_out: acct.tokensOut,
     cost_usd: acct.costUsd,
@@ -44126,6 +44207,7 @@ function toSlotRow(id, snap, acct, now = Date.now()) {
 }
 var init_slot_row = __esm(() => {
   init_contract();
+  init_reason_detail();
 });
 
 // src/pane/prompt-delivery.ts
@@ -51963,7 +52045,7 @@ function truncateKeepingLink(text, max = 400) {
   const prose = (lastSpace > room * 0.5 ? head.slice(0, lastSpace) : head).trimEnd();
   return `${prose}... ${url}`;
 }
-function oneLine4(text) {
+function oneLine5(text) {
   return text.replace(/\s+/g, " ").trim();
 }
 function messageFromJson(text) {
@@ -51986,9 +52068,9 @@ function extractErrorMessage(body) {
     return;
   const direct = messageFromJson(body);
   if (direct)
-    return truncateKeepingLink(oneLine4(unwrapFrame(direct)));
+    return truncateKeepingLink(oneLine5(unwrapFrame(direct)));
   const unwrapped = unwrapFrame(body);
-  const trimmed = oneLine4(unwrapped);
+  const trimmed = oneLine5(unwrapped);
   if (!trimmed)
     return;
   return truncateKeepingLink(trimmed);
@@ -57035,7 +57117,7 @@ If you cannot use structured tool_calls, format as JSON:
 });
 
 // src/handlers/native-handler-advisor.ts
-import { appendFileSync as appendFileSync6 } from "fs";
+import { appendFileSync as appendFileSync5 } from "fs";
 function loadAdvisorSwapConfig(cliModels, cliCollector) {
   return {
     enabled: process.env.CLAUDISH_SWAP_ADVISOR === "1" || (cliModels?.length ?? 0) > 0,
@@ -57130,7 +57212,7 @@ function appendLine(path, line) {
   if (!path)
     return;
   try {
-    appendFileSync6(path, `${line}
+    appendFileSync5(path, `${line}
 `);
   } catch {}
 }
@@ -59501,7 +59583,7 @@ var init_pricing_cache = __esm(() => {
 });
 
 // src/proxy-server.ts
-import { appendFileSync as appendFileSync7, mkdirSync as mkdirSync15 } from "fs";
+import { appendFileSync as appendFileSync6, mkdirSync as mkdirSync15 } from "fs";
 import { join as join35 } from "path";
 function isTerminalRoutingFailure(e) {
   return e instanceof RoutingError;
@@ -59535,7 +59617,7 @@ function maybeCaptureClassifierRequest(c, body) {
         "x-api-key": c.req.header("x-api-key") ? "<present>" : null
       }
     };
-    appendFileSync7(join35(dir, "classifier-capture.jsonl"), `${JSON.stringify(record)}
+    appendFileSync6(join35(dir, "classifier-capture.jsonl"), `${JSON.stringify(record)}
 `);
   } catch {}
 }
@@ -61565,7 +61647,7 @@ ${h("ENVIRONMENT VARIABLES")}
   ${blue("CLAUDISH_DIAG_MODE")}              Diagnostic output: auto / logfile / off
   ${blue("CLAUDISH_DEBUG")}                  Always enable debug logging: 1 / true ${dim("(same as -d)")}
   ${blue("CLAUDISH_ANTHROPIC_API_BILLING")}  Bill native Claude to your API key ${dim("(see --anthropic-api-billing)")}
-  ${blue("CLAUDISH_MCP_TOOLS")}              MCP tool gating: all / low-level / agentic / channel
+  ${blue("CLAUDISH_MCP_TOOLS")}              MCP tool gating: all / low-level / agentic / session / debug
   ${blue("CLAUDISH_MODEL_OPUS")}             Override model for Opus role
   ${blue("CLAUDISH_MODEL_SONNET")}           Override model for Sonnet role
   ${blue("CLAUDISH_MODEL_HAIKU")}            Override model for Haiku role
@@ -61875,11 +61957,11 @@ var init_magmux_binary = () => {};
 // src/launcher/magmux-wrapper.ts
 import {
   chmodSync,
-  closeSync as closeSync6,
+  closeSync as closeSync7,
   existsSync as existsSync27,
   mkdirSync as mkdirSync17,
   mkdtempSync,
-  openSync as openSync6,
+  openSync as openSync7,
   rmSync as rmSync2,
   writeFileSync as writeFileSync16
 } from "fs";
@@ -61955,11 +62037,11 @@ function planMagmuxWrap(input) {
   const scriptPath = join38(scriptDir, "claude-launch.sh");
   const parentEnv = input.parentEnv ?? process.env;
   const deltas = envDeltas(parentEnv, input.childEnv);
-  const fd = openSync6(scriptPath, "wx", 384);
+  const fd = openSync7(scriptPath, "wx", 384);
   try {
     writeFileSync16(fd, buildLauncherScript(input.claudeBinary, input.claudeArgs, deltas));
   } finally {
-    closeSync6(fd);
+    closeSync7(fd);
   }
   const env = { ...input.childEnv };
   for (const k of STRIPPED_CHILD_VARS)
@@ -62427,13 +62509,13 @@ function sockPathFor(root, id) {
     throw new PaneRootError(`pane socket path ${p} is ${Buffer.byteLength(p)} bytes; it must be < 100`);
   return p;
 }
-function strippedFromPane(key) {
+function isStrippedFromChildEnv(key) {
   return STRIPPED_CHILD_VARS.includes(key) || key.startsWith("MAGMUX_") || TERMINAL_IDENTITY_VARS.includes(key) || TERMINAL_IDENTITY_PREFIXES.some((p) => key.startsWith(p)) || HOST_IDENTITY_VARS.includes(key);
 }
 function buildPaneEnv(input) {
   const env = {};
   for (const [k, v] of Object.entries(input.parentEnv)) {
-    if (v === undefined || strippedFromPane(k))
+    if (v === undefined || isStrippedFromChildEnv(k))
       continue;
     env[k] = v;
   }
@@ -63364,7 +63446,7 @@ var init_pane_registry = __esm(() => {
   sweptRoots = new Set;
 });
 
-// src/channel/parent-session.ts
+// src/mcp-session/parent-session.ts
 import { readFile as readFile4 } from "fs/promises";
 import { join as join42 } from "path";
 function positiveInt(value) {
@@ -64013,11 +64095,11 @@ var init_slot_state = __esm(() => {
 
 // src/pane/transcript-follower.ts
 import {
-  closeSync as closeSync7,
+  closeSync as closeSync8,
   existsSync as existsSync29,
-  fstatSync,
-  openSync as openSync7,
-  readSync as readSync2,
+  fstatSync as fstatSync2,
+  openSync as openSync8,
+  readSync as readSync3,
   readdirSync as readdirSync7,
   realpathSync as realpathSync2,
   statSync as statSync8
@@ -64452,16 +64534,16 @@ class Tail {
   read() {
     let fd;
     try {
-      fd = openSync7(this.path, "r");
+      fd = openSync8(this.path, "r");
     } catch {
       return [];
     }
     try {
-      const size = fstatSync(fd).size;
+      const size = fstatSync2(fd).size;
       if (size <= this.offset)
         return [];
       const chunk = Buffer.alloc(size - this.offset);
-      const got = readSync2(fd, chunk, 0, chunk.length, this.offset);
+      const got = readSync3(fd, chunk, 0, chunk.length, this.offset);
       this.offset += got;
       const fresh = chunk.subarray(0, got);
       const buf = this.rest.length ? Buffer.concat([this.rest, fresh]) : fresh;
@@ -64478,7 +64560,7 @@ class Tail {
       this.rest = Buffer.from(buf.subarray(start));
       return out;
     } finally {
-      closeSync7(fd);
+      closeSync8(fd);
     }
   }
 }
@@ -65204,9 +65286,12 @@ class PaneSessionImpl {
     this.deliver(this.admission);
   }
   async deliver(adm) {
-    const plan = adm.plan;
+    if (await this.typeAndSubmit(adm.plan))
+      adm.deliveredAt = Date.now();
+  }
+  async typeAndSubmit(plan) {
     if (plan.mode !== "typed" && plan.mode !== "file" && plan.mode !== "command")
-      return;
+      return false;
     if (plan.mode === "command") {
       await this.typeLine(plan.line, false);
       await this.nextFrame(500);
@@ -65218,7 +65303,7 @@ class PaneSessionImpl {
     } else {
       await this.typeLine(plan.line, true);
     }
-    adm.deliveredAt = Date.now();
+    return true;
   }
   async typeLine(text, enter) {
     let why = "disconnected";
@@ -65322,16 +65407,44 @@ class PaneSessionImpl {
       this.fire("admit_abandoned");
     return true;
   }
+  async awaitClearedBox(adm, head) {
+    const end = Date.now() + this.t("nudgeClearDeadlineMs", NUDGE_CLEAR_DEADLINE_MS);
+    for (;; ) {
+      if (this.admission !== adm || this.phase !== "ADMITTING")
+        return "gone";
+      const box = inputBox(this.screen);
+      if (box && box.text === "")
+        return "empty";
+      if (box && !box.text.startsWith(head))
+        return "other";
+      const left = end - Date.now();
+      if (left <= 0)
+        return box ? "line" : "other";
+      await this.nextFrame(left);
+    }
+  }
   nudge(adm) {
     const box = inputBox(this.screen);
     const line = adm.plan.mode === "control" || adm.plan.mode === "refused" ? "" : adm.plan.line;
-    if (!adm.resent && box && line && box.text.startsWith(line.slice(0, 40))) {
+    const head = line.slice(0, 40);
+    if (!adm.resent && box && line && box.text.startsWith(head)) {
       adm.resent = true;
       this.anomaly("resent_enter");
       (async () => {
         if (box.menuOpen)
           await this.key("escape");
-        await this.key("enter");
+        await this.key("ctrl-u");
+        const after = await this.awaitClearedBox(adm, head);
+        if (after === "gone")
+          return;
+        if (after === "empty") {
+          this.anomaly("retyped_prompt");
+          await this.typeAndSubmit(adm.plan);
+        } else if (after === "line") {
+          await this.key("enter");
+        } else {
+          this.anomaly("clear_failed");
+        }
       })();
       return;
     }
@@ -66045,7 +66158,7 @@ async function startPaneSession(o) {
   await session.start({ magmuxBinary: magmux.binary, env: p.magmuxEnv, cwd: p.cwd });
   return session;
 }
-var BOOT_TIMEOUT_MS = 90000, ADMIT_TIMEOUT_MS = 30000, RESEND_AFTER_MS = 1e4, DEGRADED_ENTRY_MS = 1e4, SCREEN_SETTLE_QUIET_MS = 3000, PANEL_SETTLE_MS = 500, REPL_STABLE_MS = 500, BOOT_STATIC_MS = 5000, TICK_MS = 250, WATCH_FPS = 4, POLL_BACKSTOP_MS = 1000, TURN_END_MISSING_FACTOR = 3, REGISTRY_READ_MS = 250, REGISTRY_DISAGREE_MS = 2000, REGISTRY_MISSING_MS = 5000, MAX_ANOMALY_KEYS = 64, KEPT_ANSWERS = 4, EVENT_REASON, VERDICT_EVENT, PaneStartError;
+var BOOT_TIMEOUT_MS = 90000, ADMIT_TIMEOUT_MS = 30000, RESEND_AFTER_MS = 1e4, DEGRADED_ENTRY_MS = 1e4, SCREEN_SETTLE_QUIET_MS = 3000, PANEL_SETTLE_MS = 500, REPL_STABLE_MS = 3000, NUDGE_CLEAR_DEADLINE_MS = 3000, BOOT_STATIC_MS = 5000, TICK_MS = 250, WATCH_FPS = 4, POLL_BACKSTOP_MS = 1000, TURN_END_MISSING_FACTOR = 3, REGISTRY_READ_MS = 250, REGISTRY_DISAGREE_MS = 2000, REGISTRY_MISSING_MS = 5000, MAX_ANOMALY_KEYS = 64, KEPT_ANSWERS = 4, EVENT_REASON, VERDICT_EVENT, PaneStartError;
 var init_pane_session = __esm(() => {
   init_parent_session();
   init_process_tree();
@@ -66085,6 +66198,7 @@ var init_pane_session = __esm(() => {
 // src/pane/index.ts
 var init_pane = __esm(() => {
   init_slot_row();
+  init_reason_detail();
   init_prompt_delivery();
   init_accounting();
   init_pane_launch();
@@ -66110,7 +66224,7 @@ __export(exports_session_discovery, {
   transcriptPathFor: () => transcriptPathFor
 });
 import { execFile as execFile3, execFileSync as execFileSync3 } from "child_process";
-import { closeSync as closeSync8, openSync as openSync8, readSync as readSync3, readdirSync as readdirSync8, realpathSync as realpathSync4, statSync as statSync10 } from "fs";
+import { closeSync as closeSync9, openSync as openSync9, readSync as readSync4, readdirSync as readdirSync8, realpathSync as realpathSync4, statSync as statSync10 } from "fs";
 import { basename as basename2, join as join46 } from "path";
 function projectsDir(env = process.env) {
   return join46(claudeConfigDir(env), "projects");
@@ -66360,16 +66474,16 @@ function readChunk(file, pos, len) {
     return "";
   let fd = null;
   try {
-    fd = openSync8(file, "r");
+    fd = openSync9(file, "r");
     const buf = Buffer.allocUnsafe(len);
-    const n = readSync3(fd, buf, 0, len, pos);
+    const n = readSync4(fd, buf, 0, len, pos);
     return buf.subarray(0, n).toString("utf-8");
   } catch {
     return "";
   } finally {
     if (fd !== null) {
       try {
-        closeSync8(fd);
+        closeSync9(fd);
       } catch {}
     }
   }
@@ -66625,6 +66739,9 @@ function refreshAccounting(e, snap) {
 function notableAnomalies(snap) {
   return snap.anomalies.filter((a) => a.startsWith("background_shell_open") || a.startsWith("turn_end_record_missing") || a.startsWith("prompt_not_read"));
 }
+function upstreamLogPath(path, id) {
+  return join47(path, "errors", `${id}-upstream.jsonl`);
+}
 function neverSpawnedRow(e, m) {
   return {
     slot: e.id,
@@ -66632,6 +66749,11 @@ function neverSpawnedRow(e, m) {
     provider: e.acct.provider,
     state: m?.state ?? "FAILED",
     reason: m?.error?.reason ?? "pane_lost",
+    reason_detail: reasonDetail({
+      state: m?.state ?? "FAILED",
+      reason: m?.error?.reason ?? "pane_lost",
+      detail: m?.error?.detail
+    }),
     tokens_in: null,
     tokens_out: null,
     cost_usd: null,
@@ -66647,7 +66769,7 @@ function liveSlotRow(run, e) {
   if (!e.session)
     return neverSpawnedRow(e, run.status.models[e.id]);
   const snap = e.session.snapshot();
-  return toSlotRow({ slot: e.id, model: e.model, spawnModel: e.spawnModel }, snap, refreshAccounting(e, snap));
+  return toSlotRow({ slot: e.id, model: e.model, spawnModel: e.spawnModel }, snap, refreshAccounting(e, snap), Date.now(), upstreamRecordsFor(snap, upstreamLogPath(run.path, e.id)));
 }
 function outcomeOf(states) {
   const ok = states.filter((s) => s === "COMPLETED").length;
@@ -66686,12 +66808,15 @@ function teamRunRowFromDisk(path, status) {
   const slots = Object.entries(status.models ?? {}).sort(([a], [b]) => a.localeCompare(b)).map(([id, m]) => {
     const { state, known } = closedState(m?.state);
     const terminal = isTerminalState(state);
+    const reason = !known || !terminal || state === "COMPLETED" ? null : m?.error?.reason ?? null;
+    const why = { state, reason, detail: m?.error?.detail };
     return {
       slot: id,
       model: m?.model ?? manifest?.models[id]?.model ?? "unknown",
       provider: m?.provider ?? null,
       state,
-      reason: !known || !terminal || state === "COMPLETED" ? null : m?.error?.reason ?? null,
+      reason,
+      reason_detail: reasonDetail(why, upstreamRecordsFor(why, upstreamLogPath(path, id))),
       tokens_in: m?.tokensIn ?? null,
       tokens_out: m?.tokensOut ?? null,
       cost_usd: m?.costUsd ?? null,
@@ -67085,7 +67210,7 @@ async function startModelsIn(flight, sessionPath, opts) {
   const entries = new Map;
   let run = null;
   const errorLogPathOf = (id) => join47(path, "errors", `${id}.log`);
-  const upstreamLogOf = (id) => join47(path, "errors", `${id}-upstream.jsonl`);
+  const upstreamLogOf = (id) => upstreamLogPath(path, id);
   const commandOf = (e) => ["claudish", "-i", "--model", e.spawnModel ?? e.model, "-y", "--quiet", ...claudeFlags].join(" ");
   function writeResponse(e, text) {
     e.answer = text;
@@ -67647,17 +67772,17 @@ var init_team_orchestrator = __esm(() => {
   CANCELLED_DETAIL = `Stopped on the caller's instruction via team(mode:"cancel"). ` + "Whatever the child had written up to that point is in its response file.";
 });
 
-// src/channel/session-manager.ts
+// src/mcp-session/session-manager.ts
 import { randomUUID as randomUUID6 } from "crypto";
 import {
-  appendFileSync as appendFileSync8,
-  closeSync as closeSync9,
+  appendFileSync as appendFileSync7,
+  closeSync as closeSync10,
   createWriteStream,
   existsSync as existsSync31,
   mkdirSync as mkdirSync20,
-  openSync as openSync9,
+  openSync as openSync10,
   readFileSync as readFileSync30,
-  readSync as readSync4,
+  readSync as readSync5,
   renameSync as renameSync4,
   statSync as statSync12,
   writeFileSync as writeFileSync21
@@ -67669,7 +67794,7 @@ function normaliseTimeoutSeconds(raw) {
     return DEFAULT_TIMEOUT;
   return Math.min(MAX_TIMEOUT, Math.max(1, Math.round(n)));
 }
-function channelEventFor(snap) {
+function sessionEventFor(snap) {
   switch (snap.state) {
     case "STARTING":
       return { event: "starting", tool: null };
@@ -67691,7 +67816,7 @@ function channelEventFor(snap) {
       return { event: "failed", tool: null };
   }
 }
-function sessionRowOf(info) {
+function sessionRowOf(info, upstreamRecords = []) {
   const terminal = isTerminalState(info.state);
   return {
     slot: info.sessionId,
@@ -67699,6 +67824,7 @@ function sessionRowOf(info) {
     provider: info.provider,
     state: info.state,
     reason: info.state === "COMPLETED" || !terminal ? null : info.reason,
+    reason_detail: reasonDetail(info, upstreamRecords),
     tokens_in: info.tokensIn,
     tokens_out: info.tokensOut,
     cost_usd: info.costUsd,
@@ -67753,15 +67879,6 @@ function writeJsonAtomic(path, value) {
   writeFileSync21(tmp, JSON.stringify(value, null, 2), "utf-8");
   renameSync4(tmp, path);
 }
-function anomalyCount(anomalies, key) {
-  for (const a of anomalies) {
-    if (a === key)
-      return 1;
-    if (a.startsWith(`${key} \xD7`))
-      return Number(a.slice(key.length + 2)) || 1;
-  }
-  return 0;
-}
 function anomalyKey(a) {
   const at = a.lastIndexOf(" \xD7");
   return at > 0 ? a.slice(0, at) : a;
@@ -67775,20 +67892,20 @@ function readTailText(path, maxBytes) {
     const start = Math.max(0, size - maxBytes);
     const length = size - start;
     const buf = Buffer.alloc(length);
-    fd = openSync9(path, "r");
-    readSync4(fd, buf, 0, length, start);
+    fd = openSync10(path, "r");
+    readSync5(fd, buf, 0, length, start);
     return { text: buf.toString("utf-8"), truncated: start > 0 };
   } catch {
     return null;
   } finally {
     if (fd !== null) {
       try {
-        closeSync9(fd);
+        closeSync10(fd);
       } catch {}
     }
   }
 }
-function readTailLines(path, maxBytes) {
+function readTailLines2(path, maxBytes) {
   const tail = readTailText(path, maxBytes);
   if (!tail)
     return [];
@@ -67875,7 +67992,6 @@ class SessionManager {
   scrollbackCapacity;
   sessionsDir;
   terminalRetentionMs;
-  onStateChange;
   parentEnv;
   paneTimings;
   starting = 0;
@@ -67892,7 +68008,6 @@ class SessionManager {
     this.scrollbackCapacity = options?.scrollbackCapacity ?? DEFAULT_SCROLLBACK;
     this.terminalRetentionMs = options?.terminalRetentionMs ?? TERMINAL_RETENTION_MS;
     this.sessionsDir = options?.sessionsDir ?? sessionsDirFrom(process.env);
-    this.onStateChange = options?.onStateChange;
     this.parentEnv = options?.parentEnv ?? process.env;
     this.paneTimings = options?.paneTimings;
   }
@@ -68099,16 +68214,9 @@ class SessionManager {
       waitSince: null,
       ended: false,
       evictHandle: null,
-      lastEvent: "starting",
-      lastFrameTool: null,
-      lastFrameToolCount: 0,
-      lastToolFrameAt: 0,
       lastLoggedTool: null,
       assistantIdsLogged: 0,
-      anomaliesLogged: new Set,
-      sendRejectedSeen: 0,
-      pendingMeta: {},
-      blockText: null
+      anomaliesLogged: new Set
     };
   }
   async startPane(entry, opts, p) {
@@ -68157,7 +68265,6 @@ class SessionManager {
     info.elapsedSeconds = elapsedSecondsBetween(info.startedAt, Date.parse(at));
     this.appendEvent(entry, { type: "state", from: "STARTING", to: "FAILED", at });
     this.endRecords(entry, null);
-    this.emitFrame(entry, { state: "FAILED", activity: null, toolCalls: 0 });
   }
   decide(entry, turn) {
     this.appendAnswer(entry, turn.index, turn.answer);
@@ -68178,7 +68285,6 @@ class SessionManager {
       return { state: "FAILED", reason: "api_error", detail: v?.detail ?? "API error" };
     }
     if (turn.delivery.complete === false) {
-      entry.pendingMeta.prompt_not_read = "true";
       this.appendEvent(entry, {
         type: "anomaly",
         key: "prompt_not_read",
@@ -68190,8 +68296,7 @@ class SessionManager {
     }
     return "continue";
   }
-  onBlocked(entry, b) {
-    entry.blockText = b.text;
+  onBlocked(_entry, _b) {
     return "wait";
   }
   onPaneTransition(entry, t) {
@@ -68202,18 +68307,14 @@ class SessionManager {
     this.recordWaitTransition(entry, t.from, t.to, t.at, snap);
     this.appendEvent(entry, { type: "state", from: t.from, to: t.to, at: t.at });
     this.logPaneFacts(entry, snap);
-    if (!isWaiting(t.to))
-      entry.blockText = null;
     if (isTerminalState(t.to))
       this.onTerminal(entry, snap);
-    this.emitFrame(entry, snap);
   }
   onPaneChange(entry, snap) {
     if (entry.ended)
       return;
     this.applySnapshot(entry, snap);
     this.logPaneFacts(entry, snap);
-    this.emitFrame(entry, snap);
   }
   onTerminal(entry, snap) {
     const session = entry.session;
@@ -68251,7 +68352,7 @@ class SessionManager {
         wait: "closed",
         since: entry.waitSince,
         at: entry.info.completedAt ?? new Date().toISOString(),
-        to: channelEventFor(entry.info).event
+        to: sessionEventFor(entry.info).event
       });
       entry.waitSince = null;
     }
@@ -68301,7 +68402,7 @@ class SessionManager {
         at
       });
     }
-    const { tool } = channelEventFor(snap);
+    const { tool } = sessionEventFor(snap);
     if (tool && tool !== entry.lastLoggedTool)
       this.appendEvent(entry, { type: "tool", name: tool, at });
     entry.lastLoggedTool = tool;
@@ -68312,66 +68413,6 @@ class SessionManager {
       entry.anomaliesLogged.add(key);
       this.appendEvent(entry, { type: "anomaly", key, at });
     }
-    const rejected = anomalyCount(snap.anomalies, "send_not_accepted");
-    if (rejected > entry.sendRejectedSeen) {
-      entry.sendRejectedSeen = rejected;
-      entry.pendingMeta.send_rejected = "true";
-    }
-  }
-  emitFrame(entry, snap) {
-    const { event, tool } = channelEventFor(snap);
-    const now = Date.now();
-    const changed = event !== entry.lastEvent;
-    const toolRepeat = !changed && event === "tool_executing" && (tool !== entry.lastFrameTool || snap.toolCalls !== entry.lastFrameToolCount) && now - entry.lastToolFrameAt >= 1000;
-    if (!changed && !toolRepeat)
-      return;
-    entry.lastEvent = event;
-    if (event === "tool_executing") {
-      entry.lastFrameTool = tool;
-      entry.lastFrameToolCount = snap.toolCalls;
-      entry.lastToolFrameAt = now;
-    }
-    const extraMeta = {
-      ...tool ? { tool, tool_count: String(snap.toolCalls) } : {},
-      ...snap.activity ? { activity: snap.activity } : {},
-      ...entry.pendingMeta
-    };
-    entry.pendingMeta = {};
-    try {
-      this.onStateChange?.(entry.info.sessionId, {
-        type: event,
-        model: entry.info.model,
-        content: this.frameContent(entry, event, tool),
-        elapsedSeconds: entry.info.elapsedSeconds,
-        createdAt: entry.info.startedAt,
-        extraMeta
-      });
-    } catch {}
-  }
-  frameContent(entry, event, tool) {
-    const info = entry.info;
-    switch (event) {
-      case "running":
-        return "The turn is running.";
-      case "tool_executing":
-        return `Using ${tool}.`;
-      case "waiting_for_input":
-        return entry.blockText ? `The model asked a question; send_input declines it and becomes the next prompt.
-${entry.blockText}` : "The turn finished; waiting for send_input.";
-      case "awaiting_permission":
-        return `A permission dialog is open for ${info.activity ?? "a tool"}; send_input declines it and becomes the next prompt.${entry.blockText ? `
-${entry.blockText}` : ""}`;
-      case "completed":
-        return `Session completed (${info.turnsCompleted} turn(s)). Call get_output for the answer.`;
-      case "cancelled":
-        return "Session cancelled.";
-      case "timeout":
-        return `Timeout after ${info.timeoutSeconds}s; the pane was closed.`;
-      case "failed":
-        return `${info.state} ${info.reason ?? ""}${info.detail ? `: ${info.detail}` : ""}`.trim();
-      default:
-        return "";
-    }
   }
   sendInput(sessionId, text) {
     const entry = this.liveEntry(sessionId);
@@ -68415,7 +68456,7 @@ ${entry.blockText}` : ""}`;
     return {
       sessionId,
       state: info.state,
-      event: channelEventFor(info).event,
+      event: sessionEventFor(info).event,
       reason: isTerminalState(info.state) && info.state !== "COMPLETED" ? info.reason : null,
       detail: info.detail,
       model: info.model,
@@ -68439,7 +68480,7 @@ ${entry.blockText}` : ""}`;
       ...this.paneFacts(entry),
       recentEvents: limit === 0 ? [] : entry.eventRing.slice(-limit),
       eventsTotal: entry.eventRing.length,
-      upstreamErrors: readTailLines(entry.upstreamErrorLogPath, UPSTREAM_ERROR_TAIL_BYTES),
+      upstreamErrors: readTailLines2(entry.upstreamErrorLogPath, UPSTREAM_ERROR_TAIL_BYTES),
       claudeSessionId: info.claudeSessionId,
       transcriptPath: info.transcriptPath,
       sessionDir: entry.sessionDir,
@@ -68505,7 +68546,15 @@ ${entry.blockText}` : ""}`;
     return sessions;
   }
   listSessionRows(includeCompleted = false) {
-    return this.listSessions(includeCompleted).map(sessionRowOf);
+    const rows = [];
+    for (const entry of this.sessions.values()) {
+      this.refresh(entry);
+      if (!includeCompleted && isTerminalState(entry.info.state))
+        continue;
+      const info = { ...entry.info };
+      rows.push(sessionRowOf(info, upstreamRecordsFor(info, entry.upstreamErrorLogPath)));
+    }
+    return rows;
   }
   getSession(sessionId) {
     const entry = this.sessions.get(sessionId);
@@ -68610,13 +68659,13 @@ ${entry.blockText}` : ""}`;
     const eventLogPath = join48(sessionDir, "events.jsonl");
     const upstreamErrorLogPath = join48(sessionDir, "upstream-errors.jsonl");
     const outputLogPath = join48(sessionDir, "output.log");
-    const events = readTailLines(eventLogPath, EVENT_TAIL_BYTES);
+    const events = readTailLines2(eventLogPath, EVENT_TAIL_BYTES);
     const outputTail = readTailText(outputLogPath, OUTPUT_TAIL_BYTES);
     const screen = readTailText(join48(sessionDir, "screen.txt"), SCREEN_READ_BYTES);
     return {
       sessionId: info.sessionId,
       state: info.state,
-      event: channelEventFor(info).event,
+      event: sessionEventFor(info).event,
       reason: info.reason,
       detail: info.detail,
       model: info.model,
@@ -68666,7 +68715,7 @@ ${entry.blockText}` : ""}`;
         };
       }),
       eventsTotal: events.length,
-      upstreamErrors: readTailLines(upstreamErrorLogPath, UPSTREAM_ERROR_TAIL_BYTES),
+      upstreamErrors: readTailLines2(upstreamErrorLogPath, UPSTREAM_ERROR_TAIL_BYTES),
       claudeSessionId: info.claudeSessionId || null,
       transcriptPath: info.transcriptPath || null,
       sessionDir,
@@ -68720,7 +68769,7 @@ ${entry.blockText}` : ""}`;
     entry.eventLogBytes += Buffer.byteLength(payload, "utf-8");
     const capped = entry.eventLogBytes >= EVENT_LOG_LIMIT;
     try {
-      appendFileSync8(entry.eventLogPath, capped ? `${payload}{"type":"claudish_truncated","limit_bytes":${EVENT_LOG_LIMIT}}
+      appendFileSync7(entry.eventLogPath, capped ? `${payload}{"type":"claudish_truncated","limit_bytes":${EVENT_LOG_LIMIT}}
 ` : payload);
     } catch {}
   }
@@ -68737,7 +68786,7 @@ ${entry.blockText}` : ""}`;
         wait: "closed",
         since: entry.waitSince ?? at,
         at,
-        to: channelEventFor(snap).event
+        to: sessionEventFor(snap).event
       });
       entry.waitSince = null;
     }
@@ -68749,7 +68798,7 @@ ${entry.blockText}` : ""}`;
 `;
     entry.waitLogBytes += Buffer.byteLength(payload, "utf-8");
     try {
-      appendFileSync8(entry.waitLogPath, payload);
+      appendFileSync7(entry.waitLogPath, payload);
     } catch (err) {
       process.stderr.write(`[claudish] session ${entry.info.sessionId}: could not append to waits.jsonl: ` + `${err instanceof Error ? err.message : String(err)}
 `);
@@ -68883,11 +68932,11 @@ var init_session_manager = __esm(() => {
   SCREEN_READ_BYTES = 64 * 1024;
 });
 
-// src/channel/types.ts
+// src/mcp-session/types.ts
 var init_types3 = () => {};
 
-// src/channel/index.ts
-var init_channel = __esm(() => {
+// src/mcp-session/index.ts
+var init_mcp_session = __esm(() => {
   init_scrollback_buffer();
   init_session_manager();
   init_types3();
@@ -68903,7 +68952,9 @@ This server runs inside a session that a claudish MCP server started (CLAUDISH_P
 - run_prompt or compare_models: a one-shot answer from another model.
 - list_models, search_models: find a model.
 
-Do not start a claudish session another way: \`claudish -p\`, an interactive claudish or \`claudish team\` run from this session's shell exits 64 with "nested session refused".`;
+Do not start a claudish session another way: \`claudish -p\`, an interactive claudish or \`claudish team\` run from this session's shell exits 64 with "nested session refused".
+
+You are the delegate: do the task with your own tools; a workflow step that says to delegate is satisfied by you running it. The claudish-usage skill's section "Inside a claudish session (child mode)" has the details.`;
 var init_nested_mode = __esm(() => {
   NESTED_MCP_TOOL_NAMES = [
     "run_prompt",
@@ -68990,10 +69041,243 @@ var init_progress_heartbeat = __esm(() => {
   });
 });
 
+// src/mcp/run-prompt-claude-code.ts
+import { spawn as spawn2 } from "child_process";
+import { mkdirSync as mkdirSync21, mkdtempSync as mkdtempSync3, rmSync as rmSync5, writeFileSync as writeFileSync22 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join49 } from "path";
+function claudeCodePrintArgv(model, systemPromptFile) {
+  const head = [PRINT_FLAGS[0], "--model", model, ...PRINT_FLAGS.slice(1)];
+  return systemPromptFile !== undefined ? [...head, "--system-prompt-file", systemPromptFile] : [...head, "--system-prompt", ""];
+}
+function claudeCodePrintEnv(parent) {
+  const env = {};
+  for (const [k, v] of Object.entries(parent)) {
+    if (v === undefined || isStrippedFromChildEnv(k))
+      continue;
+    if (PRINT_CHILD_DROPPED_MARKERS.includes(k))
+      continue;
+    env[k] = v;
+  }
+  delete env.ANTHROPIC_API_KEY;
+  delete env.ANTHROPIC_AUTH_TOKEN;
+  delete env.ANTHROPIC_BASE_URL;
+  return env;
+}
+function isFrame(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function parseJsonDocument(stdout) {
+  const text = stdout.trim();
+  if (!text)
+    return;
+  try {
+    return JSON.parse(text);
+  } catch {
+    const lines = text.split(`
+`);
+    for (let i = lines.length - 1;i >= 0; i--) {
+      const line = lines[i].trim();
+      if (!line.startsWith("[") && !line.startsWith("{"))
+        continue;
+      try {
+        return JSON.parse(line);
+      } catch {}
+    }
+    return;
+  }
+}
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+function parseClaudeCodePrintOutput(stdout) {
+  const doc = parseJsonDocument(stdout);
+  const frames = Array.isArray(doc) ? doc.filter(isFrame) : isFrame(doc) ? [doc] : [];
+  let result;
+  let init;
+  for (const f of frames) {
+    if (f.type === "result")
+      result = f;
+    else if (f.type === "system" && f.subtype === "init" && init === undefined)
+      init = f;
+  }
+  if (!result)
+    return null;
+  const parsed = {
+    result: typeof result.result === "string" ? result.result : "",
+    isError: result.is_error === true,
+    apiErrorStatus: typeof result.api_error_status === "number" ? result.api_error_status : null
+  };
+  if (typeof result.terminal_reason === "string")
+    parsed.terminalReason = result.terminal_reason;
+  if (isFrame(result.usage)) {
+    const u = result.usage;
+    parsed.usage = {
+      input: num(u.input_tokens) + num(u.cache_creation_input_tokens) + num(u.cache_read_input_tokens),
+      output: num(u.output_tokens)
+    };
+  }
+  if (init && typeof init.apiKeySource === "string")
+    parsed.apiKeySource = init.apiKeySource;
+  return parsed;
+}
+function authFrom(apiKeySource) {
+  if (apiKeySource === undefined)
+    return;
+  return apiKeySource === "none" ? "subscription" : apiKeySource;
+}
+function killGroup(proc) {
+  const send = (sig) => {
+    if (proc.exitCode !== null || proc.signalCode !== null)
+      return;
+    try {
+      if (proc.pid !== undefined)
+        process.kill(-proc.pid, sig);
+      else
+        proc.kill(sig);
+    } catch {
+      try {
+        proc.kill(sig);
+      } catch {}
+    }
+  };
+  send("SIGTERM");
+  const timer = setTimeout(() => send("SIGKILL"), KILL_GRACE_MS);
+  timer.unref?.();
+}
+function stopAllClaudeCodePrintChildren() {
+  for (const proc of inFlight2)
+    killGroup(proc);
+}
+function stderrTail(stderr) {
+  return sanitizeForReport(stderr.slice(-STDERR_TAIL_CHARS).trim());
+}
+async function runPromptViaClaudeCode(model, prompt, systemPrompt, opts = {}) {
+  const signal = opts.signal;
+  if (signal?.aborted)
+    throw new Error("cancelled");
+  const parentEnv = opts.parentEnv ?? process.env;
+  let launch;
+  try {
+    launch = resolveClaudishLaunch(parentEnv);
+  } catch (e) {
+    throw new Error(`cannot start claudish (${parentEnv.CLAUDISH_BIN?.trim() || "claudish"}): ${e instanceof Error ? e.message : String(e)}`);
+  }
+  const root = mkdtempSync3(join49(tmpdir2(), "claudish-run-prompt-"));
+  try {
+    const cwd = join49(root, "cwd");
+    mkdirSync21(cwd, { mode: 448 });
+    let systemPromptFile;
+    if (typeof systemPrompt === "string" && systemPrompt.length > 0) {
+      systemPromptFile = join49(root, "system-prompt.txt");
+      writeFileSync22(systemPromptFile, systemPrompt, { mode: 384 });
+    }
+    const argv = claudeCodePrintArgv(model, systemPromptFile);
+    const outcome = await runChild(launch, argv, cwd, claudeCodePrintEnv(parentEnv), prompt, signal);
+    if (signal?.aborted)
+      throw new Error("cancelled");
+    const parsed = parseClaudeCodePrintOutput(outcome.stdout);
+    if (parsed === null) {
+      const how = outcome.code !== null ? `exited ${outcome.code}` : `exited ${outcome.signal ?? "?"}`;
+      const tail = stderrTail(outcome.stderr);
+      const noFrame = outcome.code === 0 ? " with no result frame in its output" : "";
+      throw new Error(`claudish -p ${how}${noFrame}${tail ? `: ${tail}` : ""}`);
+    }
+    if (parsed.isError) {
+      const status = parsed.apiErrorStatus !== null ? ` (HTTP ${parsed.apiErrorStatus})` : "";
+      throw new Error(`Claude Code: ${parsed.result || parsed.terminalReason || "error"}${status}`);
+    }
+    if (parsed.result === "")
+      throw new Error("Model returned empty response");
+    const answer = { content: parsed.result };
+    if (parsed.usage)
+      answer.usage = parsed.usage;
+    const auth = authFrom(parsed.apiKeySource);
+    if (auth !== undefined)
+      answer.auth = auth;
+    return answer;
+  } finally {
+    rmSync5(root, { recursive: true, force: true });
+  }
+}
+function runChild(launch, argv, cwd, env, prompt, signal) {
+  return new Promise((resolvePromise, reject) => {
+    let proc;
+    try {
+      proc = spawn2(launch.command, [...launch.prefixArgs, ...argv], {
+        cwd,
+        env,
+        stdio: ["pipe", "pipe", "pipe"],
+        detached: true
+      });
+    } catch (e) {
+      reject(startError(launch.command, e));
+      return;
+    }
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const onAbort = () => killGroup(proc);
+    const finish = (fn) => {
+      if (settled)
+        return;
+      settled = true;
+      inFlight2.delete(proc);
+      signal?.removeEventListener("abort", onAbort);
+      fn();
+    };
+    proc.stdout?.setEncoding("utf8");
+    proc.stderr?.setEncoding("utf8");
+    proc.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    proc.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    proc.stdin?.on("error", () => {});
+    proc.on("error", (e) => finish(() => reject(startError(launch.command, e))));
+    proc.on("close", (code, sig) => finish(() => resolvePromise({ code, signal: sig, stdout, stderr })));
+    inFlight2.add(proc);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted)
+      onAbort();
+    proc.stdin?.end(prompt);
+  });
+}
+function startError(command, e) {
+  const code = e?.code;
+  const detail = typeof code === "string" ? code : e instanceof Error ? e.message : String(e ?? "unknown");
+  return new Error(`cannot start claudish (${command}): ${detail}`);
+}
+var PRINT_FLAGS, PRINT_CHILD_DROPPED_MARKERS, inFlight2, KILL_GRACE_MS = 5000, STDERR_TAIL_CHARS = 2000;
+var init_run_prompt_claude_code = __esm(() => {
+  init_config();
+  init_child_env();
+  init_pane_launch();
+  init_redact();
+  PRINT_FLAGS = [
+    "-p",
+    "--output-format",
+    "json",
+    "--tools",
+    "",
+    "--strict-mcp-config",
+    "--setting-sources",
+    "",
+    "--disable-slash-commands",
+    "--no-session-persistence"
+  ];
+  PRINT_CHILD_DROPPED_MARKERS = [
+    ...PANE_LAUNCH_VARS,
+    ENV.CLAUDISH_PANE_CHILD
+  ];
+  inFlight2 = new Set;
+});
+
 // src/mcp-server.ts
-import { existsSync as existsSync32, mkdirSync as mkdirSync21, readFileSync as readFileSync31, readdirSync as readdirSync10, writeFileSync as writeFileSync22 } from "fs";
+import { existsSync as existsSync32, mkdirSync as mkdirSync22, readFileSync as readFileSync31, readdirSync as readdirSync10, writeFileSync as writeFileSync23 } from "fs";
 import { homedir as homedir33 } from "os";
-import { dirname as dirname14, join as join49, resolve as resolve6 } from "path";
+import { dirname as dirname14, join as join50, resolve as resolve6 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 async function loadAllModels(forceRefresh = false) {
   if (!forceRefresh && existsSync32(OPENROUTER_MODELS_CACHE_PATH)) {
@@ -69012,8 +69296,8 @@ async function loadAllModels(forceRefresh = false) {
       throw new Error(`API returned ${response.status}`);
     const data = await response.json();
     const models = data.data || [];
-    mkdirSync21(CLAUDISH_CACHE_DIR, { recursive: true });
-    writeFileSync22(OPENROUTER_MODELS_CACHE_PATH, JSON.stringify({ lastUpdated: new Date().toISOString(), models }), "utf-8");
+    mkdirSync22(CLAUDISH_CACHE_DIR, { recursive: true });
+    writeFileSync23(OPENROUTER_MODELS_CACHE_PATH, JSON.stringify({ lastUpdated: new Date().toISOString(), models }), "utf-8");
     return models;
   } catch {
     if (existsSync32(OPENROUTER_MODELS_CACHE_PATH)) {
@@ -69069,12 +69353,11 @@ function parseAnthropicSse(raw) {
   }
   return { text, usage: hasUsage ? { input: inputTokens, output: outputTokens } : undefined };
 }
-async function runPromptViaProxy(model, prompt, systemPrompt, maxTokens) {
+async function runPromptViaProxy(model, prompt, systemPrompt) {
   const proxy = await getProxy();
   const body = {
     model,
     messages: [{ role: "user", content: prompt }],
-    max_tokens: maxTokens || 4096,
     stream: true
   };
   if (systemPrompt) {
@@ -69096,6 +69379,26 @@ async function runPromptViaProxy(model, prompt, systemPrompt, maxTokens) {
   }
   return { content: parsed.text, usage: parsed.usage };
 }
+async function runPrompt(model, prompt, systemPrompt, signal) {
+  if (nativeRouteFor(model) !== null) {
+    return runPromptViaClaudeCode(model, prompt, systemPrompt, { signal });
+  }
+  return runPromptViaProxy(model, prompt, systemPrompt);
+}
+function formatRunPromptResult(result) {
+  const footer = [];
+  if (result.usage) {
+    footer.push(`Tokens: ${result.usage.input} input, ${result.usage.output} output`);
+  }
+  if (result.auth !== undefined) {
+    footer.push(result.auth === "subscription" ? "Auth: Claude Code login (subscription)" : `Auth: ${result.auth}`);
+  }
+  return footer.length > 0 ? `${result.content}
+
+---
+${footer.join(`
+`)}` : result.content;
+}
 function fuzzyScore(text, query) {
   const lowerText = text.toLowerCase();
   const lowerQuery = query.toLowerCase();
@@ -69310,7 +69613,7 @@ async function teamContractVerb(mode, args) {
     return contractErrorAnswer(e);
   }
 }
-function defineTools(sessionManager, notifyChannel, nested) {
+function defineTools(sessionManager, nested) {
   const tools = [];
   const reportHint = (text) => nested ? "" : text;
   function withOpFailureContext(message, subject) {
@@ -69322,33 +69625,25 @@ ${block.join(`
   }
   tools.push({
     name: "run_prompt",
-    description: "Run a prompt through any model \u2014 supports all providers (Kimi, GLM, Qwen, MiniMax, Gemini, GPT, Grok, etc.) with auto-routing, fallback chains, and custom routing rules.",
+    description: "One quick prompt, straight to one model's API: a single request and its answer. No " + "Claude Code session, no tools, no files, no conversation state \u2014 this is not subagent " + "work. For a task that needs tools, files or more than one turn, use create_session " + "(one model) or team (several models). Non-Claude models (Kimi, GLM, Qwen, MiniMax, " + "Gemini, GPT, Grok, \u2026) go through claudish's routing straight to the provider's API. " + "A Claude model name (claude-*, opus, sonnet, haiku) runs as one Claude Code " + "print-mode call on the user's own Claude Code login, with tools, MCP servers and " + "settings off.",
     inputSchema: {
       type: "object",
       properties: {
         model: {
           type: "string",
-          description: "Model name or ID. Short names auto-route to the best provider (e.g., 'kimi-k2.5', 'glm-5', 'gpt-5.4'). Provider prefix optional (e.g., 'google@gemini-3.1-pro-preview', 'or@x-ai/grok-3')."
+          description: "Model name or model spec. A bare name auto-routes to the best provider; " + "'provider@model' pins the provider (e.g. 'google@gemini-4-argon', " + "'or@x-ai/grok-4.7'). A bare Claude name (claude-*, opus, sonnet, haiku) runs on " + "Claude Code's own login."
         },
         prompt: { type: "string", description: "The prompt to send to the model" },
-        system_prompt: { type: "string", description: "Optional system prompt" },
-        max_tokens: { type: "number", description: "Maximum tokens in response (default: 4096)" }
+        system_prompt: { type: "string", description: "Optional system prompt" }
       },
       required: ["model", "prompt"]
     },
     group: "low-level",
     heartbeat: true,
-    handler: async (args) => {
+    handler: async (args, ctx) => {
       try {
-        const result = await runPromptViaProxy(args.model, args.prompt, args.system_prompt, args.max_tokens);
-        let response = result.content;
-        if (result.usage) {
-          response += `
-
----
-Tokens: ${result.usage.input} input, ${result.usage.output} output`;
-        }
-        return { content: [{ type: "text", text: response }] };
+        const result = await runPrompt(args.model, args.prompt, args.system_prompt, ctx.signal);
+        return { content: [{ type: "text", text: formatRunPromptResult(result) }] };
       } catch (error) {
         const errMsg = error instanceof Error ? error.message : String(error);
         return {
@@ -69500,35 +69795,30 @@ Use with: run_prompt(model="${suggested}", prompt="your prompt")`;
   });
   tools.push({
     name: "compare_models",
-    description: "Run the same prompt through multiple models and compare responses",
+    description: "DEBUG. Send the same single prompt to several models, one after another, and show " + "their answers side by side \u2014 to check that routes answer or to eyeball raw answers. " + "Each model gets exactly what run_prompt sends: one request, no tools, no Claude Code " + "session. Not for real work: use team for a blind-judged multi-model run, or " + "create_session for one model doing a task.",
     inputSchema: {
       type: "object",
       properties: {
         models: {
           type: "array",
           items: { type: "string" },
-          description: "List of model IDs to compare"
+          description: "List of model names or model specs to compare, in the order to run them"
         },
         prompt: { type: "string", description: "The prompt to send to all models" },
-        system_prompt: { type: "string", description: "Optional system prompt" },
-        max_tokens: {
-          type: "number",
-          description: "Maximum tokens in response (omit to let model decide)"
-        }
+        system_prompt: { type: "string", description: "Optional system prompt" }
       },
       required: ["models", "prompt"]
     },
-    group: "low-level",
+    group: "debug",
     heartbeat: true,
     handler: async (args, ctx) => {
       const modelIds = args.models;
       const prompt = args.prompt;
       const systemPrompt = args.system_prompt;
-      const maxTokens = args.max_tokens;
       const results = [];
       for (const model of modelIds) {
         try {
-          const result = await runPromptViaProxy(model, prompt, systemPrompt, maxTokens);
+          const result = await runPrompt(model, prompt, systemPrompt, ctx.signal);
           results.push({ model, response: result.content, tokens: result.usage });
         } catch (error) {
           results.push({
@@ -69782,28 +70072,18 @@ Use with: run_prompt(model="${suggested}", prompt="your prompt")`;
         const minOutputBytes = args.min_output_bytes;
         const childFlags = buildChildClaudeFlags(args.agent, args.claude_flags) ?? [];
         const resolved = validateSessionPath(path);
-        const teamSessionId = resolved.split("/").filter(Boolean).pop() ?? "team";
-        const teamCreatedAt = new Date().toISOString();
         const runOpts = {
           requirePattern,
           minOutputBytes,
           claudeFlags: childFlags,
           onProgress: (u) => {
             ctx.reportProgress(`team: ${u.phase}`);
-            notifyChannel({
-              content: u.rendered,
-              sessionId: teamSessionId,
-              event: u.phase === "settled" ? u.allFailed ? "failed" : "completed" : "running",
-              model: "team",
-              elapsedSeconds: (Date.now() - Date.parse(teamCreatedAt)) / 1000,
-              createdAt: teamCreatedAt
-            });
           }
         };
         const promptText = () => {
           if (input !== undefined)
             return input;
-          const existing = join49(resolved, "input.md");
+          const existing = join50(resolved, "input.md");
           return existsSync32(existing) ? readFileSync31(existing, "utf-8") : undefined;
         };
         switch (mode) {
@@ -69962,16 +70242,16 @@ Use with: run_prompt(model="${suggested}", prompt="your prompt")`;
         const sp = session_path;
         for (const file of ["status.json", "manifest.json", "input.md"]) {
           try {
-            sessionData[file] = readFileSync31(join49(sp, file), "utf-8");
+            sessionData[file] = readFileSync31(join50(sp, file), "utf-8");
           } catch {}
         }
         try {
-          const errorDir = join49(sp, "errors");
+          const errorDir = join50(sp, "errors");
           if (existsSync32(errorDir)) {
             for (const f of readdirSync10(errorDir)) {
               if (f.endsWith(".log")) {
                 try {
-                  sessionData[`errors/${f}`] = readFileSync31(join49(errorDir, f), "utf-8");
+                  sessionData[`errors/${f}`] = readFileSync31(join50(errorDir, f), "utf-8");
                 } catch {}
               }
             }
@@ -69981,7 +70261,7 @@ Use with: run_prompt(model="${suggested}", prompt="your prompt")`;
           for (const f of readdirSync10(sp)) {
             if (f.startsWith("response-") && f.endsWith(".md")) {
               try {
-                const content = readFileSync31(join49(sp, f), "utf-8");
+                const content = readFileSync31(join50(sp, f), "utf-8");
                 sessionData[f] = content.slice(0, 200) + (content.length > 200 ? "... (truncated)" : "");
               } catch {}
             }
@@ -69990,7 +70270,7 @@ Use with: run_prompt(model="${suggested}", prompt="your prompt")`;
       }
       let version = "unknown";
       try {
-        const pkgPath = join49(__dirname3, "../package.json");
+        const pkgPath = join50(__dirname3, "../package.json");
         if (existsSync32(pkgPath)) {
           version = JSON.parse(readFileSync31(pkgPath, "utf-8")).version;
         }
@@ -70070,7 +70350,7 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
   });
   tools.push({
     name: "create_session",
-    description: "Create a new claudish proxy session for an external model: an interactive Claude Code running " + "it in its own headless magmux pane. Returns at once with state STARTING; the session produces " + "channel notifications as it runs. With a prompt it is one-shot (it ends when that turn " + "settles); without one it is interactive and waits for send_input. Needs magmux >= 0.14.0 " + "(darwin and linux).",
+    description: "Create a new claudish proxy session for an external model: an interactive Claude Code running " + "it in its own headless magmux pane. Returns at once with state STARTING; nothing is " + "pushed while it runs: poll list_sessions (about once every 10 s) for its state, then " + "call get_output once it is COMPLETED. With a prompt it is one-shot (it ends when that turn " + "settles); without one it is interactive and waits for send_input. Needs magmux >= 0.14.0 " + "(darwin and linux).",
     inputSchema: {
       type: "object",
       properties: {
@@ -70103,7 +70383,7 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
       },
       required: ["model"]
     },
-    group: "channel",
+    group: "session",
     handler: async (args) => {
       try {
         const claudishFlags = buildChildClaudeFlags(args.agent, args.claude_flags) ?? [];
@@ -70171,7 +70451,7 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
       },
       required: ["session_id", "text"]
     },
-    group: "channel",
+    group: "session",
     handler: async (args) => {
       const result = sessionManager.sendInput(args.session_id, args.text);
       return {
@@ -70181,7 +70461,7 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
   });
   tools.push({
     name: "get_output",
-    description: "Get a session's answer prose (each settled turn's assistant text, from its transcript). " + "Call after the 'completed' notification to get the full response.",
+    description: "Get a session's answer prose (each settled turn's assistant text, from its transcript). " + "Call once list_sessions shows the session COMPLETED (or between turns of an " + "interactive session).",
     inputSchema: {
       type: "object",
       properties: {
@@ -70193,7 +70473,7 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
       },
       required: ["session_id"]
     },
-    group: "channel",
+    group: "session",
     handler: async (args) => {
       try {
         const output = sessionManager.getOutput(args.session_id, args.tail_lines);
@@ -70223,7 +70503,7 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
       },
       required: ["session_id"]
     },
-    group: "channel",
+    group: "session",
     handler: async (args) => {
       try {
         const sessionId = optionalString(args.session_id, "session_id");
@@ -70237,7 +70517,7 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
   });
   tools.push({
     name: "list_sessions",
-    description: "List channel sessions: {contract_version, capabilities, sessions}. Optionally include " + "finished ones. Each row reports `state`, `activity` and `idle_seconds`: how long since " + "the session's screen or transcript last changed. Nothing kills a session for being " + "idle \u2014 a child inside a long Bash call is silent and working \u2014 so this is yours to " + "judge against the task you set, and `cancel_session` is yours to call if the answer is no.",
+    description: "List sessions: {contract_version, capabilities, sessions}. Optionally include " + "finished ones. Each row reports `state`, `activity` and `idle_seconds`: how long since " + "the session's screen or transcript last changed. Nothing kills a session for being " + "idle \u2014 a child inside a long Bash call is silent and working \u2014 so this is yours to " + "judge against the task you set, and `cancel_session` is yours to call if the answer is no. " + "A failed row's `reason_detail` is one line saying why (for api_error, the provider's " + "own error message); it is null while the session is live and on COMPLETED.",
     inputSchema: {
       type: "object",
       properties: {
@@ -70247,7 +70527,7 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
         }
       }
     },
-    group: "channel",
+    group: "session",
     handler: async (args) => {
       try {
         const includeCompleted = optionalBoolean(args.include_completed, "include_completed");
@@ -70262,7 +70542,7 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
   });
   tools.push({
     name: "get_diagnostics",
-    description: "Explain what a channel session actually did \u2014 its final screen, upstream error bodies, " + "the recent state records, anomalies, the resolved model chain, accounting, and the paths " + "to the full records (transcript included). Call this FIRST whenever a session fails, times " + "out, or completes with empty or surprising output; it needs no re-run and no debug flag. " + "`idleSeconds` reports how long since the screen or transcript last changed, and is null " + "once the session is no longer live. It is information, never a verdict: claudish does " + "not terminate a session for silence.",
+    description: "Explain what a session actually did \u2014 its final screen, upstream error bodies, " + "the recent state records, anomalies, the resolved model chain, accounting, and the paths " + "to the full records (transcript included). Call this FIRST whenever a session fails, times " + "out, or completes with empty or surprising output; it needs no re-run and no debug flag. " + "`idleSeconds` reports how long since the screen or transcript last changed, and is null " + "once the session is no longer live. It is information, never a verdict: claudish does " + "not terminate a session for silence.",
     inputSchema: {
       type: "object",
       properties: {
@@ -70274,7 +70554,7 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
       },
       required: ["session_id"]
     },
-    group: "channel",
+    group: "session",
     handler: async (args) => {
       try {
         const diagnostics = sessionManager.getDiagnostics(args.session_id, args.event_limit);
@@ -70312,7 +70592,7 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
       },
       required: ["session_id"]
     },
-    group: "channel",
+    group: "session",
     handler: async (args) => {
       try {
         const sessionId = optionalString(args.session_id, "session_id");
@@ -70334,77 +70614,34 @@ function resolveToolGroups(mode) {
       return new Set(["low-level"]);
     case "agentic":
       return new Set(["agentic"]);
-    case "channel":
-      return new Set(["channel"]);
+    case "session":
+      return new Set(["session"]);
+    case "debug":
+      return new Set(["debug"]);
     default:
-      return new Set(["low-level", "agentic", "channel"]);
+      return new Set(["low-level", "agentic", "session", "debug"]);
   }
 }
-function mapEventToTaskStatus(event) {
-  return EVENT_TO_TASK_STATUS.get(event) ?? "working";
+function unknownToolModeWarning(mode) {
+  if (TOOL_MODES.includes(mode))
+    return;
+  const renamed = mode === "channel" ? " (`channel` was renamed to `session`)" : "";
+  return `[claudish] CLAUDISH_MCP_TOOLS=${JSON.stringify(mode)} is not a tool mode${renamed}; selecting all tools. Valid values: ${TOOL_MODES.join(", ")}`;
 }
 async function main() {
   const toolMode = (process.env.CLAUDISH_MCP_TOOLS || "all").toLowerCase();
   const nested = inMcpSession();
   const enabledGroups = resolveToolGroups(toolMode);
-  const channelEnabled = !nested && enabledGroups.has("channel");
-  const server = new Server({ name: "claudish", version: "9.0.0" }, {
-    capabilities: {
-      ...channelEnabled ? { experimental: { "claude/channel": {} } } : {},
-      tools: {}
-    },
+  const toolModeWarning = unknownToolModeWarning(toolMode);
+  if (toolModeWarning)
+    console.error(toolModeWarning);
+  const server = new Server({ name: "claudish", version: VERSION }, {
+    capabilities: { tools: {} },
     instructions: nested ? NESTED_INSTRUCTIONS : INSTRUCTIONS
   });
-  const sessionManager = new SessionManager({
-    onStateChange: wrapStateChange((sessionId, event) => {
-      const notificationContent = event.type === "failed" || event.type === "timeout" ? `${event.content}
-
-Call get_diagnostics with session_id: "${sessionId}" for the final screen, the upstream error bodies and the transcript path. To report it, use the report_error tool with error_type: "provider_failure" and model: "${event.model}".` : event.content;
-      const result = server.notification({
-        method: "notifications/claude/channel",
-        params: {
-          content: notificationContent,
-          meta: {
-            session_id: sessionId,
-            event: event.type,
-            model: event.model,
-            elapsed_seconds: String(event.elapsedSeconds),
-            task_id: sessionId,
-            status: mapEventToTaskStatus(event.type),
-            created_at: event.createdAt,
-            last_updated_at: new Date().toISOString(),
-            ...event.extraMeta
-          }
-        }
-      });
-      watchNotificationResult(result, { sessionId, eventType: event.type });
-    })
-  });
-  const notifyChannel = (p) => {
-    if (!channelEnabled)
-      return;
-    try {
-      const result = server.notification({
-        method: "notifications/claude/channel",
-        params: {
-          content: p.content,
-          meta: {
-            session_id: p.sessionId,
-            event: p.event,
-            model: p.model,
-            elapsed_seconds: String(Math.round(p.elapsedSeconds)),
-            task_id: p.sessionId,
-            status: mapEventToTaskStatus(p.event),
-            created_at: p.createdAt,
-            last_updated_at: new Date().toISOString()
-          }
-        }
-      });
-      watchNotificationResult(result, { sessionId: p.sessionId, eventType: p.event });
-    } catch {}
-  };
+  const sessionManager = new SessionManager;
   const progressIntervalMs = resolveProgressIntervalMs();
-  const allTools = defineTools(sessionManager, notifyChannel, nested);
+  const allTools = defineTools(sessionManager, nested);
   const nestedNames = NESTED_MCP_TOOL_NAMES;
   const enabledTools = allTools.filter((t) => enabledGroups.has(t.group) && (!nested || nestedNames.includes(t.name)));
   const toolMap = new Map(enabledTools.map((t) => [t.name, t]));
@@ -70432,7 +70669,8 @@ Call get_diagnostics with session_id: "${sessionId}" for the final screen, the u
       send: (frame) => extra.sendNotification({ method: "notifications/progress", params: frame })
     }) : NOOP_HEARTBEAT;
     const ctx = {
-      reportProgress: (message) => heartbeat.tick(message)
+      reportProgress: (message) => heartbeat.tick(message),
+      signal: extra.signal
     };
     try {
       return await tool.handler(args ?? {}, ctx);
@@ -70451,7 +70689,6 @@ Call get_diagnostics with session_id: "${sessionId}" for the final screen, the u
     }
   });
   const transport = new StdioServerTransport;
-  installWireTap();
   await server.connect(transport);
   installMcpShutdown(sessionManager);
   ensureSwept(sockRootFor()).catch(() => {
@@ -70460,6 +70697,7 @@ Call get_diagnostics with session_id: "${sessionId}" for the final screen, the u
 }
 function installMcpShutdown(sessionManager) {
   const before = async () => {
+    stopAllClaudeCodePrintChildren();
     await Promise.allSettled([shutdownAllTeamRuns(), sessionManager.shutdownAll()]);
   };
   installPaneShutdownHooks({ stdin: true, before });
@@ -70470,50 +70708,43 @@ function startMcpServer() {
     process.exit(1);
   });
 }
-var import_dotenv2, __filename3, __dirname3, CLAUDISH_CACHE_DIR, OPENROUTER_MODELS_CACHE_PATH, CACHE_MAX_AGE_DAYS = 2, INSTRUCTIONS = `Claudish MCP server provides access to external AI models (OpenRouter, Ollama, LM Studio, etc.) for coding tasks.
-
-## Channel Mode \u2014 External Model Sessions
+var import_dotenv2, __filename3, __dirname3, CLAUDISH_CACHE_DIR, OPENROUTER_MODELS_CACHE_PATH, CACHE_MAX_AGE_DAYS = 2, INSTRUCTIONS = `Claudish MCP server gives you access to external AI models (OpenRouter, Ollama, LM Studio and every claudish provider), and to Claude models on the user's own Claude Code login.
 
-When channel mode is active, you receive <channel source="claudish" ...> notifications about running external model sessions. Each session is an interactive Claude Code running the model in its own headless terminal pane.
+## Which tool
 
-### Events
+- run_prompt: one quick prompt to one model's API. One request, one answer; no tools, no files, no session.
+- create_session: one model doing a task as a full Claude Code session (tools, files, several turns).
+- team: several models on the same task, each a full Claude Code session, with optional blind judging.
 
-- running: The session's turn is running (its prompt was accepted). Note the session_id for future calls.
-- tool_executing: The model is using a tool (Read, Write, Bash, etc.). Carries tool and tool_count.
-- input_required (event waiting_for_input): The session waits for send_input: an interactive session between turns, or a session stopped on a question (meta activity "AskUserQuestion"). A send declines a question and becomes the next prompt.
-- input_required (event awaiting_permission): A permission or plan-approval dialog is open. A send declines it and becomes the next prompt.
-- completed: The session finished successfully. Call get_output to retrieve the full output.
-- failed: The session failed (boot, prompt not accepted or not read, child exited, API error, pane lost). Call get_diagnostics for the cause.
-- timeout: The session hit its timeout_seconds; the pane was closed. Call get_diagnostics to see how far it got.
-- cancelled: The session was cancelled via cancel_session.
+## Sessions
 
-### Workflow
+Each session is an interactive Claude Code running the model in its own headless terminal pane. Nothing is pushed to you while it runs: poll.
 
-1. Call create_session with a model and prompt to start an async session (state STARTING while Claude Code boots).
-2. Watch for <channel> notifications \u2014 they arrive automatically.
-3. send_input may be called at any time; it is queued until the session is idle. On input_required, call send_input with the answer.
-4. On completed: call get_output to get the full response.
-5. On failed or timeout \u2014 or on a completed session whose output is empty or
-   surprising \u2014 call get_diagnostics. It returns the child's final screen, the
-   upstream error bodies, the recent state records, the resolved model chain and the
-   paths to the full records. It needs no re-run and no debug flag.
-6. Use list_sessions to see sessions: each row has state, activity, idle_seconds and accounting.
-7. Use capture_session to read a session's current terminal screen.
-8. Use cancel_session to stop a running session.
+1. create_session returns {session_id, state: "STARTING"} at once while Claude Code boots.
+2. Poll list_sessions (include_completed: true), about once every 10 seconds. Each row has state, activity, idle_seconds and accounting.
+   - STARTING: booting, or the first prompt is not yet accepted.
+   - RUNNING: a turn is in progress (activity names the tool in use).
+   - AWAITING_INPUT: waiting for send_input \u2014 an interactive session between turns, or a turn stopped on a question (activity "AskUserQuestion"). A send declines a question and becomes the next prompt.
+   - AWAITING_PERMISSION: a permission or plan-approval dialog is open. A send declines it and becomes the next prompt.
+   - COMPLETED, FAILED, TIMEOUT, CANCELLED, EMPTY: finished.
+3. send_input may be called at any time; it is queued until the session is idle.
+4. COMPLETED: call get_output for the answer.
+5. FAILED or TIMEOUT \u2014 or COMPLETED with an empty or surprising answer \u2014 call get_diagnostics. It returns the child's final screen, the upstream error bodies, the recent state records, the resolved model chain and the paths to the full records. It needs no re-run and no debug flag.
+6. capture_session reads a session's current screen; cancel_session stops it. Nothing stops a session for being idle: a child inside a long build is silent and working.
 
-The session_id in the channel tag's meta attributes is the key for all tool calls.`, proxyInstance = null, proxyStarting = null, SCORE_TIE_EPSILON = 0.000001, NEXT_STEP, sanitize2, TASK_STATUS_BY_EVENT, EVENT_TO_TASK_STATUS;
+The session_id from create_session is the key for every session tool.`, proxyInstance = null, proxyStarting = null, SCORE_TIE_EPSILON = 0.000001, NEXT_STEP, sanitize2, TOOL_MODES;
 var init_mcp_server = __esm(() => {
   init_server2();
   init_stdio2();
   init_types();
   init_model_catalog();
   init_prehydrate();
-  init_diagnostics();
-  init_channel();
-  init_parent_session();
   init_remote_provider_types();
+  init_mcp_session();
+  init_parent_session();
   init_nested_mode();
   init_progress_heartbeat();
+  init_run_prompt_claude_code();
   init_model_loader();
   init_child_env();
   init_pane();
@@ -70532,8 +70763,8 @@ var init_mcp_server = __esm(() => {
   import_dotenv2.config({ quiet: true });
   __filename3 = fileURLToPath3(import.meta.url);
   __dirname3 = dirname14(__filename3);
-  CLAUDISH_CACHE_DIR = join49(homedir33(), ".claudish");
-  OPENROUTER_MODELS_CACHE_PATH = join49(CLAUDISH_CACHE_DIR, "openrouter-models.json");
+  CLAUDISH_CACHE_DIR = join50(homedir33(), ".claudish");
+  OPENROUTER_MODELS_CACHE_PATH = join50(CLAUDISH_CACHE_DIR, "openrouter-models.json");
   NEXT_STEP = {
     cancelled: "you stopped this slot; nothing is wrong with it. Re-run it if you still want its vote",
     timeout: "grid mode only \u2014 magmux ended the pane. The orchestrator has no deadline",
@@ -70552,18 +70783,7 @@ var init_mcp_server = __esm(() => {
     shape_mismatch: "the answer (assistant text after the task was read) did not match. Every assistant " + "message of the turn was read from the transcript, so nothing was lost in transit \u2014 " + "the model did not produce it. Re-prompt with the required format restated; do NOT " + "count this slot as a vote"
   };
   sanitize2 = sanitizeForReport;
-  TASK_STATUS_BY_EVENT = {
-    starting: "working",
-    running: "working",
-    tool_executing: "working",
-    waiting_for_input: "input_required",
-    awaiting_permission: "input_required",
-    completed: "completed",
-    failed: "failed",
-    cancelled: "cancelled",
-    timeout: "failed"
-  };
-  EVENT_TO_TASK_STATUS = new Map(Object.entries(TASK_STATUS_BY_EVENT));
+  TOOL_MODES = ["all", "low-level", "agentic", "session", "debug"];
 });
 
 // src/serve-command.ts
@@ -70666,7 +70886,7 @@ var init_serve_command = __esm(() => {
 });
 
 // src/behavior-command.ts
-import { existsSync as existsSync34, readFileSync as readFileSync33, writeFileSync as writeFileSync23 } from "fs";
+import { existsSync as existsSync34, readFileSync as readFileSync33, writeFileSync as writeFileSync24 } from "fs";
 function severityColor(sev) {
   if (sev === "fix")
     return green(sev);
@@ -70774,7 +70994,7 @@ function setTelemetryEnabled(value) {
   const behavior = cfg.behavior && typeof cfg.behavior === "object" && !Array.isArray(cfg.behavior) ? { ...cfg.behavior } : {};
   behavior.telemetry = { enabled: value };
   cfg.behavior = behavior;
-  writeFileSync23(path, `${JSON.stringify(cfg, null, 2)}
+  writeFileSync24(path, `${JSON.stringify(cfg, null, 2)}
 `, "utf-8");
 }
 function showTelemetry(action, json) {
@@ -70866,10 +71086,10 @@ var init_behavior_command = __esm(() => {
 });
 
 // src/team-grid.ts
-import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync35, readFileSync as readFileSync34, writeFileSync as writeFileSync24 } from "fs";
+import { spawn as spawn3 } from "child_process";
+import { existsSync as existsSync35, readFileSync as readFileSync34, writeFileSync as writeFileSync25 } from "fs";
 import { connect as netConnect2 } from "net";
-import { join as join50 } from "path";
+import { join as join51 } from "path";
 import { setTimeout as wait } from "timers/promises";
 function paneRouteLine(explanation) {
   const origin = describeRouteExplanation(explanation);
@@ -71019,9 +71239,9 @@ async function runWithGrid(sessionPath, models, input, opts) {
   const keep = opts?.keep ?? false;
   const manifest = setupSession(sessionPath, models, input);
   const startedAt = new Date().toISOString();
-  const gridfilePath = join50(sessionPath, "gridfile.txt");
-  const prompt = readFileSync34(join50(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
-  const rawPrompt = readFileSync34(join50(sessionPath, "input.md"), "utf-8");
+  const gridfilePath = join51(sessionPath, "gridfile.txt");
+  const prompt = readFileSync34(join51(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
+  const rawPrompt = readFileSync34(join51(sessionPath, "input.md"), "utf-8");
   const usedBannerColors = new Set;
   const routeLines = mode === "interactive" ? new Map : await resolvePaneRouteLines(Object.values(manifest.models).map((entry) => entry.model));
   const gridLines = Object.entries(manifest.models).map(([anonId]) => {
@@ -71033,7 +71253,7 @@ async function runWithGrid(sessionPath, models, input, opts) {
     const header = buildPaneHeader(model, routeLines.get(model) ?? "", rawPrompt, bg);
     return `${header} claudish --model ${model} -y --quiet '${prompt}'`;
   });
-  writeFileSync24(gridfilePath, `${gridLines.join(`
+  writeFileSync25(gridfilePath, `${gridLines.join(`
 `)}
 `, "utf-8");
   const magmuxPath = findMagmuxBinary();
@@ -71041,7 +71261,7 @@ async function runWithGrid(sessionPath, models, input, opts) {
   if (!keep && mode === "default") {
     spawnArgs.push("-w");
   }
-  const proc = spawn2(magmuxPath, spawnArgs, {
+  const proc = spawn3(magmuxPath, spawnArgs, {
     stdio: "inherit",
     env: { ...process.env }
   });
@@ -71053,8 +71273,8 @@ async function runWithGrid(sessionPath, models, input, opts) {
   });
   const [{ results }] = await Promise.all([subscription, procExit]);
   const status = buildTeamStatus(manifest, startedAt, results?.panes ?? null);
-  const statusPath = join50(sessionPath, "status.json");
-  writeFileSync24(statusPath, JSON.stringify(status, null, 2), "utf-8");
+  const statusPath = join51(sessionPath, "status.json");
+  writeFileSync25(statusPath, JSON.stringify(status, null, 2), "utf-8");
   return status;
 }
 var BANNER_BG_COLORS;
@@ -71074,7 +71294,7 @@ var init_team_grid = __esm(() => {
 
 // src/team-cli.ts
 import { readFileSync as readFileSync35 } from "fs";
-import { join as join51 } from "path";
+import { join as join52 } from "path";
 async function runPaneTeam(sessionPath, models, input, opts) {
   installPaneShutdownHooks({ exitAfter: true });
   try {
@@ -71212,7 +71432,7 @@ async function teamCommand(args) {
     }
     case "judge": {
       await judgeResponses(sessionPath, { judges });
-      console.log(readFileSync35(join51(sessionPath, "verdict.md"), "utf-8"));
+      console.log(readFileSync35(join52(sessionPath, "verdict.md"), "utf-8"));
       break;
     }
     case "run-and-judge": {
@@ -71228,7 +71448,7 @@ async function teamCommand(args) {
       });
       printStatus(status);
       await judgeResponses(sessionPath, { judges });
-      console.log(readFileSync35(join51(sessionPath, "verdict.md"), "utf-8"));
+      console.log(readFileSync35(join52(sessionPath, "verdict.md"), "utf-8"));
       break;
     }
     case "status": {
@@ -71802,7 +72022,7 @@ var init_keychain_command = __esm(() => {
 import { spawnSync as spawnSync2 } from "child_process";
 import { existsSync as existsSync36, unlinkSync as unlinkSync9 } from "fs";
 import { homedir as homedir34 } from "os";
-import { join as join52 } from "path";
+import { join as join53 } from "path";
 async function defaultSuggestModel() {
   try {
     const tok = readSharedAntigravityToken();
@@ -71923,7 +72143,7 @@ No session detected yet. Starting the Antigravity CLI interactively \u2014
   async logout(deps) {
     deleteSharedAntigravityToken(deps);
     try {
-      const tokenFile = join52(homedir34(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
+      const tokenFile = join53(homedir34(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
       if (existsSync36(tokenFile))
         unlinkSync9(tokenFile);
     } catch {}
@@ -80185,20 +80405,20 @@ var init_terminal_isolation = __esm(() => {
 });
 
 // src/claude-runner.ts
-import { spawn as spawn3, spawnSync as spawnSync4 } from "child_process";
+import { spawn as spawn4, spawnSync as spawnSync4 } from "child_process";
 import {
-  closeSync as closeSync10,
+  closeSync as closeSync11,
   existsSync as existsSync38,
-  mkdirSync as mkdirSync22,
-  openSync as openSync10,
+  mkdirSync as mkdirSync23,
+  openSync as openSync11,
   readFileSync as readFileSync36,
   readdirSync as readdirSync11,
   statSync as statSync13,
   unlinkSync as unlinkSync10,
-  writeFileSync as writeFileSync25
+  writeFileSync as writeFileSync26
 } from "fs";
-import { homedir as homedir35, tmpdir as tmpdir2 } from "os";
-import { dirname as dirname15, join as join53 } from "path";
+import { homedir as homedir35, tmpdir as tmpdir3 } from "os";
+import { dirname as dirname15, join as join54 } from "path";
 import { isatty } from "tty";
 function releaseTerminalIsolation() {
   if (!restoreTerminal)
@@ -80263,7 +80483,7 @@ function hasResolvableAnthropicAuth(deps = {}) {
   if (isRealAnthropicEnvCredential(env, "ANTHROPIC_API_KEY") || isRealAnthropicEnvCredential(env, "ANTHROPIC_AUTH_TOKEN")) {
     return true;
   }
-  if (fileExists(join53(homedir35(), ".claude", ".credentials.json")))
+  if (fileExists(join54(homedir35(), ".claude", ".credentials.json")))
     return true;
   return keychainProbe();
 }
@@ -80278,7 +80498,7 @@ function isProxyAuthMode(config) {
 }
 function managedSettingsPath() {
   if (isWindows2()) {
-    return join53(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
+    return join54(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
   }
   if (process.platform === "darwin") {
     return "/Library/Application Support/ClaudeCode/managed-settings.json";
@@ -80298,10 +80518,10 @@ function isWindows2() {
   return process.platform === "win32";
 }
 function createStatusLineScript(tokenFilePath) {
-  const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join53(homeDir, ".claudish");
+  const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir3();
+  const claudishDir = join54(homeDir, ".claudish");
   const timestamp = Date.now();
-  const scriptPath = join53(claudishDir, `status-${timestamp}.js`);
+  const scriptPath = join54(claudishDir, `status-${timestamp}.js`);
   const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
   const light = getThemeMode() === "light";
   const cyanCode = light ? "38;2;14;116;144" : "96";
@@ -80434,13 +80654,13 @@ process.stdin.on('end', () => {
   }
 });
 `;
-  writeFileSync25(scriptPath, script, "utf-8");
+  writeFileSync26(scriptPath, script, "utf-8");
   return scriptPath;
 }
 function initializeTokenFile(tokenFilePath) {
   try {
-    mkdirSync22(dirname15(tokenFilePath), { recursive: true });
-    writeFileSync25(tokenFilePath, JSON.stringify({
+    mkdirSync23(dirname15(tokenFilePath), { recursive: true });
+    writeFileSync26(tokenFilePath, JSON.stringify({
       input_tokens: 0,
       output_tokens: 0,
       total_tokens: 0,
@@ -80471,7 +80691,7 @@ function cleanupStaleTokenFiles(dir, now = Date.now(), maxAgeMs = STALE_TOKEN_FI
     if (!name.startsWith("tokens-") || !name.endsWith(".json"))
       continue;
     scanned++;
-    const full = join53(dir, name);
+    const full = join54(dir, name);
     try {
       if (statSync13(full).mtimeMs >= cutoff)
         continue;
@@ -80500,9 +80720,9 @@ function parseSettingsArgSafe(value) {
 }
 function userSettingsFileCandidates(cwd) {
   return [
-    join53(homedir35(), ".claude", "settings.json"),
-    join53(cwd, ".claude", "settings.json"),
-    join53(cwd, ".claude", "settings.local.json")
+    join54(homedir35(), ".claude", "settings.json"),
+    join54(cwd, ".claude", "settings.json"),
+    join54(cwd, ".claude", "settings.local.json")
   ];
 }
 function discoverUserStatusLineCommand(claudeArgs = [], cwd = process.cwd()) {
@@ -80542,13 +80762,13 @@ function buildChainedStatusCommand(userCommand, claudishBody, claudishSegment) {
   return `JSON=$(cat); ${runUser}; ${claudishBody}; SEG=$(${claudishSegment}); ${separator}; ${emit}`;
 }
 function createTempSettingsFile(_modelDisplay, port, proxyAuthMode, userStatusLineCommand) {
-  const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join53(homeDir, ".claudish");
+  const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir3();
+  const claudishDir = join54(homeDir, ".claudish");
   try {
-    mkdirSync22(claudishDir, { recursive: true });
+    mkdirSync23(claudishDir, { recursive: true });
   } catch {}
   const timestamp = Date.now();
-  const tempPath = join53(claudishDir, `settings-${timestamp}.json`);
+  const tempPath = join54(claudishDir, `settings-${timestamp}.json`);
   const assignedFile = assignedTokenFile(process.env) !== null;
   const tokenFilePath = resolveTokenFilePath(port);
   cleanupStaleTokenFiles(claudishDir);
@@ -80585,7 +80805,7 @@ function createTempSettingsFile(_modelDisplay, port, proxyAuthMode, userStatusLi
     padding: 0
   };
   const settings = buildClaudishSettingsOverlay(statusLine, proxyAuthMode);
-  writeFileSync25(tempPath, JSON.stringify(settings, null, 2), "utf-8");
+  writeFileSync26(tempPath, JSON.stringify(settings, null, 2), "utf-8");
   return { path: tempPath, statusLine, tokenFilePath };
 }
 function scrubChildEnv(env, opts) {
@@ -80603,6 +80823,7 @@ function buildClaudishSettingsOverlay(statusLine, proxyAuthMode, paneChild = isP
   }
   if (paneChild) {
     settings.skipDangerousModePermissionPrompt = true;
+    settings.editorMode = "normal";
   }
   return settings;
 }
@@ -80624,7 +80845,10 @@ function mergeUserSettingsIfPresent(config, tempSettingsPath, statusLine, proxyA
     if (paneChild && !("skipDangerousModePermissionPrompt" in userSettings)) {
       userSettings.skipDangerousModePermissionPrompt = true;
     }
-    writeFileSync25(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
+    if (paneChild) {
+      userSettings.editorMode = "normal";
+    }
+    writeFileSync26(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
   } catch {
     if (!config.quiet) {
       console.warn(`[claudish] Warning: could not merge user settings: ${userSettingsValue}`);
@@ -80923,7 +81147,7 @@ async function runClaudeWithProxy(config, proxyUrl, onCleanup) {
     console.error(`
 Or set CLAUDE_PATH to your custom installation:`);
     const home = homedir35();
-    const localPath = isWindows2() ? join53(home, ".claude", "local", "claude.exe") : join53(home, ".claude", "local", "claude");
+    const localPath = isWindows2() ? join54(home, ".claude", "local", "claude.exe") : join54(home, ".claude", "local", "claude");
     console.error(`  export CLAUDE_PATH=${localPath}`);
     process.exit(1);
   }
@@ -80934,11 +81158,11 @@ Or set CLAUDE_PATH to your custom installation:`);
   const childWantsTty = config.interactive && !process.stdout.isTTY && Boolean(process.stdin.isTTY);
   if (childWantsTty) {
     try {
-      const fd = openSync10("/dev/fd/0", "r+");
+      const fd = openSync11("/dev/fd/0", "r+");
       if (isatty(fd)) {
         ttyFd = fd;
       } else {
-        closeSync10(fd);
+        closeSync11(fd);
       }
     } catch {
       ttyFd = undefined;
@@ -80957,7 +81181,7 @@ Or set CLAUDE_PATH to your custom installation:`);
     stdoutIsTty: Boolean(process.stdout.isTTY),
     magmuxBinary: paneCapability.magmux
   }) : null;
-  const proc = wrap ? spawn3(wrap.command, wrap.args, { env: wrap.env, stdio, shell: false }) : spawn3(spawnCommand, claudeArgs, {
+  const proc = wrap ? spawn4(wrap.command, wrap.args, { env: wrap.env, stdio, shell: false }) : spawn4(spawnCommand, claudeArgs, {
     env,
     stdio,
     shell: needsShell
@@ -80983,7 +81207,7 @@ Or set CLAUDE_PATH to your custom installation:`);
     const fdToClose = ttyFd;
     proc.on("spawn", () => {
       try {
-        closeSync10(fdToClose);
+        closeSync11(fdToClose);
       } catch {}
     });
   }
@@ -81036,15 +81260,15 @@ async function findClaudeBinary() {
     }
   }
   const home = homedir35();
-  const localPath = isWindows ? join53(home, ".claude", "local", "claude.exe") : join53(home, ".claude", "local", "claude");
+  const localPath = isWindows ? join54(home, ".claude", "local", "claude.exe") : join54(home, ".claude", "local", "claude");
   if (existsSync38(localPath)) {
     return localPath;
   }
   if (isWindows) {
     const windowsPaths = [
-      join53(home, "AppData", "Roaming", "npm", "claude.cmd"),
-      join53(home, ".npm-global", "claude.cmd"),
-      join53(home, "node_modules", ".bin", "claude.cmd")
+      join54(home, "AppData", "Roaming", "npm", "claude.cmd"),
+      join54(home, ".npm-global", "claude.cmd"),
+      join54(home, "node_modules", ".bin", "claude.cmd")
     ];
     for (const path of windowsPaths) {
       if (existsSync38(path)) {
@@ -81055,11 +81279,11 @@ async function findClaudeBinary() {
     const commonPaths = [
       "/usr/local/bin/claude",
       "/opt/homebrew/bin/claude",
-      join53(home, ".npm-global/bin/claude"),
-      join53(home, ".local/bin/claude"),
-      join53(home, "node_modules/.bin/claude"),
+      join54(home, ".npm-global/bin/claude"),
+      join54(home, ".local/bin/claude"),
+      join54(home, "node_modules/.bin/claude"),
       "/data/data/com.termux/files/usr/bin/claude",
-      join53(home, "../usr/bin/claude")
+      join54(home, "../usr/bin/claude")
     ];
     for (const path of commonPaths) {
       if (existsSync38(path)) {
@@ -81069,7 +81293,7 @@ async function findClaudeBinary() {
   }
   try {
     const shellCommand = isWindows ? "where claude" : "command -v claude";
-    const proc = spawn3(shellCommand, [], {
+    const proc = spawn4(shellCommand, [], {
       stdio: "pipe",
       shell: true
     });
@@ -81142,18 +81366,18 @@ var init_claude_runner = __esm(() => {
 });
 
 // src/diag-output.ts
-import { createWriteStream as createWriteStream2, mkdirSync as mkdirSync23, unlinkSync as unlinkSync11, writeFileSync as writeFileSync26 } from "fs";
+import { createWriteStream as createWriteStream2, mkdirSync as mkdirSync24, unlinkSync as unlinkSync11, writeFileSync as writeFileSync27 } from "fs";
 import { homedir as homedir36 } from "os";
-import { join as join54 } from "path";
+import { join as join55 } from "path";
 function getClaudishDir() {
-  const dir = join54(homedir36(), ".claudish");
+  const dir = join55(homedir36(), ".claudish");
   try {
-    mkdirSync23(dir, { recursive: true });
+    mkdirSync24(dir, { recursive: true });
   } catch {}
   return dir;
 }
 function getDiagLogPath() {
-  return join54(getClaudishDir(), `diag-${process.pid}.log`);
+  return join55(getClaudishDir(), `diag-${process.pid}.log`);
 }
 
 class LogFileDiagOutput {
@@ -81162,7 +81386,7 @@ class LogFileDiagOutput {
   constructor() {
     this.logPath = getDiagLogPath();
     try {
-      writeFileSync26(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
+      writeFileSync27(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
 `);
     } catch {}
     this.stream = createWriteStream2(this.logPath, { flags: "a" });
@@ -81643,7 +81867,7 @@ var init_advisor_startup = __esm(() => {
 });
 
 // src/session/conversation.ts
-import { closeSync as closeSync11, openSync as openSync11, readSync as readSync5, statSync as statSync14 } from "fs";
+import { closeSync as closeSync12, openSync as openSync12, readSync as readSync6, statSync as statSync14 } from "fs";
 import { StringDecoder } from "string_decoder";
 function looksLikeTurn(line) {
   const assistant = line.includes('"type":"assistant"');
@@ -81699,7 +81923,7 @@ function readConversation(file, opts = {}) {
   let fd = null;
   try {
     const size = statSync14(file).size;
-    fd = openSync11(file, "r");
+    fd = openSync12(file, "r");
     const buf = Buffer.allocUnsafe(chunkBytes);
     const decoder = new StringDecoder("utf-8");
     let pending = "";
@@ -81731,7 +81955,7 @@ function readConversation(file, opts = {}) {
       take({ role: raw.role, text, elided });
     };
     while (pos < size) {
-      const n = readSync5(fd, buf, 0, Math.min(chunkBytes, size - pos), pos);
+      const n = readSync6(fd, buf, 0, Math.min(chunkBytes, size - pos), pos);
       if (n <= 0)
         break;
       pos += n;
@@ -81755,7 +81979,7 @@ function readConversation(file, opts = {}) {
   } catch {} finally {
     if (fd !== null) {
       try {
-        closeSync11(fd);
+        closeSync12(fd);
       } catch {}
     }
   }
@@ -83369,30 +83593,30 @@ function readSessionStats(port, opts) {
     return null;
   const d = raw;
   const processStartMs = opts?.processStartMs ?? Date.now() - Math.round(process.uptime() * 1000);
-  const trackerStartedAt = num(d.started_at);
+  const trackerStartedAt = num2(d.started_at);
   if (trackerStartedAt <= 0 || trackerStartedAt < processStartMs)
     return null;
-  const inputTokens = num(d.input_tokens);
-  const outputTokens = num(d.output_tokens);
+  const inputTokens = num2(d.input_tokens);
+  const outputTokens = num2(d.output_tokens);
   if (inputTokens <= 0 && outputTokens <= 0)
     return null;
-  const costUsd = num(d.total_cost);
+  const costUsd = num2(d.total_cost);
   const isFree = d.is_free === true;
   const contextWindow = typeof d.context_window === "number" ? d.context_window : null;
   const contextUsed = contextWindow && contextWindow > 0 ? Math.min(1, Math.max(0, inputTokens / contextWindow)) : null;
-  const toolCalls = Array.isArray(d.tool_calls) ? d.tool_calls.map((t) => t).filter((t) => typeof t?.name === "string" && num(t.count) > 0).map((t) => ({ name: String(t.name), count: num(t.count) })) : [];
-  const startedAt = num(d.started_at);
-  const updatedAt = num(d.updated_at);
+  const toolCalls = Array.isArray(d.tool_calls) ? d.tool_calls.map((t) => t).filter((t) => typeof t?.name === "string" && num2(t.count) > 0).map((t) => ({ name: String(t.name), count: num2(t.count) })) : [];
+  const startedAt = num2(d.started_at);
+  const updatedAt = num2(d.updated_at);
   const durationMs = startedAt > 0 && updatedAt > startedAt ? updatedAt - startedAt : 0;
-  const billedInputTokens = num(d.billed_input_tokens) || inputTokens;
-  const rawIn = billedInputTokens / 1e6 * num(d.input_per_m);
-  const rawOut = outputTokens / 1e6 * num(d.output_per_m);
+  const billedInputTokens = num2(d.billed_input_tokens) || inputTokens;
+  const rawIn = billedInputTokens / 1e6 * num2(d.input_per_m);
+  const rawOut = outputTokens / 1e6 * num2(d.output_per_m);
   const rawTotal = rawIn + rawOut;
   const scale = rawTotal > 0 && costUsd > 0 ? costUsd / rawTotal : 0;
   return {
     inputTokens,
     outputTokens,
-    totalTokens: num(d.total_tokens) || inputTokens + outputTokens,
+    totalTokens: num2(d.total_tokens) || inputTokens + outputTokens,
     costUsd,
     isFree,
     isEstimated: d.is_estimated === true,
@@ -83420,7 +83644,7 @@ function computeSavings(inputTokens, outputTokens, actualUsd) {
     };
   });
 }
-var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+var num2 = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
 var init_session_stats = __esm(() => {
   init_baseline_pricing();
   init_token_file();
@@ -83722,7 +83946,7 @@ init_startup_trace();
 init_picker_cancelled();
 var import_dotenv3 = __toESM(require_main(), 1);
 import { existsSync as existsSync39, readFileSync as readFileSync38 } from "fs";
-import { join as join55, resolve as resolve7 } from "path";
+import { join as join56, resolve as resolve7 } from "path";
 
 // src/tui/runtime/should-open-picker.ts
 function noModelConfigured(gate) {
@@ -84030,7 +84254,7 @@ async function runCli() {
         process.exit(1);
       }
       const mode = cliConfig.teamMode ?? "default";
-      const sessionPath = join55(process.cwd(), `.claudish-team-${Date.now()}`);
+      const sessionPath = join56(process.cwd(), `.claudish-team-${Date.now()}`);
       if (mode === "json") {
         await Promise.resolve().then(() => init_pane());
         await Promise.resolve().then(() => init_team_orchestrator());
@@ -84050,7 +84274,7 @@ async function runCli() {
         const status = await runModels(sessionPath);
         const result = { ...status, responses: {} };
         for (const anonId of Object.keys(status.models)) {
-          const responsePath = join55(sessionPath, `response-${anonId}.md`);
+          const responsePath = join56(sessionPath, `response-${anonId}.md`);
           try {
             const raw = readFileSync38(responsePath, "utf-8").trim();
             try {