claudish 6.4.2 → 6.4.5

package/dist/index.js

@@ -17971,14 +17971,14 @@ var init_model_catalog = __esm(() => {
       supportsVision: false,
       temperatureRange: { min: 0.01, max: 1 }
     },
-    { pattern: "gpt-5.4", contextWindow: 1050000 },
-    { pattern: "gpt-5", contextWindow: 400000 },
-    { pattern: "o1", contextWindow: 200000 },
-    { pattern: "o3", contextWindow: 200000 },
-    { pattern: "o4", contextWindow: 200000 },
-    { pattern: "gpt-4o", contextWindow: 128000 },
-    { pattern: "gpt-4-turbo", contextWindow: 128000 },
-    { pattern: "gpt-3.5", contextWindow: 16385 },
+    { pattern: "gpt-5.4", contextWindow: 1050000, maxToolCount: 128 },
+    { pattern: "gpt-5", contextWindow: 400000, maxToolCount: 128 },
+    { pattern: "o1", contextWindow: 200000, maxToolCount: 128 },
+    { pattern: "o3", contextWindow: 200000, maxToolCount: 128 },
+    { pattern: "o4", contextWindow: 200000, maxToolCount: 128 },
+    { pattern: "gpt-4o", contextWindow: 128000, maxToolCount: 128 },
+    { pattern: "gpt-4-turbo", contextWindow: 128000, maxToolCount: 128 },
+    { pattern: "gpt-3.5", contextWindow: 16385, maxToolCount: 128 },
     { pattern: "kimi-k2.5", contextWindow: 262144 },
     { pattern: "kimi-k2-5", contextWindow: 262144 },
     { pattern: "kimi-k2", contextWindow: 131000 },
@@ -23936,7 +23936,12 @@ class ComposedHandler {
     if (typeof adapter.reset === "function")
       adapter.reset();
     const messages = adapter.convertMessages(claudeRequest, filterIdentity);
-    const tools = adapter.convertTools(claudeRequest, this.options.summarizeTools);
+    let tools = adapter.convertTools(claudeRequest, this.options.summarizeTools);
+    const maxToolCount = lookupModel(this.targetModel)?.maxToolCount;
+    if (maxToolCount && tools.length > maxToolCount) {
+      log(`[ComposedHandler] Truncating tools from ${tools.length} to ${maxToolCount} (model limit for ${this.targetModel})`);
+      tools = tools.slice(0, maxToolCount);
+    }
     if (!this.getModelSupportsVision()) {
       const imageBlocks = [];
       for (let msgIdx = 0;msgIdx < messages.length; msgIdx++) {
@@ -24408,6 +24413,7 @@ var init_composed_handler = __esm(() => {
   init_vision_proxy();
   init_telemetry();
   init_stats();
+  init_model_catalog();
 });
 
 // src/providers/provider-registry.ts
@@ -28632,8 +28638,12 @@ Tokens: ${result.usage.input} input, ${result.usage.output} output`;
         }
         return { content: [{ type: "text", text: response }] };
       } catch (error2) {
+        const errMsg = error2 instanceof Error ? error2.message : String(error2);
         return {
-          content: [{ type: "text", text: `Error: ${error2 instanceof Error ? error2.message : String(error2)}` }],
+          content: [{ type: "text", text: `Error: ${errMsg}
+
+---
+**To report this error**, use the \`report_error\` tool with \`error_type: "provider_failure"\` and \`model: "${args.model}"\`.` }],
           isError: true
         };
       }
@@ -28781,6 +28791,10 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
 
 `;
       }
+      const failed = results.filter((r) => r.error);
+      if (failed.length > 0) {
+        output += '---\n**To report failed model(s)**, use the `report_error` tool with `error_type: "provider_failure"` and the model ID(s) above.\n';
+      }
       return { content: [{ type: "text", text: output }] };
     }
   });
@@ -28999,8 +29013,12 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
           content: [{ type: "text", text: JSON.stringify({ session_id: sessionId2, status: "starting" }) }]
         };
       } catch (error2) {
+        const errMsg = error2 instanceof Error ? error2.message : String(error2);
         return {
-          content: [{ type: "text", text: `Error: ${error2 instanceof Error ? error2.message : String(error2)}` }],
+          content: [{ type: "text", text: `Error creating session: ${errMsg}
+
+---
+**To report this error**, use the \`report_error\` tool with \`error_type: "provider_failure"\` and \`model: "${args.model}"\`.` }],
           isError: true
         };
       }
