claudish 7.48.0 → 7.49.0

package/dist/index.js

@@ -729,7 +729,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.48.0";
+var VERSION = "7.49.0";
 
 // src/logger.ts
 var exports_logger = {};
@@ -28142,7 +28142,7 @@ var init_provider_definitions = __esm(() => {
       name: "minimax",
       displayName: "MiniMax",
       transport: "anthropic",
-      baseUrl: "https://api.minimax.io",
+      baseUrl: "https://api.minimaxi.com",
       baseUrlEnvVars: ["MINIMAX_BASE_URL"],
       apiPath: "/anthropic/v1/messages",
       apiKeyEnvVar: "MINIMAX_API_KEY",
@@ -29640,6 +29640,48 @@ var init_base_api_format = __esm(() => {
 });
 
 // src/adapters/anthropic-api-format.ts
+function systemText(content) {
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    return content.map((block) => typeof block?.text === "string" ? block.text : "").filter(Boolean).join(`
+`);
+  }
+  return "";
+}
+function hoistInlineSystem(messages) {
+  if (!Array.isArray(messages) || !messages.some((m) => m?.role === "system")) {
+    return { messages, hoisted: [] };
+  }
+  const kept = [];
+  const hoisted = [];
+  for (const msg of messages) {
+    if (msg?.role === "system") {
+      const text = systemText(msg.content);
+      if (text)
+        hoisted.push(text);
+      continue;
+    }
+    kept.push(msg);
+  }
+  return { messages: kept, hoisted };
+}
+function mergeSystem(existing, hoisted) {
+  if (hoisted.length === 0)
+    return existing;
+  const merged = hoisted.join(`
+
+`);
+  if (existing === undefined || existing === null || existing === "")
+    return merged;
+  if (Array.isArray(existing))
+    return [...existing, { type: "text", text: merged }];
+  if (typeof existing === "string")
+    return `${existing}
+
+${merged}`;
+  return existing;
+}
 var AnthropicAPIFormat;
 var init_anthropic_api_format = __esm(() => {
   init_base_api_format();
@@ -29684,14 +29726,16 @@ var init_anthropic_api_format = __esm(() => {
       return claudeRequest.tools || [];
     }
     buildPayload(claudeRequest, messages, tools) {
+      const { messages: cleanMessages, hoisted } = hoistInlineSystem(messages);
       const payload = {
         model: this.modelId,
-        messages,
+        messages: cleanMessages,
         max_tokens: claudeRequest.max_tokens || 4096,
         stream: true
       };
-      if (claudeRequest.system) {
-        payload.system = claudeRequest.system;
+      const system = mergeSystem(claudeRequest.system, hoisted);
+      if (system !== undefined) {
+        payload.system = system;
       }
       if (tools.length > 0) {
         payload.tools = tools;
@@ -34884,14 +34928,14 @@ var init_config = __esm(() => {
 });
 
 // src/behavior/harness.ts
-function extractAvailableSkills(systemText) {
-  if (!systemText)
+function extractAvailableSkills(systemText2) {
+  if (!systemText2)
     return [];
-  const start = SKILL_SECTION.exec(systemText);
+  const start = SKILL_SECTION.exec(systemText2);
   if (!start)
     return [];
   const out = [];
-  const body = systemText.slice(start.index + start[0].length);
+  const body = systemText2.slice(start.index + start[0].length);
   for (const line of body.split(`
 `)) {
     const trimmed2 = line.trim();
@@ -38024,6 +38068,170 @@ var init_anthropic_error = __esm(() => {
   CONTROL_CHARS = /[\x00-\x1F\x7F]/g;
 });
 
+// src/handlers/shared/collect-sse-message.ts
+function finalizeBlock(block) {
+  if (block.type === "text") {
+    return { type: "text", text: block.text ?? "" };
+  }
+  if (block.type === "thinking") {
+    return {
+      type: "thinking",
+      thinking: block.thinking ?? "",
+      ...block.signature ? { signature: block.signature } : {}
+    };
+  }
+  let input = block.input ?? {};
+  if (block.partialJson !== undefined && block.partialJson !== "") {
+    try {
+      input = JSON.parse(block.partialJson);
+    } catch {
+      log(`[CollectSSE] tool_use ${block.name ?? "?"} had unparseable input, emitting empty object`);
+      input = {};
+    }
+  }
+  return {
+    type: "tool_use",
+    id: block.id ?? "",
+    name: block.name ?? "",
+    input
+  };
+}
+async function collectSseMessage(sse, fallbackModel, opts = {}) {
+  const message = {
+    id: `msg_${Date.now()}`,
+    type: "message",
+    role: "assistant",
+    model: fallbackModel,
+    content: [],
+    stop_reason: null,
+    stop_sequence: null,
+    usage: { input_tokens: 0, output_tokens: 0 }
+  };
+  const blocks = new Map;
+  const blockAt = (index) => {
+    let block = blocks.get(index);
+    if (!block) {
+      block = { type: "text", text: "" };
+      blocks.set(index, block);
+    }
+    return block;
+  };
+  if (!sse.body)
+    return message;
+  const reader = sse.body.getReader();
+  const decoder = new TextDecoder;
+  const stallMs = opts.stallTimeoutMs ?? STALL_TIMEOUT_MS;
+  let buffer = "";
+  const handle = (data) => {
+    switch (data?.type) {
+      case "message_start": {
+        const m = data.message ?? {};
+        if (m.id)
+          message.id = m.id;
+        if (m.model)
+          message.model = m.model;
+        if (m.usage?.input_tokens != null)
+          message.usage.input_tokens = m.usage.input_tokens;
+        if (m.usage?.output_tokens != null)
+          message.usage.output_tokens = m.usage.output_tokens;
+        break;
+      }
+      case "content_block_start": {
+        const cb = data.content_block ?? {};
+        const kind = cb.type === "thinking" ? "thinking" : cb.type === "tool_use" ? "tool_use" : "text";
+        blocks.set(data.index, {
+          type: kind,
+          text: kind === "text" ? cb.text ?? "" : undefined,
+          thinking: kind === "thinking" ? cb.thinking ?? "" : undefined,
+          id: cb.id,
+          name: cb.name,
+          partialJson: kind === "tool_use" ? "" : undefined
+        });
+        break;
+      }
+      case "content_block_delta": {
+        const block = blockAt(data.index);
+        const d = data.delta ?? {};
+        if (d.type === "text_delta")
+          block.text = (block.text ?? "") + (d.text ?? "");
+        else if (d.type === "thinking_delta")
+          block.thinking = (block.thinking ?? "") + (d.thinking ?? "");
+        else if (d.type === "signature_delta")
+          block.signature = d.signature;
+        else if (d.type === "input_json_delta")
+          block.partialJson = (block.partialJson ?? "") + (d.partial_json ?? "");
+        break;
+      }
+      case "message_delta": {
+        if (data.delta?.stop_reason !== undefined)
+          message.stop_reason = data.delta.stop_reason;
+        if (data.delta?.stop_sequence !== undefined)
+          message.stop_sequence = data.delta.stop_sequence;
+        if (data.usage?.input_tokens != null)
+          message.usage.input_tokens = data.usage.input_tokens;
+        if (data.usage?.output_tokens != null)
+          message.usage.output_tokens = data.usage.output_tokens;
+        break;
+      }
+      default:
+        break;
+    }
+  };
+  try {
+    while (true) {
+      let timer;
+      const chunk = await Promise.race([
+        reader.read(),
+        new Promise((resolve2) => {
+          timer = setTimeout(() => resolve2("stalled"), stallMs);
+        })
+      ]);
+      clearTimeout(timer);
+      if (chunk === "stalled") {
+        log(`[CollectSSE] no data for ${stallMs}ms \u2014 returning ${blocks.size} block(s) collected so far`);
+        await reader.cancel().catch(() => {});
+        break;
+      }
+      if (chunk.done)
+        break;
+      buffer += decoder.decode(chunk.value, { stream: true });
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.startsWith("data:"))
+          continue;
+        const payload = line.slice(5).trim();
+        if (!payload || payload === "[DONE]")
+          continue;
+        try {
+          handle(JSON.parse(payload));
+        } catch {}
+      }
+    }
+  } catch (e) {
+    log(`[CollectSSE] read failed, keeping ${blocks.size} block(s): ${e}`);
+  }
+  for (const index of Array.from(blocks.keys()).sort((a, b) => a - b)) {
+    message.content.push(finalizeBlock(blocks.get(index)));
+  }
+  if (message.stop_reason === null) {
+    message.stop_reason = message.content.some((b) => b.type === "tool_use") ? "tool_use" : "end_turn";
+  }
+  return message;
+}
+async function sseResponseToJson(sse, fallbackModel, opts = {}) {
+  const message = await collectSseMessage(sse, fallbackModel, opts);
+  return new Response(JSON.stringify(message), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+var STALL_TIMEOUT_MS = 120000;
+var init_collect_sse_message = __esm(() => {
+  init_logger();
+});
+
 // src/handlers/shared/connection-error.ts
 function findConnectionCode(error46) {
   let e = error46;
@@ -38584,6 +38792,31 @@ function createAnthropicPassthroughStream(c, response, opts) {
   const filterThinking = opts.adapter?.shouldFilterThinking() ?? false;
   const interceptToolFrame = createToolRepairInterceptor(opts);
   let pendingEventLine = null;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let stopReason = null;
+  let sawMessageStart = false;
+  let sawMessageStop = false;
+  let openBlockIndex = null;
+  const noteLifecycle = (data, emittedIndex) => {
+    switch (data?.type) {
+      case "message_start":
+        sawMessageStart = true;
+        break;
+      case "message_stop":
+        sawMessageStop = true;
+        break;
+      case "content_block_start":
+        if (emittedIndex !== null)
+          openBlockIndex = emittedIndex;
+        break;
+      case "content_block_stop":
+        openBlockIndex = null;
+        break;
+      default:
+        break;
+    }
+  };
   const flushPendingEvent = (controller) => {
     if (pendingEventLine !== null && !isClosed) {
       controller.enqueue(encoder.encode(`${pendingEventLine}
@@ -38601,6 +38834,48 @@ function createAnthropicPassthroughStream(c, response, opts) {
     }
     flushPendingEvent(controller);
     controller.enqueue(encoder.encode(out));
+    noteLifecycle(data, typeof data?.index === "number" ? data.index : null);
+  };
+  const finalizeAbandonedStream = (controller) => {
+    if (isClosed || sawMessageStop)
+      return;
+    const send = (event, data) => {
+      controller.enqueue(encoder.encode(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`));
+    };
+    try {
+      if (!sawMessageStart) {
+        send("message_start", {
+          type: "message_start",
+          message: {
+            id: `msg_${Date.now()}`,
+            type: "message",
+            role: "assistant",
+            content: [],
+            model: opts.modelName,
+            stop_reason: null,
+            stop_sequence: null,
+            usage: { input_tokens: inputTokens, output_tokens: outputTokens }
+          }
+        });
+      }
+      if (openBlockIndex !== null) {
+        send("content_block_stop", { type: "content_block_stop", index: openBlockIndex });
+        openBlockIndex = null;
+      }
+      send("message_delta", {
+        type: "message_delta",
+        delta: { stop_reason: stopReason ?? "end_turn", stop_sequence: null },
+        usage: {
+          ...inputTokens > 0 ? { input_tokens: inputTokens } : {},
+          output_tokens: outputTokens
+        }
+      });
+      send("message_stop", { type: "message_stop" });
+      sawMessageStop = true;
+    } catch {}
   };
   return c.body(new ReadableStream({
     async start(controller) {
@@ -38621,12 +38896,9 @@ data: {"type":"ping"}
       try {
         const reader = response.body.getReader();
         let buffer = "";
-        let inputTokens = 0;
-        let outputTokens = 0;
         let totalLines = 0;
         let textChunks = 0;
         let toolUseBlocks = 0;
-        let stopReason = null;
         let insideThinkingBlock = false;
         let thinkingBlocksSuppressed = 0;
         let suppressedFrame = false;
@@ -38691,6 +38963,7 @@ data: ${JSON.stringify({
                     flushPendingEvent(controller);
                     controller.enqueue(encoder.encode(`${modifiedLine}
 `));
+                    noteLifecycle(data, reindexed);
                   }
                 } else {
                   enqueueData(controller, data, line);
@@ -38813,6 +39086,13 @@ data: ${JSON.stringify({
         }
       } catch (e) {
         log(`[AnthropicSSE] Stream error: ${e}`);
+        finalizeAbandonedStream(controller);
+        try {
+          opts.onTurnEnd?.();
+        } catch {}
+        try {
+          opts.onTokenUpdate?.(inputTokens, outputTokens);
+        } catch {}
         if (!isClosed) {
           isClosed = true;
           if (pingInterval) {
@@ -40773,9 +41053,12 @@ class ComposedHandler {
         behaviorSession?.noteTurnComplete(this.tokenTracker.getInputTokens());
       } catch {}
     };
-    return this.handleStream(c, response, adapter, claudeRequest, toolNameMap, onStreamComplete, (code, message) => {
+    const streamed = this.handleStream(c, response, adapter, claudeRequest, toolNameMap, onStreamComplete, (code, message) => {
       streamApiError = { code, message };
     }, behaviorSession);
+    if (payload?.stream === true)
+      return streamed;
+    return sseResponseToJson(streamed, this.bareModelName);
   }
   async settleResponsesStreamHead(initial, reissue) {
     let response = initial;
@@ -41084,6 +41367,7 @@ var init_composed_handler = __esm(() => {
   init_telemetry();
   init_transform();
   init_anthropic_error();
+  init_collect_sse_message();
   init_connection_error();
   init_devin_stream_head_sniffer();
   init_openai_compat();
@@ -44029,6 +44313,83 @@ var init_channel = __esm(() => {
   init_session_manager();
 });
 
+// src/mcp/progress-heartbeat.ts
+function isProgressToken(v) {
+  return typeof v === "string" || typeof v === "number" && Number.isFinite(v);
+}
+function clampInterval(ms) {
+  if (ms < MIN_PROGRESS_INTERVAL_MS)
+    return MIN_PROGRESS_INTERVAL_MS;
+  if (ms > MAX_PROGRESS_INTERVAL_MS)
+    return MAX_PROGRESS_INTERVAL_MS;
+  return ms;
+}
+function resolveProgressIntervalMs(env = process.env) {
+  const raw = env[PROGRESS_INTERVAL_ENV_VAR];
+  if (raw === undefined || raw === null || raw.trim() === "")
+    return DEFAULT_PROGRESS_INTERVAL_MS;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0)
+    return DEFAULT_PROGRESS_INTERVAL_MS;
+  return clampInterval(parsed);
+}
+function resolveExplicitIntervalMs(ms) {
+  if (ms === undefined)
+    return DEFAULT_PROGRESS_INTERVAL_MS;
+  if (!Number.isFinite(ms) || ms <= 0)
+    return DEFAULT_PROGRESS_INTERVAL_MS;
+  return Math.min(ms, MAX_PROGRESS_INTERVAL_MS);
+}
+function startHeartbeat(opts) {
+  const { token, send, label } = opts;
+  if (!isProgressToken(token))
+    return NOOP_HEARTBEAT;
+  const intervalMs = resolveExplicitIntervalMs(opts.intervalMs);
+  const startedAt = Date.now();
+  let progress = 0;
+  let stopped = false;
+  const emit2 = (message) => {
+    if (stopped)
+      return;
+    progress += 1;
+    try {
+      const elapsedSeconds = Math.round((Date.now() - startedAt) / 1000);
+      const result = send({
+        progressToken: token,
+        progress,
+        message: message ?? `${label}: working (${elapsedSeconds}s)`
+      });
+      if (result && typeof result.then === "function") {
+        result.catch(() => {});
+      }
+    } catch {}
+  };
+  const timer = setInterval(() => emit2(), intervalMs);
+  timer.unref?.();
+  return {
+    tick: (message) => emit2(message),
+    stop: () => {
+      stopped = true;
+      clearInterval(timer);
+    },
+    get active() {
+      return !stopped;
+    },
+    get emitted() {
+      return progress;
+    }
+  };
+}
+var DEFAULT_PROGRESS_INTERVAL_MS = 1e4, MIN_PROGRESS_INTERVAL_MS = 1000, MAX_PROGRESS_INTERVAL_MS = 60000, PROGRESS_INTERVAL_ENV_VAR = "CLAUDISH_MCP_PROGRESS_INTERVAL_MS", NOOP_HEARTBEAT;
+var init_progress_heartbeat = __esm(() => {
+  NOOP_HEARTBEAT = Object.freeze({
+    tick(_message) {},
+    stop() {},
+    active: false,
+    emitted: 0
+  });
+});
+
 // src/providers/cache-ttl.ts
 var FIREBASE_CACHE_TTL_HOURS = 24, FIREBASE_CACHE_TTL_MS;
 var init_cache_ttl = __esm(() => {
@@ -46892,6 +47253,34 @@ var init_native_handler_advisor = __esm(() => {
   advisorToolUseIds = new Set;
 });
 
+// src/handlers/shared/thinking-signature.ts
+function isUnsignedThinking(block) {
+  if (!block || typeof block !== "object")
+    return false;
+  const b = block;
+  if (b.type !== "thinking")
+    return false;
+  return typeof b.signature !== "string" || b.signature.length === 0;
+}
+function stripUnsignedThinkingBlocks(messages) {
+  if (!Array.isArray(messages))
+    return 0;
+  let removed = 0;
+  for (const message of messages) {
+    if (!message || typeof message !== "object")
+      continue;
+    const content = message.content;
+    if (!Array.isArray(content))
+      continue;
+    const kept = content.filter((block) => !isUnsignedThinking(block));
+    if (kept.length !== content.length) {
+      removed += content.length - kept.length;
+      message.content = kept;
+    }
+  }
+  return removed;
+}
+
 // src/handlers/native-handler.ts
 async function resolveAdvisorKeys() {
   const keyFromAuthority = async (name) => {
@@ -46937,6 +47326,10 @@ class NativeHandler {
   async handle(c, payload) {
     const originalHeaders = c.req.header();
     const target = payload.model;
+    const strippedThinking = stripUnsignedThinkingBlocks(payload.messages);
+    if (strippedThinking > 0) {
+      log(`[Native] stripped ${strippedThinking} unsigned thinking block(s) from history for ${target} (foreign-provider origin)`);
+    }
     const advisorCfg = loadAdvisorSwapConfig(this.advisorModels, this.advisorCollector);
     let advisorSwapped = null;
     let advisorRewrittenIds = [];
@@ -47958,7 +48351,8 @@ var init_vertex_oauth = __esm(() => {
 
 // src/providers/provider-profiles.ts
 function requiresResponsesApi(modelName) {
-  return /^gpt-5\.6/.test(modelName.toLowerCase());
+  const name = modelName.toLowerCase();
+  return /^gpt-5\.6/.test(name) || name.includes("codex");
 }
 function createHandlerForProvider(ctx) {
   const profile = PROVIDER_PROFILES[ctx.provider.name] ?? getRuntimeProfiles().get(ctx.provider.name);
@@ -49720,7 +50114,7 @@ import {
 } from "fs";
 import { join as join28, resolve as resolve3 } from "path";
 function classifyRunOutput(opts) {
-  const { outputSize, stdoutTail, stderr, minOutputBytes } = opts;
+  const { outputSize, stdoutTail, stderr, minOutputBytes, requirePattern, fullOutput } = opts;
   const apiError = API_ERROR_RE.exec(stdoutTail);
   if (apiError) {
     return {
@@ -49748,6 +50142,21 @@ function classifyRunOutput(opts) {
       detail: `Child exited 0 but produced only ${outputSize} B of stdout ` + `(caller required at least ${minOutputBytes} B).`
     };
   }
+  if (requirePattern) {
+    const haystack = fullOutput ?? stdoutTail;
+    let re = null;
+    try {
+      re = new RegExp(requirePattern);
+    } catch {
+      re = null;
+    }
+    if (re && !re.test(haystack)) {
+      return {
+        reason: "shape_mismatch",
+        detail: `Child exited 0 with ${outputSize} B, but the response does not match the ` + `required pattern /${requirePattern}/. This is the signature of a child that ` + "answered and then took one more turn: `claude -p` prints only the FINAL " + "assistant message, so a background task completing (or any late notification) " + "replaces the real answer with an epilogue about it. Check the child's " + "transcript \u2014 the answer was generated, it just was not the last thing said."
+      };
+    }
+  }
   return null;
 }
 function persistErrorLog(errorLogPath, header, stderr, stdoutTail) {
@@ -49826,8 +50235,28 @@ function setupSession(sessionPath, models, input) {
   writeFileSync12(join28(sessionPath, "status.json"), JSON.stringify(status, null, 2), "utf-8");
   return manifest;
 }
+function assertValidRequirePattern(pattern) {
+  if (pattern === undefined)
+    return;
+  try {
+    new RegExp(pattern);
+  } catch (err) {
+    throw new Error(`Invalid requirePattern /${pattern}/: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function readFullOutputIfNeeded(opts) {
+  const { crashed, requirePattern, outputSize, outputPath } = opts;
+  if (crashed || !requirePattern || outputSize <= STDOUT_TAIL_LIMIT)
+    return;
+  try {
+    return readFileSync18(outputPath, "utf-8");
+  } catch {
+    return;
+  }
+}
 async function runModels(sessionPath, opts = {}) {
   const timeoutMs = (opts.timeout ?? 300) * 1000;
+  assertValidRequirePattern(opts.requirePattern);
   const manifest = JSON.parse(readFileSync18(join28(sessionPath, "manifest.json"), "utf-8"));
   const statusPath = join28(sessionPath, "status.json");
   const inputPath = join28(sessionPath, "input.md");
@@ -49839,6 +50268,7 @@ async function runModels(sessionPath, opts = {}) {
     writeFileSync12(statusPath, JSON.stringify(statusCache, null, 2), "utf-8");
   }
   const minOutputBytes = opts.minOutputBytes ?? DEFAULT_MIN_OUTPUT_BYTES;
+  const requirePattern = opts.requirePattern;
   mkdirSync12(statsDir(sessionPath), { recursive: true });
   const processes = new Map;
   const runtimes = new Map;
@@ -49905,7 +50335,20 @@ async function runModels(sessionPath, opts = {}) {
         resolved = true;
         const outputSize = byteCount;
         const crashed = exitCode !== 0;
-        const degraded = crashed ? null : classifyRunOutput({ outputSize, stdoutTail, stderr, minOutputBytes });
+        const fullOutput = readFullOutputIfNeeded({
+          crashed,
+          requirePattern,
+          outputSize,
+          outputPath
+        });
+        const degraded = crashed ? null : classifyRunOutput({
+          outputSize,
+          stdoutTail,
+          stderr,
+          minOutputBytes,
+          requirePattern,
+          fullOutput
+        });
         const failed = crashed || degraded !== null;
         const state = crashed ? "FAILED" : degraded ? "EMPTY" : "COMPLETED";
         if (failed) {
@@ -50438,6 +50881,7 @@ ${block.join(`
       required: ["model", "prompt"]
     },
     group: "low-level",
+    heartbeat: true,
     handler: async (args) => {
       try {
         const result = await runPromptViaProxy(args.model, args.prompt, args.system_prompt, args.max_tokens);
@@ -50658,7 +51102,8 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
       required: ["models", "prompt"]
     },
     group: "low-level",
-    handler: async (args) => {
+    heartbeat: true,
+    handler: async (args, ctx) => {
       const modelIds = args.models;
       const prompt = args.prompt;
       const systemPrompt = args.system_prompt;
@@ -50675,6 +51120,7 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
             error: error46 instanceof Error ? error46.message : String(error46)
           });
         }
+        ctx.reportProgress(`compare_models: ${results.length}/${modelIds.length} models done`);
       }
       let output = `# Model Comparison
 
@@ -50740,12 +51186,21 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
           type: "string",
           description: "Task prompt text (or place input.md in the session directory before calling)"
         },
-        timeout: { type: "number", description: "Per-model timeout in seconds (default: 300)" }
+        timeout: { type: "number", description: "Per-model timeout in seconds (default: 300)" },
+        require_pattern: {
+          type: "string",
+          description: "Regex the response MUST match, or the slot is reported FAILED (state EMPTY, " + "reason 'shape_mismatch') instead of succeeded. Strongly recommended whenever " + "your prompt mandates an output shape \u2014 e.g. '```vote' for a voting panel. " + "Exit code 0 is not a success oracle: a child that answers and then takes one " + "more turn (a background Task finishing, a late notification) has its real " + "answer replaced by a short epilogue, because print mode emits only the FINAL " + "assistant message. That lands as a few hundred bytes of plausible prose with " + "exit 0 and no error, and is otherwise indistinguishable from success."
+        },
+        min_output_bytes: {
+          type: "number",
+          description: "Report a slot FAILED if it produced fewer than this many bytes (default 0 = " + "off). A blunter instrument than require_pattern \u2014 short answers can be " + "legitimate \u2014 so prefer require_pattern when you know the expected shape."
+        }
       },
       required: ["mode", "path"]
     },
     group: "agentic",
-    handler: async (args) => {
+    heartbeat: true,
+    handler: async (args, ctx) => {
       try {
         const mode = args.mode;
         const path = args.path;
@@ -50753,19 +51208,26 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
         const judges = args.judges;
         const input = args.input;
         const timeout = args.timeout;
+        const requirePattern = args.require_pattern;
+        const minOutputBytes = args.min_output_bytes;
         const resolved = validateSessionPath(path);
         const teamSessionId = resolved.split("/").filter(Boolean).pop() ?? "team";
         const teamCreatedAt = new Date().toISOString();
         const runOpts = {
           timeout,
-          onProgress: (u) => 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
-          })
+          requirePattern,
+          minOutputBytes,
+          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
+            });
+          }
         };
         switch (mode) {
           case "run": {
@@ -51200,6 +51662,7 @@ To report this error, use the report_error tool with error_type: "provider_failu
       watchNotificationResult(result, { sessionId: p.sessionId, eventType: p.event });
     } catch {}
   };
+  const progressIntervalMs = resolveProgressIntervalMs();
   const allTools = defineTools(sessionManager, notifyChannel);
   const enabledTools = allTools.filter((t) => enabledGroups.has(t.group));
   const toolMap = new Map(enabledTools.map((t) => [t.name, t]));
@@ -51211,7 +51674,7 @@ To report this error, use the report_error tool with error_type: "provider_failu
       inputSchema: t.inputSchema
     }))
   }));
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
     const { name, arguments: args } = request.params;
     const tool = toolMap.get(name);
     if (!tool) {
@@ -51220,8 +51683,15 @@ To report this error, use the report_error tool with error_type: "provider_failu
         isError: true
       };
     }
+    const heartbeat = tool.heartbeat ? startHeartbeat({
+      token: extra._meta?.progressToken,
+      label: name,
+      intervalMs: progressIntervalMs,
+      send: (frame) => extra.sendNotification({ method: "notifications/progress", params: frame })
+    }) : NOOP_HEARTBEAT;
+    const ctx = { reportProgress: (message) => heartbeat.tick(message) };
     try {
-      return await tool.handler(args ?? {});
+      return await tool.handler(args ?? {}, ctx);
     } catch (error46) {
       return {
         content: [
@@ -51232,6 +51702,8 @@ To report this error, use the report_error tool with error_type: "provider_failu
         ],
         isError: true
       };
+    } finally {
+      heartbeat.stop();
     }
   });
   const transport = new StdioServerTransport;
@@ -51279,6 +51751,7 @@ var init_mcp_server = __esm(() => {
   init_prehydrate();
   init_diagnostics();
   init_channel();
+  init_progress_heartbeat();
   init_model_loader();
   init_port_manager();
   init_onepassword();
@@ -51297,7 +51770,8 @@ var init_mcp_server = __esm(() => {
     timeout: "raise `timeout`, or pick a faster model",
     api_error: "retry once, or route via a different provider (or@<model>)",
     background_task_ceiling: "set CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS=0 for children, or forbid background work in the prompt",
-    empty_output: "retry once; if it repeats, drop the model"
+    empty_output: "retry once; if it repeats, drop the model",
+    shape_mismatch: "the answer was generated but not captured \u2014 print mode keeps only the FINAL " + "assistant message, so a late background task or notification overwrote it. " + "Retry, and forbid background work in the prompt; do NOT count this slot as a vote"
   };
   sanitize = sanitizeForReport;
   EVENT_TO_TASK_STATUS = new Map([
@@ -51603,6 +52077,440 @@ var init_behavior_command = __esm(() => {
   init_profile_config();
 });
 
+// src/team-grid.ts
+var exports_team_grid = {};
+__export(exports_team_grid, {
+  runWithGrid: () => runWithGrid
+});
+import { spawn as spawn3 } from "child_process";
+import { execSync } from "child_process";
+import { existsSync as existsSync23, readFileSync as readFileSync22, writeFileSync as writeFileSync15 } from "fs";
+import { connect as netConnect } from "net";
+import { dirname as dirname10, join as join30 } from "path";
+import { setTimeout as wait } from "timers/promises";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function resolveRouteInfo(modelId) {
+  const parsed = parseModelSpec(modelId);
+  if (parsed.isExplicitProvider) {
+    return { chain: [parsed.provider], source: "direct" };
+  }
+  const local = loadLocalConfig();
+  if (local?.routing && Object.keys(local.routing).length > 0) {
+    const matched2 = matchRoutingRule(parsed.model, local.routing);
+    if (matched2) {
+      const routes = buildRoutingChain(matched2, parsed.model);
+      const pattern = Object.keys(local.routing).find((k) => {
+        if (k === parsed.model)
+          return true;
+        if (k.includes("*")) {
+          const star = k.indexOf("*");
+          return parsed.model.startsWith(k.slice(0, star)) && parsed.model.endsWith(k.slice(star + 1));
+        }
+        return false;
+      });
+      return {
+        chain: routes.map((r) => r.displayName),
+        source: "project routing",
+        sourceDetail: pattern
+      };
+    }
+  }
+  const global_ = loadConfig();
+  if (global_.routing && Object.keys(global_.routing).length > 0) {
+    const matched2 = matchRoutingRule(parsed.model, global_.routing);
+    if (matched2) {
+      const routes = buildRoutingChain(matched2, parsed.model);
+      const pattern = Object.keys(global_.routing).find((k) => {
+        if (k === parsed.model)
+          return true;
+        if (k.includes("*")) {
+          const star = k.indexOf("*");
+          return parsed.model.startsWith(k.slice(0, star)) && parsed.model.endsWith(k.slice(star + 1));
+        }
+        return false;
+      });
+      return {
+        chain: routes.map((r) => r.displayName),
+        source: "user routing",
+        sourceDetail: pattern
+      };
+    }
+  }
+  const merged = loadRoutingRules();
+  const matched = matchRoutingRule(parsed.model, merged);
+  if (matched) {
+    const routes = buildRoutingChain(matched, parsed.model);
+    return {
+      chain: routes.map((r) => r.displayName),
+      source: "auto"
+    };
+  }
+  return {
+    chain: [],
+    source: "auto"
+  };
+}
+function pickBannerColor(model, used) {
+  let hash2 = 0;
+  for (let i = 0;i < model.length; i++)
+    hash2 = (hash2 << 5) - hash2 + model.charCodeAt(i) | 0;
+  const start = Math.abs(hash2) % BANNER_BG_COLORS.length;
+  let idx = start;
+  if (used.size < BANNER_BG_COLORS.length) {
+    while (used.has(idx))
+      idx = (idx + 1) % BANNER_BG_COLORS.length;
+  }
+  used.add(idx);
+  return BANNER_BG_COLORS[idx];
+}
+function buildPaneHeader(model, prompt, bg) {
+  const route2 = resolveRouteInfo(model);
+  const esc2 = (s) => s.replace(/'/g, "'\\''");
+  const chainStr = route2.chain.join(" \u2192 ");
+  const sourceLabel = route2.sourceDetail ? `${route2.source}: ${route2.sourceDetail}` : route2.source;
+  const lines = [];
+  lines.push(`printf '\\033[1;97;${bg}m  %s  \\033[0m\\n' '${esc2(model)}';`);
+  lines.push(`printf '\\033[2m  route: ${esc2(chainStr)}  (${esc2(sourceLabel)})\\033[0m\\n' ;`);
+  lines.push(`printf '\\033[2m  %s\\033[0m\\n' '\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500';`);
+  const promptForShell = esc2(prompt).replace(/\n/g, "\\n");
+  lines.push(`printf '%b\\n' '${promptForShell}' | fold -s -w 78 | sed 's/^/  /';`);
+  lines.push(`printf '\\033[2m  %s\\033[0m\\n\\n' '\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500';`);
+  return lines.join(" ");
+}
+function findMagmuxBinary() {
+  const thisFile = fileURLToPath2(import.meta.url);
+  const thisDir = dirname10(thisFile);
+  const pkgRoot = join30(thisDir, "..");
+  const platform2 = process.platform;
+  const arch = process.arch;
+  const bundledMagmux = join30(pkgRoot, "native", `magmux-${platform2}-${arch}`);
+  if (existsSync23(bundledMagmux))
+    return bundledMagmux;
+  try {
+    const pkgName = `@claudish/magmux-${platform2}-${arch}`;
+    let searchDir = pkgRoot;
+    for (let i = 0;i < 5; i++) {
+      const candidate = join30(searchDir, "node_modules", pkgName, "bin", "magmux");
+      if (existsSync23(candidate))
+        return candidate;
+      const parent = dirname10(searchDir);
+      if (parent === searchDir)
+        break;
+      searchDir = parent;
+    }
+  } catch {}
+  try {
+    const result = execSync("which magmux", { encoding: "utf-8" }).trim();
+    if (result)
+      return result;
+  } catch {}
+  throw new Error(`magmux not found. Install it:
+  brew install MadAppGang/tap/magmux`);
+}
+async function subscribeToMagmux(sockPath, onEvent) {
+  let client = null;
+  for (let attempt = 0;attempt < 40; attempt++) {
+    if (existsSync23(sockPath)) {
+      try {
+        client = await new Promise((resolve5, reject) => {
+          const s = netConnect(sockPath);
+          s.once("connect", () => resolve5(s));
+          s.once("error", reject);
+        });
+        break;
+      } catch {}
+    }
+    await wait(50);
+  }
+  if (!client) {
+    return { results: null, client: null };
+  }
+  return await new Promise((resolve5) => {
+    let buf = "";
+    let finalResults = null;
+    client.on("data", (chunk) => {
+      buf += chunk.toString("utf-8");
+      let nl = buf.indexOf(`
+`);
+      while (nl >= 0) {
+        const line = buf.slice(0, nl).trim();
+        buf = buf.slice(nl + 1);
+        nl = buf.indexOf(`
+`);
+        if (!line)
+          continue;
+        try {
+          const evt = JSON.parse(line);
+          onEvent?.(evt);
+          if (evt.type === "results") {
+            finalResults = evt;
+          }
+        } catch {}
+      }
+    });
+    const done = () => resolve5({ results: finalResults, client });
+    client.once("end", done);
+    client.once("close", done);
+    client.once("error", done);
+  });
+}
+function buildTeamStatus(manifest, startedAt, results) {
+  const anonIds = Object.keys(manifest.models);
+  const models = {};
+  for (let i = 0;i < anonIds.length; i++) {
+    const anonId = anonIds[i];
+    const result = results?.find((r) => r.pane === i);
+    if (!result) {
+      models[anonId] = {
+        state: "TIMEOUT",
+        exitCode: null,
+        startedAt,
+        completedAt: null,
+        outputSize: 0
+      };
+      continue;
+    }
+    let state;
+    switch (result.state) {
+      case "completed":
+      case "awaiting_input":
+        state = "COMPLETED";
+        break;
+      case "failed":
+        state = "FAILED";
+        break;
+      default:
+        state = "TIMEOUT";
+    }
+    models[anonId] = {
+      state,
+      exitCode: result.exitCode,
+      startedAt: result.startedAt ?? startedAt,
+      completedAt: result.completedAt ?? new Date().toISOString(),
+      outputSize: result.response?.length ?? 0
+    };
+  }
+  return { startedAt, models };
+}
+async function runWithGrid(sessionPath, models, input, opts) {
+  const mode = opts?.mode ?? "default";
+  const keep = opts?.keep ?? false;
+  const manifest = setupSession(sessionPath, models, input);
+  const startedAt = new Date().toISOString();
+  const gridfilePath = join30(sessionPath, "gridfile.txt");
+  const prompt = readFileSync22(join30(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
+  const rawPrompt = readFileSync22(join30(sessionPath, "input.md"), "utf-8");
+  const usedBannerColors = new Set;
+  const gridLines = Object.entries(manifest.models).map(([anonId]) => {
+    const model = manifest.models[anonId].model;
+    if (mode === "interactive") {
+      return `claudish --model ${model} -i --dangerously-skip-permissions '${prompt}'`;
+    }
+    const bg = pickBannerColor(model, usedBannerColors);
+    const header = buildPaneHeader(model, rawPrompt, bg);
+    return `${header} claudish --model ${model} -y --quiet '${prompt}'`;
+  });
+  writeFileSync15(gridfilePath, `${gridLines.join(`
+`)}
+`, "utf-8");
+  const magmuxPath = findMagmuxBinary();
+  const spawnArgs = ["-g", gridfilePath];
+  if (!keep && mode === "default") {
+    spawnArgs.push("-w");
+  }
+  const proc = spawn3(magmuxPath, spawnArgs, {
+    stdio: "inherit",
+    env: { ...process.env }
+  });
+  const sockPath = `/tmp/magmux-${proc.pid}.sock`;
+  const subscription = subscribeToMagmux(sockPath);
+  const procExit = new Promise((resolve5) => {
+    proc.on("exit", () => resolve5());
+    proc.on("error", () => resolve5());
+  });
+  const [{ results }] = await Promise.all([subscription, procExit]);
+  const status = buildTeamStatus(manifest, startedAt, results?.panes ?? null);
+  const statusPath = join30(sessionPath, "status.json");
+  writeFileSync15(statusPath, JSON.stringify(status, null, 2), "utf-8");
+  return status;
+}
+var BANNER_BG_COLORS;
+var init_team_grid = __esm(() => {
+  init_profile_config();
+  init_model_parser();
+  init_routing_rules();
+  init_team_orchestrator();
+  BANNER_BG_COLORS = [
+    "48;2;40;90;180",
+    "48;2;140;60;160",
+    "48;2;30;130;100",
+    "48;2;160;80;40",
+    "48;2;60;120;60",
+    "48;2;160;50;70"
+  ];
+});
+
+// src/team-cli.ts
+var exports_team_cli = {};
+__export(exports_team_cli, {
+  teamCommand: () => teamCommand
+});
+import { readFileSync as readFileSync23 } from "fs";
+import { join as join31 } from "path";
+function getFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx === -1 || idx + 1 >= args.length)
+    return;
+  return args[idx + 1];
+}
+function hasFlag(args, flag) {
+  return args.includes(flag);
+}
+function printStatus(status) {
+  const modelIds = Object.keys(status.models).sort();
+  console.log(`
+Team Status (started: ${status.startedAt})`);
+  console.log("\u2500".repeat(60));
+  for (const id of modelIds) {
+    const m = status.models[id];
+    const duration3 = m.startedAt && m.completedAt ? `${Math.round((new Date(m.completedAt).getTime() - new Date(m.startedAt).getTime()) / 1000)}s` : m.startedAt ? "running" : "pending";
+    const size = m.outputSize > 0 ? ` (${m.outputSize} bytes)` : "";
+    console.log(`  ${id}  ${m.state.padEnd(10)}  ${duration3}${size}`);
+  }
+  console.log("");
+}
+function printHelp() {
+  console.log(`
+Usage: claudish team <subcommand> [options]
+
+Subcommands:
+  run             Run multiple models on a task in parallel
+  judge           Blind-judge existing model outputs
+  run-and-judge   Run models then judge their outputs
+  status          Show current session status
+
+Options (run / run-and-judge):
+  --path <dir>        Session directory (default: .)
+  --models <a,b,...>  Comma-separated model IDs to run
+  --input <text>      Task prompt (or create input.md in --path beforehand)
+  --timeout <secs>    Timeout per model in seconds (default: 300)
+  --grid              Show all models in a magmux grid with live output + status bar
+
+Options (judge / run-and-judge):
+  --judges <a,b,...>  Comma-separated judge model IDs (default: same as runners)
+
+Options (status):
+  --path <dir>        Session directory (default: .)
+
+Examples:
+  claudish team run --path ./review --models minimax-m2.5,kimi-k2.5 --input "Review this code"
+  claudish team run --grid --models kimi-k2.5,gpt-5.4,gemini-3.1-pro --input "Solve this"
+  claudish team judge --path ./review
+  claudish team run-and-judge --path ./review --models gpt-5.4,gemini-3.1-pro-preview --input "Evaluate this design"
+  claudish team status --path ./review
+`);
+}
+async function teamCommand(args) {
+  if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
+    printHelp();
+    process.exit(0);
+  }
+  const firstArg = args[0] ?? "";
+  const legacySubs = ["run", "judge", "run-and-judge", "status"];
+  const subcommand = legacySubs.includes(firstArg) ? firstArg : "run";
+  const rawSessionPath = getFlag(args, "--path") ?? ".";
+  let sessionPath;
+  try {
+    sessionPath = validateSessionPath(rawSessionPath);
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  const modelsRaw = getFlag(args, "--models");
+  const judgesRaw = getFlag(args, "--judges");
+  const mode = getFlag(args, "--mode") ?? "default";
+  const timeoutStr = getFlag(args, "--timeout");
+  const timeout = timeoutStr ? Number.parseInt(timeoutStr, 10) : 300;
+  let input = getFlag(args, "--input");
+  if (!input) {
+    const flagsWithValues = ["--models", "--judges", "--mode", "--path", "--timeout", "--input"];
+    const positionals = args.filter((a, i) => {
+      if (legacySubs.includes(a) && i === 0)
+        return false;
+      if (a.startsWith("--"))
+        return false;
+      const prev = args[i - 1];
+      if (prev && flagsWithValues.includes(prev))
+        return false;
+      return true;
+    });
+    if (positionals.length > 0)
+      input = positionals.join(" ");
+  }
+  const models = modelsRaw ? modelsRaw.split(",").map((m) => m.trim()).filter(Boolean) : [];
+  const judges = judgesRaw ? judgesRaw.split(",").map((m) => m.trim()).filter(Boolean) : undefined;
+  const effectiveMode = hasFlag(args, "--interactive") ? "interactive" : hasFlag(args, "--grid") ? "default" : mode;
+  switch (subcommand) {
+    case "run": {
+      if (models.length === 0) {
+        console.error("Error: --models is required");
+        printHelp();
+        process.exit(1);
+      }
+      if (effectiveMode === "json") {
+        setupSession(sessionPath, models, input);
+        const runStatus = await runModels(sessionPath, {
+          timeout,
+          onStatusChange: (id, s) => {
+            process.stderr.write(`[team] ${id}: ${s.state}
+`);
+          }
+        });
+        printStatus(runStatus);
+      } else {
+        const { runWithGrid: runWithGrid2 } = await Promise.resolve().then(() => (init_team_grid(), exports_team_grid));
+        const gridStatus = await runWithGrid2(sessionPath, models, input ?? "", {
+          timeout,
+          mode: effectiveMode === "interactive" ? "interactive" : "default"
+        });
+        printStatus(gridStatus);
+      }
+      break;
+    }
+    case "judge": {
+      await judgeResponses(sessionPath, { judges });
+      console.log(readFileSync23(join31(sessionPath, "verdict.md"), "utf-8"));
+      break;
+    }
+    case "run-and-judge": {
+      if (models.length === 0) {
+        console.error("Error: --models is required");
+        process.exit(1);
+      }
+      setupSession(sessionPath, models, input);
+      const status = await runModels(sessionPath, {
+        timeout,
+        onStatusChange: (id, s) => {
+          process.stderr.write(`[team] ${id}: ${s.state}
+`);
+        }
+      });
+      printStatus(status);
+      await judgeResponses(sessionPath, { judges });
+      console.log(readFileSync23(join31(sessionPath, "verdict.md"), "utf-8"));
+      break;
+    }
+    case "status": {
+      const statusResult = getStatus(sessionPath);
+      printStatus(statusResult);
+      break;
+    }
+  }
+}
+var init_team_cli = __esm(() => {
+  init_team_orchestrator();
+});
+
 // src/auth/credentials/source.ts
 function describeSourceSync(p, config3) {
   if (p.isLocal)
@@ -63014,8 +63922,8 @@ var init_RemoveFileError = __esm(() => {
 });
 
 // ../../node_modules/.bun/@inquirer+external-editor@2.0.1+04f2146be16c61ef/node_modules/@inquirer/external-editor/dist/index.js
-import { spawn as spawn3, spawnSync as spawnSync2 } from "child_process";
-import { readFileSync as readFileSync22, unlinkSync as unlinkSync5, writeFileSync as writeFileSync15 } from "fs";
+import { spawn as spawn4, spawnSync as spawnSync2 } from "child_process";
+import { readFileSync as readFileSync24, unlinkSync as unlinkSync5, writeFileSync as writeFileSync16 } from "fs";
 import path from "path";
 import os from "os";
 import { randomUUID as randomUUID5 } from "crypto";
@@ -63124,14 +64032,14 @@ class ExternalEditor {
       if (Object.prototype.hasOwnProperty.call(this.fileOptions, "mode")) {
         opt.mode = this.fileOptions.mode;
       }
-      writeFileSync15(this.tempFile, this.text, opt);
+      writeFileSync16(this.tempFile, this.text, opt);
     } catch (createFileError) {
       throw new CreateFileError(createFileError);
     }
   }
   readTemporaryFile() {
     try {
-      const tempFileBuffer = readFileSync22(this.tempFile);
+      const tempFileBuffer = readFileSync24(this.tempFile);
       if (tempFileBuffer.length === 0) {
         this.text = "";
       } else {
@@ -63162,7 +64070,7 @@ class ExternalEditor {
   }
   launchEditorAsync(callback) {
     try {
-      const editorProcess = spawn3(this.editor.bin, this.editor.args.concat([this.tempFile]), { stdio: "inherit" });
+      const editorProcess = spawn4(this.editor.bin, this.editor.args.concat([this.tempFile]), { stdio: "inherit" });
       editorProcess.on("exit", (code) => {
         this.lastExitStatus = code;
         setImmediate(callback);
@@ -64112,9 +65020,9 @@ var init_dist16 = __esm(() => {
 
 // src/auth/antigravity-oauth.ts
 import { spawnSync as spawnSync3 } from "child_process";
-import { existsSync as existsSync23, unlinkSync as unlinkSync6 } from "fs";
+import { existsSync as existsSync24, unlinkSync as unlinkSync6 } from "fs";
 import { homedir as homedir28 } from "os";
-import { join as join30 } from "path";
+import { join as join32 } from "path";
 async function defaultSuggestModel() {
   try {
     const tok = readSharedAntigravityToken();
@@ -64235,8 +65143,8 @@ No session detected yet. Starting the Antigravity CLI interactively \u2014
   async logout(deps) {
     deleteSharedAntigravityToken(deps);
     try {
-      const tokenFile = join30(homedir28(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
-      if (existsSync23(tokenFile))
+      const tokenFile = join32(homedir28(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
+      if (existsSync24(tokenFile))
         unlinkSync6(tokenFile);
     } catch {}
     log("[AntigravityOAuth] Antigravity session cleared (keychain + agy token file)");
@@ -68322,22 +69230,22 @@ __export(exports_cli, {
 });
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync24,
+  existsSync as existsSync25,
   mkdirSync as mkdirSync14,
-  readFileSync as readFileSync23,
+  readFileSync as readFileSync25,
   readdirSync as readdirSync5,
   unlinkSync as unlinkSync7,
-  writeFileSync as writeFileSync16
+  writeFileSync as writeFileSync17
 } from "fs";
 import { homedir as homedir29 } from "os";
-import { dirname as dirname10, join as join31 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname11, join as join33 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 function getVersion3() {
   return VERSION;
 }
 function clearAllModelCaches() {
-  const cacheDir = join31(homedir29(), ".claudish");
-  if (!existsSync24(cacheDir))
+  const cacheDir = join33(homedir29(), ".claudish");
+  if (!existsSync25(cacheDir))
     return;
   const cachePatterns = ["pricing-cache.json", "recommended-models-cache.json"];
   let cleared = 0;
@@ -68345,7 +69253,7 @@ function clearAllModelCaches() {
     const files = readdirSync5(cacheDir);
     for (const file2 of files) {
       if (cachePatterns.includes(file2)) {
-        unlinkSync7(join31(cacheDir, file2));
+        unlinkSync7(join33(cacheDir, file2));
         cleared++;
       }
     }
@@ -68578,7 +69486,7 @@ async function parseArgs(args) {
       printVersion();
       process.exit(0);
     } else if (arg === "--help" || arg === "-h") {
-      printHelp();
+      printHelp2();
       process.exit(0);
     } else if (arg === "--help-ai") {
       printAIAgentGuide();
@@ -68760,15 +69668,15 @@ Usage:  claudish --models --provider <slug>`);
     });
     config3.resolvedDefaultProvider = resolved;
     if (resolved.legacyAutoPromoted && !config3.quiet) {
-      const markerFile = join31(homedir29(), ".claudish", ".legacy-litellm-hint-shown");
-      if (!existsSync24(markerFile)) {
+      const markerFile = join33(homedir29(), ".claudish", ".legacy-litellm-hint-shown");
+      if (!existsSync25(markerFile)) {
         const hint = buildLegacyHint(resolved);
         if (hint) {
           console.error(hint);
         }
         try {
-          mkdirSync14(dirname10(markerFile), { recursive: true });
-          writeFileSync16(markerFile, new Date().toISOString(), "utf-8");
+          mkdirSync14(dirname11(markerFile), { recursive: true });
+          writeFileSync17(markerFile, new Date().toISOString(), "utf-8");
         } catch {}
       }
     }
@@ -69535,7 +70443,7 @@ async function probeModelRouting(models, jsonOutput, options = { live: true, tim
     await tui.shutdown();
   }
 }
-function printHelp() {
+function printHelp2() {
   const useColor = !!process.stdout.isTTY && !process.env.NO_COLOR;
   const c = (code) => (s) => useColor ? `\x1B[${code}m${s}\x1B[0m` : s;
   const bold4 = c("1");
@@ -69838,8 +70746,8 @@ ${h("MORE INFO")}
 }
 function printAIAgentGuide() {
   try {
-    const guidePath = join31(__dirname3, "../AI_AGENT_GUIDE.md");
-    const guideContent = readFileSync23(guidePath, "utf-8");
+    const guidePath = join33(__dirname3, "../AI_AGENT_GUIDE.md");
+    const guideContent = readFileSync25(guidePath, "utf-8");
     console.log(guideContent);
   } catch (error46) {
     console.error("Error reading AI Agent Guide:");
@@ -69855,19 +70763,19 @@ async function initializeClaudishSkill() {
   console.log(`\uD83D\uDD27 Initializing Claudish skill in current project...
 `);
   const cwd = process.cwd();
-  const claudeDir = join31(cwd, ".claude");
-  const skillsDir = join31(claudeDir, "skills");
-  const claudishSkillDir = join31(skillsDir, "claudish-usage");
-  const skillFile = join31(claudishSkillDir, "SKILL.md");
-  if (existsSync24(skillFile)) {
+  const claudeDir = join33(cwd, ".claude");
+  const skillsDir = join33(claudeDir, "skills");
+  const claudishSkillDir = join33(skillsDir, "claudish-usage");
+  const skillFile = join33(claudishSkillDir, "SKILL.md");
+  if (existsSync25(skillFile)) {
     console.log("\u2705 Claudish skill already installed at:");
     console.log(`   ${skillFile}
 `);
     console.log("\uD83D\uDCA1 To reinstall, delete the file and run 'claudish --init' again.");
     return;
   }
-  const sourceSkillPath = join31(__dirname3, "../skills/claudish-usage/SKILL.md");
-  if (!existsSync24(sourceSkillPath)) {
+  const sourceSkillPath = join33(__dirname3, "../skills/claudish-usage/SKILL.md");
+  if (!existsSync25(sourceSkillPath)) {
     console.error("\u274C Error: Claudish skill file not found in installation.");
     console.error(`   Expected at: ${sourceSkillPath}`);
     console.error(`
@@ -69876,15 +70784,15 @@ async function initializeClaudishSkill() {
     process.exit(1);
   }
   try {
-    if (!existsSync24(claudeDir)) {
+    if (!existsSync25(claudeDir)) {
       mkdirSync14(claudeDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/ directory");
     }
-    if (!existsSync24(skillsDir)) {
+    if (!existsSync25(skillsDir)) {
       mkdirSync14(skillsDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/ directory");
     }
-    if (!existsSync24(claudishSkillDir)) {
+    if (!existsSync25(claudishSkillDir)) {
       mkdirSync14(claudishSkillDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/claudish-usage/ directory");
     }
@@ -69956,8 +70864,8 @@ var init_cli = __esm(() => {
   init_provider_definitions();
   init_routing_rules();
   init_provider_resolver();
-  __filename3 = fileURLToPath2(import.meta.url);
-  __dirname3 = dirname10(__filename3);
+  __filename3 = fileURLToPath3(import.meta.url);
+  __dirname3 = dirname11(__filename3);
 });
 
 // src/update-checker.ts
@@ -69969,33 +70877,33 @@ __export(exports_update_checker, {
   clearCache: () => clearCache,
   checkForUpdates: () => checkForUpdates
 });
-import { existsSync as existsSync25, mkdirSync as mkdirSync15, readFileSync as readFileSync24, unlinkSync as unlinkSync8, writeFileSync as writeFileSync17 } from "fs";
+import { existsSync as existsSync26, mkdirSync as mkdirSync15, readFileSync as readFileSync26, unlinkSync as unlinkSync8, writeFileSync as writeFileSync18 } from "fs";
 import { homedir as homedir30, platform as platform2, tmpdir } from "os";
-import { join as join32 } from "path";
+import { join as join34 } from "path";
 function getCacheFilePath() {
   let cacheDir;
   if (isWindows) {
-    const localAppData = process.env.LOCALAPPDATA || join32(homedir30(), "AppData", "Local");
-    cacheDir = join32(localAppData, "claudish");
+    const localAppData = process.env.LOCALAPPDATA || join34(homedir30(), "AppData", "Local");
+    cacheDir = join34(localAppData, "claudish");
   } else {
-    cacheDir = join32(homedir30(), ".cache", "claudish");
+    cacheDir = join34(homedir30(), ".cache", "claudish");
   }
   try {
-    if (!existsSync25(cacheDir)) {
+    if (!existsSync26(cacheDir)) {
       mkdirSync15(cacheDir, { recursive: true });
     }
-    return join32(cacheDir, "update-check.json");
+    return join34(cacheDir, "update-check.json");
   } catch {
-    return join32(tmpdir(), "claudish-update-check.json");
+    return join34(tmpdir(), "claudish-update-check.json");
   }
 }
 function readCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (!existsSync25(cachePath)) {
+    if (!existsSync26(cachePath)) {
       return null;
     }
-    const data = JSON.parse(readFileSync24(cachePath, "utf-8"));
+    const data = JSON.parse(readFileSync26(cachePath, "utf-8"));
     return data;
   } catch {
     return null;
@@ -70008,7 +70916,7 @@ function writeCache(latestVersion) {
       lastCheck: Date.now(),
       latestVersion
     };
-    writeFileSync17(cachePath, JSON.stringify(data), "utf-8");
+    writeFileSync18(cachePath, JSON.stringify(data), "utf-8");
   } catch {}
 }
 function isCacheValid(cache2) {
@@ -70018,7 +70926,7 @@ function isCacheValid(cache2) {
 function clearCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (existsSync25(cachePath)) {
+    if (existsSync26(cachePath)) {
       unlinkSync8(cachePath);
     }
   } catch {}
@@ -70106,7 +71014,7 @@ var exports_update_command = {};
 __export(exports_update_command, {
   updateCommand: () => updateCommand
 });
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 function detectInstallationMethod() {
   const scriptPath = process.argv[1] || "";
   if (scriptPath.includes("/opt/homebrew/") || scriptPath.includes("/usr/local/Cellar/")) {
@@ -70134,7 +71042,7 @@ function getUpdateCommand(method) {
 }
 async function executeUpdate(command) {
   try {
-    execSync(command, {
+    execSync2(command, {
       stdio: "inherit",
       shell: process.platform === "win32" ? "cmd.exe" : "/bin/sh"
     });
@@ -70271,7 +71179,7 @@ ${BOLD2}Unable to detect installation method.${RESET2}`);
 }
 function fetchLatestVersionViaNpm() {
   try {
-    const output = execSync("npm view claudish version", {
+    const output = execSync2("npm view claudish version", {
       encoding: "utf-8",
       timeout: 20000,
       stdio: ["ignore", "pipe", "ignore"]
@@ -70903,15 +71811,15 @@ var init_local_liveness = __esm(() => {
 });
 
 // src/providers/probe-catalog.ts
-import { existsSync as existsSync26, mkdirSync as mkdirSync16, readFileSync as readFileSync25, writeFileSync as writeFileSync18 } from "fs";
+import { existsSync as existsSync27, mkdirSync as mkdirSync16, readFileSync as readFileSync27, writeFileSync as writeFileSync19 } from "fs";
 import { homedir as homedir31 } from "os";
-import { dirname as dirname11, join as join33 } from "path";
+import { dirname as dirname12, join as join35 } from "path";
 function readProbeModelsCache(path2 = PROBE_MODELS_CACHE_PATH) {
-  if (!existsSync26(path2))
+  if (!existsSync27(path2))
     return null;
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync25(path2, "utf-8"));
+    raw2 = JSON.parse(readFileSync27(path2, "utf-8"));
   } catch {
     return null;
   }
@@ -70920,8 +71828,8 @@ function readProbeModelsCache(path2 = PROBE_MODELS_CACHE_PATH) {
   return raw2;
 }
 function writeProbeModelsCache(data, path2 = PROBE_MODELS_CACHE_PATH) {
-  mkdirSync16(dirname11(path2), { recursive: true });
-  writeFileSync18(path2, JSON.stringify(data), "utf-8");
+  mkdirSync16(dirname12(path2), { recursive: true });
+  writeFileSync19(path2, JSON.stringify(data), "utf-8");
 }
 function isCacheFresh(data, ttlMs = CACHE_TTL_MS4) {
   if (!data?.generatedAt)
@@ -71040,7 +71948,7 @@ function isValidResponse(raw2) {
 var PROBE_MODELS_URL = "https://us-central1-claudish-6da10.cloudfunctions.net/probeModels", CACHE_TTL_MS4, FETCH_TIMEOUT_MS3 = 15000, PROBE_MODELS_CACHE_PATH, _inFlight = null;
 var init_probe_catalog = __esm(() => {
   CACHE_TTL_MS4 = 60 * 60 * 1000;
-  PROBE_MODELS_CACHE_PATH = join33(homedir31(), ".claudish", "probe-models.json");
+  PROBE_MODELS_CACHE_PATH = join35(homedir31(), ".claudish", "probe-models.json");
 });
 
 // src/tui/constants.ts
@@ -77387,20 +78295,20 @@ __export(exports_claude_runner, {
   MIN_AUTO_COMPACT_WINDOW: () => MIN_AUTO_COMPACT_WINDOW,
   CLAUDE_CODE_DEFAULT_MAX_CONTEXT: () => CLAUDE_CODE_DEFAULT_MAX_CONTEXT
 });
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import {
   closeSync as closeSync4,
-  existsSync as existsSync27,
+  existsSync as existsSync28,
   mkdirSync as mkdirSync17,
   openSync as openSync4,
-  readFileSync as readFileSync26,
+  readFileSync as readFileSync28,
   readdirSync as readdirSync6,
   statSync as statSync5,
   unlinkSync as unlinkSync9,
-  writeFileSync as writeFileSync19
+  writeFileSync as writeFileSync20
 } from "fs";
 import { homedir as homedir32, tmpdir as tmpdir2 } from "os";
-import { dirname as dirname12, join as join34 } from "path";
+import { dirname as dirname13, join as join36 } from "path";
 import { isatty } from "tty";
 function releaseTerminalIsolation() {
   if (!restoreTerminal)
@@ -77435,14 +78343,14 @@ function isProxyAuthMode(config3) {
 }
 function managedSettingsPath() {
   if (isWindows2()) {
-    return join34(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
+    return join36(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
   }
   if (process.platform === "darwin") {
     return "/Library/Application Support/ClaudeCode/managed-settings.json";
   }
   return "/etc/claude-code/managed-settings.json";
 }
-function managedSettingsForcesClaudeAi(readFile3 = readFileSync26) {
+function managedSettingsForcesClaudeAi(readFile3 = readFileSync28) {
   try {
     const raw2 = readFile3(managedSettingsPath(), "utf-8");
     const parsed = JSON.parse(raw2);
@@ -77456,9 +78364,9 @@ function isWindows2() {
 }
 function createStatusLineScript(tokenFilePath) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join34(homeDir, ".claudish");
+  const claudishDir = join36(homeDir, ".claudish");
   const timestamp = Date.now();
-  const scriptPath = join34(claudishDir, `status-${timestamp}.js`);
+  const scriptPath = join36(claudishDir, `status-${timestamp}.js`);
   const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
   const script = `
 const fs = require('fs');
@@ -77585,13 +78493,13 @@ process.stdin.on('end', () => {
   }
 });
 `;
-  writeFileSync19(scriptPath, script, "utf-8");
+  writeFileSync20(scriptPath, script, "utf-8");
   return scriptPath;
 }
 function initializeTokenFile(tokenFilePath) {
   try {
-    mkdirSync17(dirname12(tokenFilePath), { recursive: true });
-    writeFileSync19(tokenFilePath, JSON.stringify({
+    mkdirSync17(dirname13(tokenFilePath), { recursive: true });
+    writeFileSync20(tokenFilePath, JSON.stringify({
       input_tokens: 0,
       output_tokens: 0,
       total_tokens: 0,
@@ -77622,7 +78530,7 @@ function cleanupStaleTokenFiles(dir, now = Date.now(), maxAgeMs = STALE_TOKEN_FI
     if (!name.startsWith("tokens-") || !name.endsWith(".json"))
       continue;
     scanned++;
-    const full = join34(dir, name);
+    const full = join36(dir, name);
     try {
       if (statSync5(full).mtimeMs >= cutoff)
         continue;
@@ -77639,7 +78547,7 @@ function parseSettingsArg(value) {
   if (value.trimStart().startsWith("{")) {
     return JSON.parse(value);
   }
-  return JSON.parse(readFileSync26(value, "utf-8"));
+  return JSON.parse(readFileSync28(value, "utf-8"));
 }
 function parseSettingsArgSafe(value) {
   try {
@@ -77651,13 +78559,13 @@ function parseSettingsArgSafe(value) {
 }
 function userSettingsFileCandidates(cwd) {
   return [
-    join34(homedir32(), ".claude", "settings.json"),
-    join34(cwd, ".claude", "settings.json"),
-    join34(cwd, ".claude", "settings.local.json")
+    join36(homedir32(), ".claude", "settings.json"),
+    join36(cwd, ".claude", "settings.json"),
+    join36(cwd, ".claude", "settings.local.json")
   ];
 }
 function discoverUserStatusLineCommand(claudeArgs = [], cwd = process.cwd()) {
-  const sources = userSettingsFileCandidates(cwd).filter((file2) => existsSync27(file2));
+  const sources = userSettingsFileCandidates(cwd).filter((file2) => existsSync28(file2));
   const idx = claudeArgs.indexOf("--settings");
   const settingsArg = idx === -1 ? undefined : claudeArgs[idx + 1];
   if (settingsArg)
@@ -77694,13 +78602,13 @@ function buildChainedStatusCommand(userCommand, claudishBody, claudishSegment) {
 }
 function createTempSettingsFile(_modelDisplay, port, proxyAuthMode, userStatusLineCommand) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join34(homeDir, ".claudish");
+  const claudishDir = join36(homeDir, ".claudish");
   try {
     mkdirSync17(claudishDir, { recursive: true });
   } catch {}
   const timestamp = Date.now();
-  const tempPath = join34(claudishDir, `settings-${timestamp}.json`);
-  const tokenFilePath = join34(claudishDir, `tokens-${port}.json`);
+  const tempPath = join36(claudishDir, `settings-${timestamp}.json`);
+  const tokenFilePath = join36(claudishDir, `tokens-${port}.json`);
   cleanupStaleTokenFiles(claudishDir);
   initializeTokenFile(tokenFilePath);
   let statusCommand;
@@ -77733,7 +78641,7 @@ function createTempSettingsFile(_modelDisplay, port, proxyAuthMode, userStatusLi
     padding: 0
   };
   const settings = buildClaudishSettingsOverlay(statusLine, proxyAuthMode);
-  writeFileSync19(tempPath, JSON.stringify(settings, null, 2), "utf-8");
+  writeFileSync20(tempPath, JSON.stringify(settings, null, 2), "utf-8");
   return { path: tempPath, statusLine, tokenFilePath };
 }
 function buildClaudishSettingsOverlay(statusLine, proxyAuthMode) {
@@ -77758,7 +78666,7 @@ function mergeUserSettingsIfPresent(config3, tempSettingsPath, statusLine, proxy
     if (proxyAuthMode && !("forceLoginMethod" in userSettings)) {
       userSettings.forceLoginMethod = "console";
     }
-    writeFileSync19(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
+    writeFileSync20(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
   } catch {
     if (!config3.quiet) {
       console.warn(`[claudish] Warning: could not merge user settings: ${userSettingsValue}`);
@@ -77951,7 +78859,7 @@ async function runClaudeWithProxy(config3, proxyUrl, onCleanup) {
     console.error(`
 Or set CLAUDE_PATH to your custom installation:`);
     const home = homedir32();
-    const localPath = isWindows2() ? join34(home, ".claude", "local", "claude.exe") : join34(home, ".claude", "local", "claude");
+    const localPath = isWindows2() ? join36(home, ".claude", "local", "claude.exe") : join36(home, ".claude", "local", "claude");
     console.error(`  export CLAUDE_PATH=${localPath}`);
     process.exit(1);
   }
@@ -77975,7 +78883,7 @@ Or set CLAUDE_PATH to your custom installation:`);
     console.error("[claudish] An interactive session was requested but no terminal is attached (stdin and stdout are both non-TTY). Pass a prompt argument, or use --stdin / -p for non-interactive mode.");
   }
   const stdio = ttyFd !== undefined ? [0, ttyFd, ttyFd] : "inherit";
-  const proc = spawn4(spawnCommand, claudeArgs, {
+  const proc = spawn5(spawnCommand, claudeArgs, {
     env,
     stdio,
     shell: needsShell
@@ -78031,23 +78939,23 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet, onCleanup) {
 async function findClaudeBinary() {
   const isWindows3 = process.platform === "win32";
   if (process.env.CLAUDE_PATH) {
-    if (existsSync27(process.env.CLAUDE_PATH)) {
+    if (existsSync28(process.env.CLAUDE_PATH)) {
       return process.env.CLAUDE_PATH;
     }
   }
   const home = homedir32();
-  const localPath = isWindows3 ? join34(home, ".claude", "local", "claude.exe") : join34(home, ".claude", "local", "claude");
-  if (existsSync27(localPath)) {
+  const localPath = isWindows3 ? join36(home, ".claude", "local", "claude.exe") : join36(home, ".claude", "local", "claude");
+  if (existsSync28(localPath)) {
     return localPath;
   }
   if (isWindows3) {
     const windowsPaths = [
-      join34(home, "AppData", "Roaming", "npm", "claude.cmd"),
-      join34(home, ".npm-global", "claude.cmd"),
-      join34(home, "node_modules", ".bin", "claude.cmd")
+      join36(home, "AppData", "Roaming", "npm", "claude.cmd"),
+      join36(home, ".npm-global", "claude.cmd"),
+      join36(home, "node_modules", ".bin", "claude.cmd")
     ];
     for (const path2 of windowsPaths) {
-      if (existsSync27(path2)) {
+      if (existsSync28(path2)) {
         return path2;
       }
     }
@@ -78055,21 +78963,21 @@ async function findClaudeBinary() {
     const commonPaths = [
       "/usr/local/bin/claude",
       "/opt/homebrew/bin/claude",
-      join34(home, ".npm-global/bin/claude"),
-      join34(home, ".local/bin/claude"),
-      join34(home, "node_modules/.bin/claude"),
+      join36(home, ".npm-global/bin/claude"),
+      join36(home, ".local/bin/claude"),
+      join36(home, "node_modules/.bin/claude"),
       "/data/data/com.termux/files/usr/bin/claude",
-      join34(home, "../usr/bin/claude")
+      join36(home, "../usr/bin/claude")
     ];
     for (const path2 of commonPaths) {
-      if (existsSync27(path2)) {
+      if (existsSync28(path2)) {
         return path2;
       }
     }
   }
   try {
     const shellCommand = isWindows3 ? "where claude" : "command -v claude";
-    const proc = spawn4(shellCommand, [], {
+    const proc = spawn5(shellCommand, [], {
       stdio: "pipe",
       shell: true
     });
@@ -78121,18 +79029,18 @@ __export(exports_diag_output, {
   NullDiagOutput: () => NullDiagOutput,
   LogFileDiagOutput: () => LogFileDiagOutput
 });
-import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync18, unlinkSync as unlinkSync10, writeFileSync as writeFileSync20 } from "fs";
+import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync18, unlinkSync as unlinkSync10, writeFileSync as writeFileSync21 } from "fs";
 import { homedir as homedir33 } from "os";
-import { join as join35 } from "path";
+import { join as join37 } from "path";
 function getClaudishDir() {
-  const dir = join35(homedir33(), ".claudish");
+  const dir = join37(homedir33(), ".claudish");
   try {
     mkdirSync18(dir, { recursive: true });
   } catch {}
   return dir;
 }
 function getDiagLogPath() {
-  return join35(getClaudishDir(), `diag-${process.pid}.log`);
+  return join37(getClaudishDir(), `diag-${process.pid}.log`);
 }
 
 class LogFileDiagOutput {
@@ -78141,7 +79049,7 @@ class LogFileDiagOutput {
   constructor() {
     this.logPath = getDiagLogPath();
     try {
-      writeFileSync20(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
+      writeFileSync21(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
 `);
     } catch {}
     this.stream = createWriteStream3(this.logPath, { flags: "a" });
@@ -78328,279 +79236,6 @@ var init_catalog_warm = __esm(() => {
   ];
 });
 
-// src/team-grid.ts
-var exports_team_grid = {};
-__export(exports_team_grid, {
-  runWithGrid: () => runWithGrid
-});
-import { spawn as spawn5 } from "child_process";
-import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync28, readFileSync as readFileSync27, writeFileSync as writeFileSync21 } from "fs";
-import { connect as netConnect } from "net";
-import { dirname as dirname13, join as join36 } from "path";
-import { setTimeout as wait } from "timers/promises";
-import { fileURLToPath as fileURLToPath3 } from "url";
-function resolveRouteInfo(modelId) {
-  const parsed = parseModelSpec(modelId);
-  if (parsed.isExplicitProvider) {
-    return { chain: [parsed.provider], source: "direct" };
-  }
-  const local = loadLocalConfig();
-  if (local?.routing && Object.keys(local.routing).length > 0) {
-    const matched2 = matchRoutingRule(parsed.model, local.routing);
-    if (matched2) {
-      const routes = buildRoutingChain(matched2, parsed.model);
-      const pattern = Object.keys(local.routing).find((k) => {
-        if (k === parsed.model)
-          return true;
-        if (k.includes("*")) {
-          const star = k.indexOf("*");
-          return parsed.model.startsWith(k.slice(0, star)) && parsed.model.endsWith(k.slice(star + 1));
-        }
-        return false;
-      });
-      return {
-        chain: routes.map((r) => r.displayName),
-        source: "project routing",
-        sourceDetail: pattern
-      };
-    }
-  }
-  const global_ = loadConfig();
-  if (global_.routing && Object.keys(global_.routing).length > 0) {
-    const matched2 = matchRoutingRule(parsed.model, global_.routing);
-    if (matched2) {
-      const routes = buildRoutingChain(matched2, parsed.model);
-      const pattern = Object.keys(global_.routing).find((k) => {
-        if (k === parsed.model)
-          return true;
-        if (k.includes("*")) {
-          const star = k.indexOf("*");
-          return parsed.model.startsWith(k.slice(0, star)) && parsed.model.endsWith(k.slice(star + 1));
-        }
-        return false;
-      });
-      return {
-        chain: routes.map((r) => r.displayName),
-        source: "user routing",
-        sourceDetail: pattern
-      };
-    }
-  }
-  const merged = loadRoutingRules();
-  const matched = matchRoutingRule(parsed.model, merged);
-  if (matched) {
-    const routes = buildRoutingChain(matched, parsed.model);
-    return {
-      chain: routes.map((r) => r.displayName),
-      source: "auto"
-    };
-  }
-  return {
-    chain: [],
-    source: "auto"
-  };
-}
-function pickBannerColor(model, used) {
-  let hash2 = 0;
-  for (let i = 0;i < model.length; i++)
-    hash2 = (hash2 << 5) - hash2 + model.charCodeAt(i) | 0;
-  const start = Math.abs(hash2) % BANNER_BG_COLORS.length;
-  let idx = start;
-  if (used.size < BANNER_BG_COLORS.length) {
-    while (used.has(idx))
-      idx = (idx + 1) % BANNER_BG_COLORS.length;
-  }
-  used.add(idx);
-  return BANNER_BG_COLORS[idx];
-}
-function buildPaneHeader(model, prompt, bg) {
-  const route2 = resolveRouteInfo(model);
-  const esc2 = (s) => s.replace(/'/g, "'\\''");
-  const chainStr2 = route2.chain.join(" \u2192 ");
-  const sourceLabel = route2.sourceDetail ? `${route2.source}: ${route2.sourceDetail}` : route2.source;
-  const lines = [];
-  lines.push(`printf '\\033[1;97;${bg}m  %s  \\033[0m\\n' '${esc2(model)}';`);
-  lines.push(`printf '\\033[2m  route: ${esc2(chainStr2)}  (${esc2(sourceLabel)})\\033[0m\\n' ;`);
-  lines.push(`printf '\\033[2m  %s\\033[0m\\n' '\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500';`);
-  const promptForShell = esc2(prompt).replace(/\n/g, "\\n");
-  lines.push(`printf '%b\\n' '${promptForShell}' | fold -s -w 78 | sed 's/^/  /';`);
-  lines.push(`printf '\\033[2m  %s\\033[0m\\n\\n' '\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500';`);
-  return lines.join(" ");
-}
-function findMagmuxBinary() {
-  const thisFile = fileURLToPath3(import.meta.url);
-  const thisDir = dirname13(thisFile);
-  const pkgRoot = join36(thisDir, "..");
-  const platform3 = process.platform;
-  const arch = process.arch;
-  const bundledMagmux = join36(pkgRoot, "native", `magmux-${platform3}-${arch}`);
-  if (existsSync28(bundledMagmux))
-    return bundledMagmux;
-  try {
-    const pkgName = `@claudish/magmux-${platform3}-${arch}`;
-    let searchDir = pkgRoot;
-    for (let i = 0;i < 5; i++) {
-      const candidate = join36(searchDir, "node_modules", pkgName, "bin", "magmux");
-      if (existsSync28(candidate))
-        return candidate;
-      const parent = dirname13(searchDir);
-      if (parent === searchDir)
-        break;
-      searchDir = parent;
-    }
-  } catch {}
-  try {
-    const result = execSync2("which magmux", { encoding: "utf-8" }).trim();
-    if (result)
-      return result;
-  } catch {}
-  throw new Error(`magmux not found. Install it:
-  brew install MadAppGang/tap/magmux`);
-}
-async function subscribeToMagmux(sockPath, onEvent) {
-  let client = null;
-  for (let attempt = 0;attempt < 40; attempt++) {
-    if (existsSync28(sockPath)) {
-      try {
-        client = await new Promise((resolve5, reject) => {
-          const s = netConnect(sockPath);
-          s.once("connect", () => resolve5(s));
-          s.once("error", reject);
-        });
-        break;
-      } catch {}
-    }
-    await wait(50);
-  }
-  if (!client) {
-    return { results: null, client: null };
-  }
-  return await new Promise((resolve5) => {
-    let buf = "";
-    let finalResults = null;
-    client.on("data", (chunk) => {
-      buf += chunk.toString("utf-8");
-      let nl = buf.indexOf(`
-`);
-      while (nl >= 0) {
-        const line = buf.slice(0, nl).trim();
-        buf = buf.slice(nl + 1);
-        nl = buf.indexOf(`
-`);
-        if (!line)
-          continue;
-        try {
-          const evt = JSON.parse(line);
-          onEvent?.(evt);
-          if (evt.type === "results") {
-            finalResults = evt;
-          }
-        } catch {}
-      }
-    });
-    const done = () => resolve5({ results: finalResults, client });
-    client.once("end", done);
-    client.once("close", done);
-    client.once("error", done);
-  });
-}
-function buildTeamStatus(manifest, startedAt, results) {
-  const anonIds = Object.keys(manifest.models);
-  const models = {};
-  for (let i = 0;i < anonIds.length; i++) {
-    const anonId = anonIds[i];
-    const result = results?.find((r) => r.pane === i);
-    if (!result) {
-      models[anonId] = {
-        state: "TIMEOUT",
-        exitCode: null,
-        startedAt,
-        completedAt: null,
-        outputSize: 0
-      };
-      continue;
-    }
-    let state;
-    switch (result.state) {
-      case "completed":
-      case "awaiting_input":
-        state = "COMPLETED";
-        break;
-      case "failed":
-        state = "FAILED";
-        break;
-      default:
-        state = "TIMEOUT";
-    }
-    models[anonId] = {
-      state,
-      exitCode: result.exitCode,
-      startedAt: result.startedAt ?? startedAt,
-      completedAt: result.completedAt ?? new Date().toISOString(),
-      outputSize: result.response?.length ?? 0
-    };
-  }
-  return { startedAt, models };
-}
-async function runWithGrid(sessionPath, models, input, opts) {
-  const mode = opts?.mode ?? "default";
-  const keep = opts?.keep ?? false;
-  const manifest = setupSession(sessionPath, models, input);
-  const startedAt = new Date().toISOString();
-  const gridfilePath = join36(sessionPath, "gridfile.txt");
-  const prompt = readFileSync27(join36(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
-  const rawPrompt = readFileSync27(join36(sessionPath, "input.md"), "utf-8");
-  const usedBannerColors = new Set;
-  const gridLines = Object.entries(manifest.models).map(([anonId]) => {
-    const model = manifest.models[anonId].model;
-    if (mode === "interactive") {
-      return `claudish --model ${model} -i --dangerously-skip-permissions '${prompt}'`;
-    }
-    const bg = pickBannerColor(model, usedBannerColors);
-    const header = buildPaneHeader(model, rawPrompt, bg);
-    return `${header} claudish --model ${model} -y --quiet '${prompt}'`;
-  });
-  writeFileSync21(gridfilePath, `${gridLines.join(`
-`)}
-`, "utf-8");
-  const magmuxPath = findMagmuxBinary();
-  const spawnArgs = ["-g", gridfilePath];
-  if (!keep && mode === "default") {
-    spawnArgs.push("-w");
-  }
-  const proc = spawn5(magmuxPath, spawnArgs, {
-    stdio: "inherit",
-    env: { ...process.env }
-  });
-  const sockPath = `/tmp/magmux-${proc.pid}.sock`;
-  const subscription = subscribeToMagmux(sockPath);
-  const procExit = new Promise((resolve5) => {
-    proc.on("exit", () => resolve5());
-    proc.on("error", () => resolve5());
-  });
-  const [{ results }] = await Promise.all([subscription, procExit]);
-  const status = buildTeamStatus(manifest, startedAt, results?.panes ?? null);
-  const statusPath = join36(sessionPath, "status.json");
-  writeFileSync21(statusPath, JSON.stringify(status, null, 2), "utf-8");
-  return status;
-}
-var BANNER_BG_COLORS;
-var init_team_grid = __esm(() => {
-  init_profile_config();
-  init_model_parser();
-  init_routing_rules();
-  init_team_orchestrator();
-  BANNER_BG_COLORS = [
-    "48;2;40;90;180",
-    "48;2;140;60;160",
-    "48;2;30;130;100",
-    "48;2;160;80;40",
-    "48;2;60;120;60",
-    "48;2;160;50;70"
-  ];
-});
-
 // src/tui/viz/text.ts
 function columns(n, fn, arg = "width") {
   if (!Number.isFinite(n))
@@ -79003,7 +79638,7 @@ __export(exports_session_discovery, {
 import { execFile, execFileSync as execFileSync2 } from "child_process";
 import { closeSync as closeSync5, openSync as openSync5, readSync, readdirSync as readdirSync7, statSync as statSync6 } from "fs";
 import { homedir as homedir34 } from "os";
-import { basename, join as join37 } from "path";
+import { basename, join as join38 } from "path";
 function slugForPath(absPath) {
   return absPath.replace(/[/.]/g, "-");
 }
@@ -79052,7 +79687,7 @@ function projectDirs() {
   }
 }
 function sessionsIn(dirName) {
-  const dir = join37(PROJECTS_DIR, dirName);
+  const dir = join38(PROJECTS_DIR, dirName);
   let names;
   try {
     names = readdirSync7(dir).filter((n) => n.endsWith(".jsonl"));
@@ -79061,7 +79696,7 @@ function sessionsIn(dirName) {
   }
   const rows = [];
   for (const n of names) {
-    const file2 = join37(dir, n);
+    const file2 = join38(dir, n);
     try {
       const st = statSync6(file2);
       if (st.size === 0)
@@ -79420,7 +80055,7 @@ function findLatestSessionId(cwd = process.cwd(), sinceMs = 0) {
 }
 var ENTRYPOINT_BYTES = 8192, PROJECTS_DIR, ACTIVE_WINDOW_MS = 120000, HEAD_BYTES, TAIL_BYTES, HARNESS_ENVELOPES, DEEP_TAIL_BYTES, RECENT_AI_TURNS = 5, RECENT_USER_TURNS = 1;
 var init_session_discovery = __esm(() => {
-  PROJECTS_DIR = join37(homedir34(), ".claude", "projects");
+  PROJECTS_DIR = join38(homedir34(), ".claude", "projects");
   HEAD_BYTES = 64 * 1024;
   TAIL_BYTES = 128 * 1024;
   HARNESS_ENVELOPES = [
@@ -81112,22 +81747,26 @@ __export(exports_session_stats, {
   readSessionStats: () => readSessionStats,
   computeSavings: () => computeSavings
 });
-import { readFileSync as readFileSync28 } from "fs";
+import { readFileSync as readFileSync29 } from "fs";
 import { homedir as homedir35 } from "os";
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 function tokenFilePath(port) {
-  return process.env.CLAUDISH_TOKEN_FILE || join38(homedir35(), ".claudish", `tokens-${port}.json`);
+  return process.env.CLAUDISH_TOKEN_FILE || join39(homedir35(), ".claudish", `tokens-${port}.json`);
 }
-function readSessionStats(port) {
+function readSessionStats(port, opts) {
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync28(tokenFilePath(port), "utf-8"));
+    raw2 = JSON.parse(readFileSync29(tokenFilePath(port), "utf-8"));
   } catch {
     return null;
   }
   if (!raw2 || typeof raw2 !== "object")
     return null;
   const d = raw2;
+  const processStartMs = opts?.processStartMs ?? Date.now() - Math.round(process.uptime() * 1000);
+  const trackerStartedAt = num(d.started_at);
+  if (trackerStartedAt <= 0 || trackerStartedAt < processStartMs)
+    return null;
   const inputTokens = num(d.input_tokens);
   const outputTokens = num(d.output_tokens);
   if (inputTokens <= 0 && outputTokens <= 0)
@@ -81457,8 +82096,8 @@ var init_session_summary = __esm(() => {
 init_op_source();
 init_startup_trace();
 var import_dotenv3 = __toESM(require_main(), 1);
-import { existsSync as existsSync29, readFileSync as readFileSync29 } from "fs";
-import { join as join39, resolve as resolve5 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync30 } from "fs";
+import { join as join40, resolve as resolve5 } from "path";
 import_dotenv3.config({ quiet: true });
 function classifyStartupKind() {
   const argv = process.argv.slice(2);
@@ -81592,6 +82231,7 @@ var isConfigCommand = firstPositional === "config";
 var isServeCommand = firstPositional === "serve";
 var isProvidersCommand = firstPositional === "providers";
 var isBehaviorCommand = firstPositional === "behavior";
+var isTeamCommand = firstPositional === "team";
 var isLoginCommand = firstPositional === "login";
 var isLogoutCommand = firstPositional === "logout";
 var isQuotaCommand = firstPositional === "quota" || firstPositional === "usage";
@@ -81617,6 +82257,12 @@ if (isMcpMode) {
     console.error(`[claudish behavior] ${e instanceof Error ? e.message : String(e)}`);
     process.exit(1);
   }));
+} else if (isTeamCommand) {
+  const teamArgIndex = args.indexOf("team");
+  Promise.resolve().then(() => (init_team_cli(), exports_team_cli)).then((m) => m.teamCommand(args.slice(teamArgIndex + 1)).catch((e) => {
+    console.error(`[claudish team] ${e instanceof Error ? e.message : String(e)}`);
+    process.exit(1);
+  }));
 } else if (isProvidersCommand) {
   const json2 = args.includes("--json");
   Promise.resolve().then(() => (init_providers_command(), exports_providers_command)).then((m) => m.providersCommand({ json: json2 }).catch((e) => {
@@ -81701,14 +82347,14 @@ async function runCli() {
     if (cliConfig.team && cliConfig.team.length > 0) {
       let prompt = cliConfig.claudeArgs.join(" ");
       if (cliConfig.inputFile) {
-        prompt = readFileSync29(cliConfig.inputFile, "utf-8");
+        prompt = readFileSync30(cliConfig.inputFile, "utf-8");
       }
       if (!prompt.trim()) {
         console.error("Error: --team requires a prompt (positional args or -f <file>)");
         process.exit(1);
       }
       const mode = cliConfig.teamMode ?? "default";
-      const sessionPath = join39(process.cwd(), `.claudish-team-${Date.now()}`);
+      const sessionPath = join40(process.cwd(), `.claudish-team-${Date.now()}`);
       if (mode === "json") {
         const { setupSession: setupSession2, runModels: runModels2 } = await Promise.resolve().then(() => (init_team_orchestrator(), exports_team_orchestrator));
         setupSession2(sessionPath, cliConfig.team, prompt);
@@ -81718,9 +82364,9 @@ async function runCli() {
         });
         const result = { ...status2, responses: {} };
         for (const anonId of Object.keys(status2.models)) {
-          const responsePath = join39(sessionPath, `response-${anonId}.md`);
+          const responsePath = join40(sessionPath, `response-${anonId}.md`);
           try {
-            const raw2 = readFileSync29(responsePath, "utf-8").trim();
+            const raw2 = readFileSync30(responsePath, "utf-8").trim();
             try {
               result.responses[anonId] = JSON.parse(raw2);
             } catch {