@@ -29113,10 +29131,13 @@ async function main() {
   });
   const sessionManager = new SessionManager({
     onStateChange: (sessionId2, event) => {
+      const notificationContent = event.type === "failed" ? `${event.content}
+
+To report this error, use the report_error tool with error_type: "provider_failure" and model: "${event.model}".` : event.content;
       server.notification({
         method: "notifications/claude/channel",
         params: {
-          content: event.content,
+          content: notificationContent,
           meta: {
             session_id: sessionId2,
             event: event.type,
@@ -30956,7 +30977,7 @@ async function fetchGLMCodingModels() {
     return [];
   }
 }
-var __filename4, __dirname4, VERSION = "6.4.2", CACHE_MAX_AGE_DAYS2 = 2, CLAUDISH_CACHE_DIR2, BUNDLED_MODELS_PATH, CACHED_MODELS_PATH, ALL_MODELS_JSON_PATH;
+var __filename4, __dirname4, VERSION = "6.4.5", CACHE_MAX_AGE_DAYS2 = 2, CLAUDISH_CACHE_DIR2, BUNDLED_MODELS_PATH, CACHED_MODELS_PATH, ALL_MODELS_JSON_PATH;
 var init_cli = __esm(() => {
   init_config();
   init_model_loader();
@@ -94180,13 +94201,234 @@ var init_tui = __esm(async () => {
   }
 });
 
+// src/team-grid.ts
+var exports_team_grid = {};
+__export(exports_team_grid, {
+  runWithGrid: () => runWithGrid
+});
+import { spawn as spawn3 } from "child_process";
+import {
+  appendFileSync,
+  existsSync as existsSync24,
+  mkdirSync as mkdirSync13,
+  readFileSync as readFileSync19,
+  writeFileSync as writeFileSync14
+} from "fs";
+import { dirname as dirname6, join as join25 } from "path";
+import { fileURLToPath as fileURLToPath6 } from "url";
+import { execSync as execSync3 } from "child_process";
+function formatElapsed(ms) {
+  const s = Math.floor(ms / 1000);
+  if (s < 60)
+    return `${s}s`;
+  const m2 = Math.floor(s / 60);
+  const rem = s % 60;
+  return `${m2}m ${rem}s`;
+}
+function findMtmBinary() {
+  const thisFile = fileURLToPath6(import.meta.url);
+  const thisDir = dirname6(thisFile);
+  const platform3 = process.platform;
+  const arch = process.arch;
+  const pkgRoot = join25(thisDir, "..");
+  const builtDev = join25(pkgRoot, "native", "mtm", "mtm");
+  if (existsSync24(builtDev))
+    return builtDev;
+  const bundledPlatform = join25(pkgRoot, "native", "mtm", `mtm-${platform3}-${arch}`);
+  if (existsSync24(bundledPlatform))
+    return bundledPlatform;
+  try {
+    const result = execSync3("which mtm", { encoding: "utf-8" }).trim();
+    if (result && isMtmForkWithGrid(result))
+      return result;
+  } catch {}
+  throw new Error("mtm binary not found. Build it with: cd packages/cli/native/mtm && make");
+}
+function isMtmForkWithGrid(binPath) {
+  try {
+    const output = execSync3(`"${binPath}" --help 2>&1 || true`, {
+      encoding: "utf-8",
+      timeout: 2000
+    });
+    return output.includes("-g ");
+  } catch {
+    return false;
+  }
+}
+function renderGridStatusBar(counts) {
+  const elapsed = formatElapsed(counts.elapsedMs);
+  const { done, running, failed, total, allDone } = counts;
+  if (allDone) {
+    if (failed > 0) {
+      return [
+        "C: claudish team",
+        `G: ${done} done`,
+        `R: ${failed} failed`,
+        `D: ${elapsed}`,
+        "R: \u2717 issues"
+      ].join("\t");
+    }
+    return [
+      "C: claudish team",
+      `G: ${total} done`,
+      `D: ${elapsed}`,
+      "G: \u2713 complete"
+    ].join("\t");
+  }
+  return [
+    "C: claudish team",
+    `G: ${done} done`,
+    `C: ${running} running`,
+    `R: ${failed} failed`,
+    `D: ${elapsed}`
+  ].join("\t");
+}
+function pollStatus(state) {
+  const { statusCache, statusPath, sessionPath, anonIds, startTime, timeoutMs, statusbarPath } = state;
+  const elapsedMs = Date.now() - startTime;
+  let changed = false;
+  let done = 0;
+  let running = 0;
+  let failed = 0;
+  for (const anonId of anonIds) {
+    const current = statusCache.models[anonId];
+    if (current.state === "COMPLETED" || current.state === "FAILED" || current.state === "TIMEOUT") {
+      if (current.state === "COMPLETED")
+        done++;
+      else
+        failed++;
+      continue;
+    }
+    const exitCodePath = join25(sessionPath, "work", anonId, ".exit-code");
+    const responsePath = join25(sessionPath, `response-${anonId}.md`);
+    if (existsSync24(exitCodePath)) {
+      const codeStr = readFileSync19(exitCodePath, "utf-8").trim();
+      const code = parseInt(codeStr, 10);
+      const isSuccess = code === 0;
+      let outputSize = 0;
+      try {
+        outputSize = existsSync24(responsePath) ? readFileSync19(responsePath, "utf-8").length : 0;
+      } catch {}
+      const newState = {
+        ...current,
+        state: isSuccess ? "COMPLETED" : "FAILED",
+        exitCode: code,
+        startedAt: current.startedAt ?? new Date().toISOString(),
+        completedAt: new Date().toISOString(),
+        outputSize
+      };
+      statusCache.models[anonId] = newState;
+      changed = true;
+      if (isSuccess)
+        done++;
+      else
+        failed++;
+    } else {
+      if (elapsedMs > timeoutMs) {
+        const newState = {
+          ...current,
+          state: "TIMEOUT",
+          startedAt: current.startedAt ?? new Date().toISOString(),
+          completedAt: new Date().toISOString()
+        };
+        statusCache.models[anonId] = newState;
+        changed = true;
+        failed++;
+      } else {
+        if (current.state === "PENDING" && existsSync24(responsePath)) {
+          statusCache.models[anonId] = {
+            ...current,
+            state: "RUNNING",
+            startedAt: current.startedAt ?? new Date().toISOString()
+          };
+          changed = true;
+        }
+        running++;
+      }
+    }
+  }
+  if (changed) {
+    writeFileSync14(statusPath, JSON.stringify(statusCache, null, 2), "utf-8");
+  }
+  const total = anonIds.length;
+  const allDone = done + failed >= total;
+  const counts = {
+    done,
+    running,
+    failed,
+    total,
+    elapsedMs,
+    allDone
+  };
+  appendFileSync(statusbarPath, renderGridStatusBar(counts) + `
+`);
+  return allDone;
+}
+async function runWithGrid(sessionPath, models, input, opts) {
+  const timeoutMs = (opts?.timeout ?? 300) * 1000;
+  const manifest = setupSession(sessionPath, models, input);
+  mkdirSync13(join25(sessionPath, "errors"), { recursive: true });
+  const gridfilePath = join25(sessionPath, "gridfile.txt");
+  const gridLines = Object.entries(manifest.models).map(([anonId]) => {
+    const inputMd = join25(sessionPath, "input.md");
+    const errorLog = join25(sessionPath, "errors", `${anonId}.log`);
+    const responseMd = join25(sessionPath, `response-${anonId}.md`);
+    const exitCodeFile = join25(sessionPath, "work", anonId, ".exit-code");
+    return `claudish --model ${manifest.models[anonId].model} -y --stdin --quiet` + ` < ${inputMd} 2>${errorLog}` + ` | tee ${responseMd}` + `; echo $? > ${exitCodeFile}`;
+  });
+  writeFileSync14(gridfilePath, gridLines.join(`
+`) + `
+`, "utf-8");
+  const mtmBin = findMtmBinary();
+  const statusbarPath = join25(sessionPath, "statusbar.txt");
+  const statusPath = join25(sessionPath, "status.json");
+  const statusCache = JSON.parse(readFileSync19(statusPath, "utf-8"));
+  const anonIds = Object.keys(manifest.models);
+  const startTime = Date.now();
+  appendFileSync(statusbarPath, renderGridStatusBar({
+    done: 0,
+    running: 0,
+    failed: 0,
+    total: anonIds.length,
+    elapsedMs: 0,
+    allDone: false
+  }) + `
+`);
+  const pollState = {
+    statusCache,
+    statusPath,
+    sessionPath,
+    anonIds,
+    startTime,
+    timeoutMs,
+    statusbarPath
+  };
+  const pollInterval = setInterval(() => {
+    pollStatus(pollState);
+  }, 500);
+  const proc = spawn3(mtmBin, ["-g", gridfilePath, "-S", statusbarPath, "-t", "xterm-256color"], {
+    stdio: "inherit",
+    env: { ...process.env }
+  });
+  await new Promise((resolve4) => {
+    proc.on("exit", () => resolve4());
+    proc.on("error", () => resolve4());
+  });
+  clearInterval(pollInterval);
+  pollStatus(pollState);
+  return JSON.parse(readFileSync19(statusPath, "utf-8"));
+}
+var init_team_grid = __esm(() => {
+  init_team_orchestrator();
+});
+
 // src/team-cli.ts
 var exports_team_cli = {};
 __export(exports_team_cli, {
   teamCommand: () => teamCommand
 });
-import { readFileSync as readFileSync19 } from "fs";
-import { join as join25 } from "path";
+import { readFileSync as readFileSync20 } from "fs";
+import { join as join26 } from "path";
 function getFlag(args, flag) {
   const idx = args.indexOf(flag);
   if (idx === -1 || idx + 1 >= args.length)
@@ -94224,6 +94466,7 @@ Options (run / run-and-judge):
   --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 an mtm grid with live output + status bar
 
 Options (judge / run-and-judge):
   --judges <a,b,...>  Comma-separated judge model IDs (default: same as runners)
@@ -94233,6 +94476,7 @@ Options (status):
 
 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
@@ -94265,20 +94509,26 @@ async function teamCommand(args) {
         console.error("Error: --models is required for 'run'");
         process.exit(1);
       }
-      setupSession(sessionPath, models, input);
-      const runStatus = await runModels(sessionPath, {
-        timeout,
-        onStatusChange: (id, s) => {
-          process.stderr.write(`[team] ${id}: ${s.state}
+      if (hasFlag(args, "--grid")) {
+        const { runWithGrid: runWithGrid2 } = await Promise.resolve().then(() => (init_team_grid(), exports_team_grid));
+        const gridStatus = await runWithGrid2(sessionPath, models, input ?? "", { timeout });
+        printStatus(gridStatus);
+      } else {
+        setupSession(sessionPath, models, input);
+        const runStatus = await runModels(sessionPath, {
+          timeout,
+          onStatusChange: (id, s) => {
+            process.stderr.write(`[team] ${id}: ${s.state}
 `);
-        }
-      });
-      printStatus(runStatus);
+          }
+        });
+        printStatus(runStatus);
+      }
       break;
     }
     case "judge": {
       const verdict = await judgeResponses(sessionPath, { judges });
-      console.log(readFileSync19(join25(sessionPath, "verdict.md"), "utf-8"));
+      console.log(readFileSync20(join26(sessionPath, "verdict.md"), "utf-8"));
       break;
     }
     case "run-and-judge": {
@@ -94296,7 +94546,7 @@ async function teamCommand(args) {
       });
       printStatus(status);
       await judgeResponses(sessionPath, { judges });
-      console.log(readFileSync19(join25(sessionPath, "verdict.md"), "utf-8"));
+      console.log(readFileSync20(join26(sessionPath, "verdict.md"), "utf-8"));
       break;
     }
     case "status": {
@@ -94321,10 +94571,10 @@ __export(exports_claude_runner, {
   runClaudeWithProxy: () => runClaudeWithProxy,
   checkClaudeInstalled: () => checkClaudeInstalled
 });
-import { spawn as spawn3 } from "child_process";
-import { writeFileSync as writeFileSync14, unlinkSync as unlinkSync7, mkdirSync as mkdirSync13, existsSync as existsSync24, readFileSync as readFileSync20 } from "fs";
+import { spawn as spawn4 } from "child_process";
+import { writeFileSync as writeFileSync15, unlinkSync as unlinkSync7, mkdirSync as mkdirSync14, existsSync as existsSync26, readFileSync as readFileSync21 } from "fs";
 import { tmpdir as tmpdir2, homedir as homedir23 } from "os";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 function hasNativeAnthropicMapping(config3) {
   const models = [
     config3.model,
@@ -94340,9 +94590,9 @@ function isWindows2() {
 }
 function createStatusLineScript(tokenFilePath) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join26(homeDir, ".claudish");
+  const claudishDir = join27(homeDir, ".claudish");
   const timestamp = Date.now();
-  const scriptPath = join26(claudishDir, `status-${timestamp}.js`);
+  const scriptPath = join27(claudishDir, `status-${timestamp}.js`);
   const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
   const script = `
 const fs = require('fs');
@@ -94422,18 +94672,18 @@ process.stdin.on('end', () => {
   }
 });
 `;
-  writeFileSync14(scriptPath, script, "utf-8");
+  writeFileSync15(scriptPath, script, "utf-8");
   return scriptPath;
 }
 function createTempSettingsFile(modelDisplay, port) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join26(homeDir, ".claudish");
+  const claudishDir = join27(homeDir, ".claudish");
   try {
-    mkdirSync13(claudishDir, { recursive: true });
+    mkdirSync14(claudishDir, { recursive: true });
   } catch {}
   const timestamp = Date.now();
-  const tempPath = join26(claudishDir, `settings-${timestamp}.json`);
-  const tokenFilePath = join26(claudishDir, `tokens-${port}.json`);
+  const tempPath = join27(claudishDir, `settings-${timestamp}.json`);
+  const tokenFilePath = join27(claudishDir, `tokens-${port}.json`);
   let statusCommand;
   if (isWindows2()) {
     const scriptPath = createStatusLineScript(tokenFilePath);
@@ -94455,7 +94705,7 @@ function createTempSettingsFile(modelDisplay, port) {
     padding: 0
   };
   const settings = { statusLine };
-  writeFileSync14(tempPath, JSON.stringify(settings, null, 2), "utf-8");
+  writeFileSync15(tempPath, JSON.stringify(settings, null, 2), "utf-8");
   return { path: tempPath, statusLine };
 }
 function mergeUserSettingsIfPresent(config3, tempSettingsPath, statusLine) {
@@ -94469,11 +94719,11 @@ function mergeUserSettingsIfPresent(config3, tempSettingsPath, statusLine) {
     if (userSettingsValue.trimStart().startsWith("{")) {
       userSettings = JSON.parse(userSettingsValue);
     } else {
-      const rawUserSettings = readFileSync20(userSettingsValue, "utf-8");
+      const rawUserSettings = readFileSync21(userSettingsValue, "utf-8");
       userSettings = JSON.parse(rawUserSettings);
     }
     userSettings.statusLine = statusLine;
-    writeFileSync14(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
+    writeFileSync15(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
   } catch {
     if (!config3.quiet) {
       console.warn(`[claudish] Warning: could not merge user settings: ${userSettingsValue}`);
@@ -94562,7 +94812,7 @@ async function runClaudeWithProxy(config3, proxyUrl, onCleanup, ptyDiagRunner) {
     console.error(`
 Or set CLAUDE_PATH to your custom installation:`);
     const home = homedir23();
-    const localPath = isWindows2() ? join26(home, ".claude", "local", "claude.exe") : join26(home, ".claude", "local", "claude");
+    const localPath = isWindows2() ? join27(home, ".claude", "local", "claude.exe") : join27(home, ".claude", "local", "claude");
     console.error(`  export CLAUDE_PATH=${localPath}`);
     process.exit(1);
   }
@@ -94575,7 +94825,7 @@ Or set CLAUDE_PATH to your custom installation:`);
       unlinkSync7(tempSettingsPath);
     } catch {}
   } else {
-    const proc = spawn3(spawnCommand, claudeArgs, {
+    const proc = spawn4(spawnCommand, claudeArgs, {
       env: env2,
       stdio: "inherit",
       shell: needsShell
@@ -94616,23 +94866,23 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet, onCleanup) {
 async function findClaudeBinary() {
   const isWindows3 = process.platform === "win32";
   if (process.env.CLAUDE_PATH) {
-    if (existsSync24(process.env.CLAUDE_PATH)) {
+    if (existsSync26(process.env.CLAUDE_PATH)) {
       return process.env.CLAUDE_PATH;
     }
   }
   const home = homedir23();
-  const localPath = isWindows3 ? join26(home, ".claude", "local", "claude.exe") : join26(home, ".claude", "local", "claude");
-  if (existsSync24(localPath)) {
+  const localPath = isWindows3 ? join27(home, ".claude", "local", "claude.exe") : join27(home, ".claude", "local", "claude");
+  if (existsSync26(localPath)) {
     return localPath;
   }
   if (isWindows3) {
     const windowsPaths = [
-      join26(home, "AppData", "Roaming", "npm", "claude.cmd"),
-      join26(home, ".npm-global", "claude.cmd"),
-      join26(home, "node_modules", ".bin", "claude.cmd")
+      join27(home, "AppData", "Roaming", "npm", "claude.cmd"),
+      join27(home, ".npm-global", "claude.cmd"),
+      join27(home, "node_modules", ".bin", "claude.cmd")
     ];
     for (const path2 of windowsPaths) {
-      if (existsSync24(path2)) {
+      if (existsSync26(path2)) {
         return path2;
       }
     }
@@ -94640,21 +94890,21 @@ async function findClaudeBinary() {
     const commonPaths = [
       "/usr/local/bin/claude",
       "/opt/homebrew/bin/claude",
-      join26(home, ".npm-global/bin/claude"),
-      join26(home, ".local/bin/claude"),
-      join26(home, "node_modules/.bin/claude"),
+      join27(home, ".npm-global/bin/claude"),
+      join27(home, ".local/bin/claude"),
+      join27(home, "node_modules/.bin/claude"),
       "/data/data/com.termux/files/usr/bin/claude",
-      join26(home, "../usr/bin/claude")
+      join27(home, "../usr/bin/claude")
     ];
     for (const path2 of commonPaths) {
-      if (existsSync24(path2)) {
+      if (existsSync26(path2)) {
         return path2;
       }
     }
   }
   try {
     const shellCommand = isWindows3 ? "where claude" : "command -v claude";
-    const proc = spawn3(shellCommand, [], {
+    const proc = spawn4(shellCommand, [], {
       stdio: "pipe",
       shell: true
     });
@@ -94699,19 +94949,19 @@ __export(exports_diag_output, {
   MtmDiagOutput: () => MtmDiagOutput,
   LogFileDiagOutput: () => LogFileDiagOutput
 });
-import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync14, writeFileSync as writeFileSync15, unlinkSync as unlinkSync8 } from "fs";
+import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync15, writeFileSync as writeFileSync16, unlinkSync as unlinkSync8 } from "fs";
 import { execFileSync } from "child_process";
 import { homedir as homedir24 } from "os";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 function getClaudishDir() {
-  const dir = join27(homedir24(), ".claudish");
+  const dir = join28(homedir24(), ".claudish");
   try {
-    mkdirSync14(dir, { recursive: true });
+    mkdirSync15(dir, { recursive: true });
   } catch {}
   return dir;
 }
 function getDiagLogPath() {
-  return join27(getClaudishDir(), `diag-${process.pid}.log`);
+  return join28(getClaudishDir(), `diag-${process.pid}.log`);
 }
 
 class LogFileDiagOutput {
@@ -94720,7 +94970,7 @@ class LogFileDiagOutput {
   constructor() {
     this.logPath = getDiagLogPath();
     try {
-      writeFileSync15(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
+      writeFileSync16(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
 `);
     } catch {}
     this.stream = createWriteStream3(this.logPath, { flags: "a" });
@@ -94849,12 +95099,12 @@ __export(exports_pty_diag_runner, {
   PtyDiagRunner: () => MtmDiagRunner,
   MtmDiagRunner: () => MtmDiagRunner
 });
-import { spawn as spawn4 } from "child_process";
-import { appendFileSync, createWriteStream as createWriteStream4, existsSync as existsSync26, mkdirSync as mkdirSync15, unlinkSync as unlinkSync9 } from "fs";
+import { spawn as spawn5 } from "child_process";
+import { appendFileSync as appendFileSync2, createWriteStream as createWriteStream4, existsSync as existsSync27, mkdirSync as mkdirSync16, unlinkSync as unlinkSync9 } from "fs";
 import { homedir as homedir25 } from "os";
-import { dirname as dirname6, join as join28 } from "path";
-import { execSync as execSync3 } from "child_process";
-import { fileURLToPath as fileURLToPath6 } from "url";
+import { dirname as dirname7, join as join29 } from "path";
+import { execSync as execSync4 } from "child_process";
+import { fileURLToPath as fileURLToPath7 } from "url";
 
 class MtmDiagRunner {
   mtmProc = null;
@@ -94862,12 +95112,12 @@ class MtmDiagRunner {
   statusPath;
   logStream = null;
   constructor() {
-    const dir = join28(homedir25(), ".claudish");
+    const dir = join29(homedir25(), ".claudish");
     try {
-      mkdirSync15(dir, { recursive: true });
+      mkdirSync16(dir, { recursive: true });
     } catch {}
-    this.logPath = join28(dir, `diag-${process.pid}.log`);
-    this.statusPath = join28(dir, `status-${process.pid}.txt`);
+    this.logPath = join29(dir, `diag-${process.pid}.log`);
+    this.statusPath = join29(dir, `status-${process.pid}.txt`);
     this.logStream = createWriteStream4(this.logPath, { flags: "w" });
     this.logStream.on("error", () => {});
   }
@@ -94876,7 +95126,7 @@ class MtmDiagRunner {
     const quotedArgs = claudeArgs.map((a) => shellQuote(a)).join(" ");
     const claudeCmd = `${shellQuote(claudeCommand)} ${quotedArgs}`;
     const mergedEnv = { ...process.env, ...env2 };
-    this.mtmProc = spawn4(mtmBin, ["-t", "xterm-256color", "-e", claudeCmd, "-S", this.statusPath, "-L", this.logPath], {
+    this.mtmProc = spawn5(mtmBin, ["-t", "xterm-256color", "-e", claudeCmd, "-S", this.statusPath, "-L", this.logPath], {
       stdio: "inherit",
       env: mergedEnv
     });
@@ -94957,7 +95207,7 @@ class MtmDiagRunner {
       avgRoundtripMs: this.avgRoundtripMs
     });
     try {
-      appendFileSync(this.statusPath, bar + `
+      appendFileSync2(this.statusPath, bar + `
 `);
     } catch {}
   }
@@ -94985,19 +95235,19 @@ class MtmDiagRunner {
     }
   }
   findMtmBinary() {
-    const thisFile = fileURLToPath6(import.meta.url);
-    const thisDir = dirname6(thisFile);
+    const thisFile = fileURLToPath7(import.meta.url);
+    const thisDir = dirname7(thisFile);
     const platform3 = process.platform;
     const arch = process.arch;
-    const pkgRoot = join28(thisDir, "..");
-    const bundledPlatform = join28(pkgRoot, "native", "mtm", `mtm-${platform3}-${arch}`);
-    if (existsSync26(bundledPlatform))
+    const pkgRoot = join29(thisDir, "..");
+    const bundledPlatform = join29(pkgRoot, "native", "mtm", `mtm-${platform3}-${arch}`);
+    if (existsSync27(bundledPlatform))
       return bundledPlatform;
-    const builtDev = join28(pkgRoot, "native", "mtm", "mtm");
-    if (existsSync26(builtDev))
+    const builtDev = join29(pkgRoot, "native", "mtm", "mtm");
+    if (existsSync27(builtDev))
       return builtDev;
     try {
-      const result = execSync3("which mtm", { encoding: "utf-8" }).trim();
+      const result = execSync4("which mtm", { encoding: "utf-8" }).trim();
       if (result && this.isMtmFork(result))
         return result;
     } catch {}
@@ -95005,7 +95255,7 @@ class MtmDiagRunner {
   }
   isMtmFork(binPath) {
     try {
-      const output = execSync3(`"${binPath}" --help 2>&1 || true`, {
+      const output = execSync4(`"${binPath}" --help 2>&1 || true`, {
         encoding: "utf-8",
         timeout: 2000
       });
@@ -95090,16 +95340,16 @@ var init_pty_diag_runner = __esm(() => {
 
 // src/index.ts
 var import_dotenv3 = __toESM(require_main(), 1);
-import { existsSync as existsSync27, readFileSync as readFileSync21 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync22 } from "fs";
 import { homedir as homedir26 } from "os";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 import_dotenv3.config({ quiet: true });
 function loadStoredApiKeys() {
   try {
-    const configPath = join29(homedir26(), ".claudish", "config.json");
-    if (!existsSync27(configPath))
+    const configPath = join30(homedir26(), ".claudish", "config.json");
+    if (!existsSync28(configPath))
       return;
-    const raw2 = readFileSync21(configPath, "utf-8");
+    const raw2 = readFileSync22(configPath, "utf-8");
     const cfg = JSON.parse(raw2);
     if (cfg.apiKeys) {
       for (const [envVar, value] of Object.entries(cfg.apiKeys)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "6.4.2",
+  "version": "6.4.5",
   "description": "Run Claude Code with any model - OpenRouter, Ollama, LM Studio & local models",
   "type": "module",
   "main": "./dist/index.js",