claudish 6.6.3 → 6.8.0

package/dist/index.js

@@ -23252,6 +23252,24 @@ var init_provider_definitions = __esm(() => {
       isLocal: true,
       description: "Local MLX (mlx@)"
     },
+    {
+      name: "deepseek",
+      displayName: "DeepSeek",
+      transport: "openai",
+      tokenStrategy: "delta-aware",
+      baseUrl: "https://api.deepseek.com",
+      baseUrlEnvVars: ["DEEPSEEK_BASE_URL"],
+      apiPath: "/v1/chat/completions",
+      apiKeyEnvVar: "DEEPSEEK_API_KEY",
+      apiKeyDescription: "DeepSeek API Key",
+      apiKeyUrl: "https://platform.deepseek.com/api_keys",
+      shortcuts: ["ds"],
+      shortestPrefix: "ds",
+      legacyPrefixes: [{ prefix: "ds/", stripPrefix: true }],
+      nativeModelPatterns: [{ pattern: /^deepseek\//i }, { pattern: /^deepseek-/i }],
+      isDirectApi: true,
+      description: "DeepSeek API (ds@)"
+    },
     {
       name: "qwen",
       displayName: "Qwen",
@@ -24806,75 +24824,156 @@ var init_static_fallback = __esm(() => {
     minimax: "minimax",
     openrouter: "openrouter",
     ollamacloud: "meta-llama",
-    qwen: "qwen"
+    qwen: "qwen",
+    deepseek: "deepseek",
+    grok: "x-ai"
   };
 });
 
 // src/providers/catalog-resolvers/openrouter.ts
-import { readFileSync as readFileSync6, existsSync as existsSync8 } from "fs";
+import { readFileSync as readFileSync6, existsSync as existsSync8, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8 } from "fs";
 import { join as join10 } from "path";
 import { homedir as homedir9 } from "os";
 
 class OpenRouterCatalogResolver {
   provider = "openrouter";
   resolveSync(userInput) {
+    const entries = this._getEntries();
     if (userInput.includes("/")) {
-      const models2 = this._getModels();
-      if (models2) {
-        const exactMatch = models2.find((m) => m.id === userInput);
-        return exactMatch ? exactMatch.id : userInput;
+      if (entries) {
+        for (const entry of entries) {
+          for (const src of Object.values(entry.sources)) {
+            if (src.externalId === userInput)
+              return userInput;
+          }
+        }
       }
       return userInput;
     }
-    const models = this._getModels();
-    if (models) {
+    if (entries) {
+      const byModelId = entries.find((e) => e.modelId === userInput);
+      if (byModelId) {
+        const orId = this._getOpenRouterExternalId(byModelId);
+        if (orId)
+          return orId;
+      }
+      const byAlias = entries.find((e) => e.aliases.includes(userInput));
+      if (byAlias) {
+        const orId = this._getOpenRouterExternalId(byAlias);
+        if (orId)
+          return orId;
+      }
+      for (const entry of entries) {
+        for (const src of Object.values(entry.sources)) {
+          if (src.externalId === userInput) {
+            const orId = this._getOpenRouterExternalId(entry);
+            if (orId)
+              return orId;
+          }
+        }
+      }
       const suffix = `/${userInput}`;
-      const match2 = models.find((m) => m.id.endsWith(suffix));
-      if (match2)
-        return match2.id;
+      for (const entry of entries) {
+        const orId = this._getOpenRouterExternalId(entry);
+        if (orId && orId.endsWith(suffix))
+          return orId;
+      }
       const lowerSuffix = `/${userInput.toLowerCase()}`;
-      const ciMatch = models.find((m) => m.id.toLowerCase().endsWith(lowerSuffix));
-      if (ciMatch)
-        return ciMatch.id;
+      for (const entry of entries) {
+        const orId = this._getOpenRouterExternalId(entry);
+        if (orId && orId.toLowerCase().endsWith(lowerSuffix))
+          return orId;
+      }
     }
     return staticOpenRouterFallback(userInput);
   }
   async warmCache() {
-    try {
-      const existing = getCachedOpenRouterModels();
-      if (existing && existing.length > 0) {
-        _memCache = existing;
-        return;
-      }
-      const models = await ensureOpenRouterModelsLoaded();
-      if (models.length > 0) {
-        _memCache = models;
-      }
-    } catch {}
+    if (!_warmPromise) {
+      _warmPromise = this._fetchAndCache();
+    }
+    await _warmPromise;
   }
   isCacheWarm() {
     return _memCache !== null && _memCache.length > 0;
   }
-  _getModels() {
+  async ensureReady(timeoutMs) {
+    if (this.isCacheWarm())
+      return;
+    if (!_warmPromise) {
+      _warmPromise = this._fetchAndCache();
+    }
+    await Promise.race([
+      _warmPromise,
+      new Promise((resolve2) => setTimeout(resolve2, timeoutMs))
+    ]);
+  }
+  _getOpenRouterExternalId(entry) {
+    const orSource = entry.sources["openrouter-api"];
+    if (orSource?.externalId)
+      return orSource.externalId;
+    for (const src of Object.values(entry.sources)) {
+      if (src.externalId.includes("/"))
+        return src.externalId;
+    }
+    return null;
+  }
+  _getEntries() {
     if (_memCache)
       return _memCache;
-    const diskPath = join10(homedir9(), ".claudish", "all-models.json");
-    if (existsSync8(diskPath)) {
+    if (existsSync8(DISK_CACHE_PATH)) {
       try {
-        const data = JSON.parse(readFileSync6(diskPath, "utf-8"));
+        const data = JSON.parse(readFileSync6(DISK_CACHE_PATH, "utf-8"));
+        if (data.version === 2 && Array.isArray(data.entries) && data.entries.length > 0) {
+          _memCache = data.entries;
+          return _memCache;
+        }
         if (Array.isArray(data.models) && data.models.length > 0) {
-          _memCache = data.models;
+          _memCache = data.models.map((m) => ({
+            modelId: m.id.includes("/") ? m.id.split("/").slice(1).join("/") : m.id,
+            aliases: [],
+            sources: { "openrouter-api": { externalId: m.id } }
+          }));
           return _memCache;
         }
       } catch {}
     }
     return null;
   }
+  async _fetchAndCache() {
+    try {
+      const response = await fetch(FIREBASE_CATALOG_URL, {
+        signal: AbortSignal.timeout(8000)
+      });
+      if (!response.ok) {
+        throw new Error(`Firebase catalog returned ${response.status}`);
+      }
+      const data = await response.json();
+      if (!Array.isArray(data.models) || data.models.length === 0)
+        return;
+      _memCache = data.models;
+      const backwardCompatModels = [];
+      for (const entry of data.models) {
+        const orSource = entry.sources["openrouter-api"];
+        if (orSource?.externalId) {
+          backwardCompatModels.push({ id: orSource.externalId });
+        }
+      }
+      const cacheDir = join10(homedir9(), ".claudish");
+      mkdirSync8(cacheDir, { recursive: true });
+      const diskData = {
+        version: 2,
+        lastUpdated: new Date().toISOString(),
+        entries: data.models,
+        models: backwardCompatModels
+      };
+      writeFileSync8(DISK_CACHE_PATH, JSON.stringify(diskData), "utf-8");
+    } catch {}
+  }
 }
-var _memCache = null;
+var FIREBASE_CATALOG_URL = "https://us-central1-claudish-6da10.cloudfunctions.net/queryModels?status=active&catalog=slim&limit=1000", DISK_CACHE_PATH, _memCache = null, _warmPromise = null;
 var init_openrouter2 = __esm(() => {
-  init_model_loader();
   init_static_fallback();
+  DISK_CACHE_PATH = join10(homedir9(), ".claudish", "all-models.json");
 });
 
 // src/providers/catalog-resolvers/litellm.ts
@@ -24927,6 +25026,10 @@ class LiteLLMCatalogResolver {
   isCacheWarm() {
     return _memCache2 !== null && _memCache2.length > 0;
   }
+  async ensureReady(_timeoutMs) {
+    if (!this.isCacheWarm())
+      await this.warmCache();
+  }
   _getModelIds() {
     if (_memCache2)
       return _memCache2;
@@ -24977,6 +25080,12 @@ function logResolution(userInput, result, quiet = false) {
 `);
   }
 }
+async function ensureCatalogReady(provider, timeoutMs = 5000) {
+  const resolver = getResolver(provider);
+  if (!resolver || resolver.isCacheWarm())
+    return;
+  await resolver.ensureReady(timeoutMs);
+}
 async function warmAllCatalogs(providers) {
   const targets = providers ? [...RESOLVER_REGISTRY.entries()].filter(([k]) => providers.includes(k)) : [...RESOLVER_REGISTRY.entries()];
   await Promise.allSettled(targets.map(([, r]) => r.warmCache()));
@@ -25125,8 +25234,8 @@ async function warmZenModelCache() {
   if (models.length === 0)
     return;
   const cacheDir = join12(homedir11(), ".claudish");
-  const { mkdirSync: mkdirSync8, writeFileSync: writeSync } = await import("fs");
-  mkdirSync8(cacheDir, { recursive: true });
+  const { mkdirSync: mkdirSync9, writeFileSync: writeSync } = await import("fs");
+  mkdirSync9(cacheDir, { recursive: true });
   writeSync(join12(cacheDir, "zen-models.json"), JSON.stringify({ models, fetchedAt: new Date().toISOString() }));
 }
 function readZenGoModelCacheSync() {
@@ -25162,8 +25271,8 @@ async function warmZenGoModelCache() {
   if (models.length === 0)
     return;
   const cacheDir = join12(homedir11(), ".claudish");
-  const { mkdirSync: mkdirSync8, writeFileSync: writeSync } = await import("fs");
-  mkdirSync8(cacheDir, { recursive: true });
+  const { mkdirSync: mkdirSync9, writeFileSync: writeSync } = await import("fs");
+  mkdirSync9(cacheDir, { recursive: true });
   writeSync(join12(cacheDir, "zen-go-models.json"), JSON.stringify({ models, fetchedAt: new Date().toISOString() }));
 }
 function hasProviderCredentials(provider) {
@@ -25237,6 +25346,7 @@ var init_auto_route = __esm(() => {
     "minimax-coding": { apiKeyEnvVar: "MINIMAX_CODING_API_KEY" },
     glm: { apiKeyEnvVar: "ZHIPU_API_KEY" },
     "glm-coding": { apiKeyEnvVar: "GLM_CODING_API_KEY" },
+    deepseek: { apiKeyEnvVar: "DEEPSEEK_API_KEY" },
     ollamacloud: { apiKeyEnvVar: "OLLAMA_API_KEY" }
   };
   PROVIDER_TO_PREFIX = (() => {
@@ -25639,7 +25749,7 @@ var init_provider_resolver = __esm(() => {
 });
 
 // src/services/pricing-cache.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync8, existsSync as existsSync12, mkdirSync as mkdirSync8, statSync as statSync2 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync9, existsSync as existsSync12, mkdirSync as mkdirSync9, statSync as statSync2 } from "fs";
 import { homedir as homedir13 } from "os";
 import { join as join14 } from "path";
 function getDynamicPricingSync(provider, modelName) {
@@ -25723,12 +25833,12 @@ function loadDiskCache() {
 }
 function saveDiskCache() {
   try {
-    mkdirSync8(CACHE_DIR, { recursive: true });
+    mkdirSync9(CACHE_DIR, { recursive: true });
     const data = {};
     for (const [key, pricing] of pricingMap) {
       data[key] = pricing;
     }
-    writeFileSync8(CACHE_FILE, JSON.stringify(data), "utf-8");
+    writeFileSync9(CACHE_FILE, JSON.stringify(data), "utf-8");
   } catch (error2) {
     log(`[PricingCache] Error saving disk cache: ${error2}`);
   }
@@ -26305,8 +26415,8 @@ Details: ${e.message}`);
     const credPath = this.getCredentialsPath();
     const claudishDir = join15(homedir14(), ".claudish");
     if (!existsSync13(claudishDir)) {
-      const { mkdirSync: mkdirSync9 } = __require("fs");
-      mkdirSync9(claudishDir, { recursive: true });
+      const { mkdirSync: mkdirSync10 } = __require("fs");
+      mkdirSync10(claudishDir, { recursive: true });
     }
     const fd = openSync(credPath, "w", 384);
     try {
@@ -27163,8 +27273,8 @@ Details: ${e.message}`);
     const credPath = this.getCredentialsPath();
     const claudishDir = join16(homedir15(), ".claudish");
     if (!existsSync14(claudishDir)) {
-      const { mkdirSync: mkdirSync9 } = __require("fs");
-      mkdirSync9(claudishDir, { recursive: true });
+      const { mkdirSync: mkdirSync10 } = __require("fs");
+      mkdirSync10(claudishDir, { recursive: true });
     }
     const fd = openSync2(credPath, "w", 384);
     try {
@@ -27480,8 +27590,8 @@ class KimiOAuth {
     const deviceIdPath = this.getDeviceIdPath();
     const claudishDir = join18(homedir17(), ".claudish");
     if (!existsSync16(claudishDir)) {
-      const { mkdirSync: mkdirSync9 } = __require("fs");
-      mkdirSync9(claudishDir, { recursive: true });
+      const { mkdirSync: mkdirSync10 } = __require("fs");
+      mkdirSync10(claudishDir, { recursive: true });
     }
     if (existsSync16(deviceIdPath)) {
       try {
@@ -27764,8 +27874,8 @@ Waiting for authorization...`);
     const credPath = this.getCredentialsPath();
     const claudishDir = join18(homedir17(), ".claudish");
     if (!existsSync16(claudishDir)) {
-      const { mkdirSync: mkdirSync9 } = __require("fs");
-      mkdirSync9(claudishDir, { recursive: true });
+      const { mkdirSync: mkdirSync10 } = __require("fs");
+      mkdirSync10(claudishDir, { recursive: true });
     }
     const fd = openSync3(credPath, "w", 384);
     try {
@@ -28843,6 +28953,7 @@ var init_provider_profiles = __esm(() => {
     "glm-coding": glmProfile,
     "opencode-zen": openCodeZenProfile,
     "opencode-zen-go": openCodeZenProfile,
+    deepseek: openaiProfile,
     ollamacloud: ollamaCloudProfile,
     litellm: litellmProfile,
     vertex: vertexProfile
@@ -29001,7 +29112,7 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
     }
     return "auto-route";
   };
-  const getHandlerForRequest = (requestedModel) => {
+  const getHandlerForRequest = async (requestedModel) => {
     if (monitorMode)
       return nativeHandler;
     let target = requestedModel;
@@ -29026,6 +29137,7 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
     {
       const parsedTarget = parseModelSpec(target);
       if (parsedTarget.provider === "openrouter" || parsedTarget.provider === "litellm") {
+        await ensureCatalogReady(parsedTarget.provider, 5000);
         const resolution = resolveModelNameSync(parsedTarget.model, parsedTarget.provider);
         logResolution(parsedTarget.model, resolution, options.quiet);
         if (resolution.wasResolved) {
@@ -29040,6 +29152,7 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
         if (fallbackHandlerCache.has(cacheKey2)) {
           return fallbackHandlerCache.get(cacheKey2);
         }
+        await ensureCatalogReady("openrouter", 5000);
         const matchedEntries = customRoutingRules ? matchRoutingRule(parsedForFallback.model, customRoutingRules) : null;
         const chain = matchedEntries ? buildRoutingChain(matchedEntries, parsedForFallback.model) : getFallbackChain(parsedForFallback.model, parsedForFallback.provider);
         if (chain.length > 0) {
@@ -29099,7 +29212,7 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
     try {
       const body = await c.req.json();
       const reqModel = body.model || "claude-3-opus-20240229";
-      const handler = getHandlerForRequest(reqModel);
+      const handler = await getHandlerForRequest(reqModel);
       if (handler instanceof NativeHandler) {
         const headers = { "Content-Type": "application/json" };
         if (anthropicApiKey)
@@ -29121,7 +29234,7 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
   app.post("/v1/messages", async (c) => {
     try {
       const body = await c.req.json();
-      const handler = getHandlerForRequest(body.model);
+      const handler = await getHandlerForRequest(body.model);
       return handler.handle(c, body);
     } catch (e) {
       log(`[Proxy] Error: ${e}`);
@@ -29210,7 +29323,7 @@ var exports_mcp_server = {};
 __export(exports_mcp_server, {
   startMcpServer: () => startMcpServer
 });
-import { readFileSync as readFileSync17, existsSync as existsSync20, writeFileSync as writeFileSync9, mkdirSync as mkdirSync9, readdirSync as readdirSync3 } from "fs";
+import { readFileSync as readFileSync17, existsSync as existsSync20, writeFileSync as writeFileSync10, mkdirSync as mkdirSync10, readdirSync as readdirSync3 } from "fs";
 import { join as join22, dirname as dirname2 } from "path";
 import { homedir as homedir21 } from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -29242,8 +29355,8 @@ async function loadAllModels(forceRefresh = false) {
       throw new Error(`API returned ${response.status}`);
     const data = await response.json();
     const models = data.data || [];
-    mkdirSync9(CLAUDISH_CACHE_DIR, { recursive: true });
-    writeFileSync9(ALL_MODELS_CACHE_PATH, JSON.stringify({ lastUpdated: new Date().toISOString(), models }), "utf-8");
+    mkdirSync10(CLAUDISH_CACHE_DIR, { recursive: true });
+    writeFileSync10(ALL_MODELS_CACHE_PATH, JSON.stringify({ lastUpdated: new Date().toISOString(), models }), "utf-8");
     return models;
   } catch {
     if (existsSync20(ALL_MODELS_CACHE_PATH)) {
@@ -32719,9 +32832,9 @@ __export(exports_cli, {
 });
 import {
   readFileSync as readFileSync18,
-  writeFileSync as writeFileSync10,
+  writeFileSync as writeFileSync11,
   existsSync as existsSync21,
-  mkdirSync as mkdirSync10,
+  mkdirSync as mkdirSync11,
   copyFileSync,
   readdirSync as readdirSync4,
   unlinkSync as unlinkSync6
@@ -33071,8 +33184,8 @@ async function searchAndPrintModels(query, forceUpdate) {
         throw new Error(`API returned ${response.status}`);
       const data = await response.json();
       models = data.data;
-      mkdirSync10(CLAUDISH_CACHE_DIR2, { recursive: true });
-      writeFileSync10(ALL_MODELS_JSON_PATH, JSON.stringify({
+      mkdirSync11(CLAUDISH_CACHE_DIR2, { recursive: true });
+      writeFileSync11(ALL_MODELS_JSON_PATH, JSON.stringify({
         lastUpdated: new Date().toISOString(),
         models
       }), "utf-8");
@@ -33244,8 +33357,8 @@ async function printAllModels(jsonOutput, forceUpdate) {
         throw new Error(`API returned ${response.status}`);
       const data = await response.json();
       models = data.data;
-      mkdirSync10(CLAUDISH_CACHE_DIR2, { recursive: true });
-      writeFileSync10(ALL_MODELS_JSON_PATH, JSON.stringify({
+      mkdirSync11(CLAUDISH_CACHE_DIR2, { recursive: true });
+      writeFileSync11(ALL_MODELS_JSON_PATH, JSON.stringify({
         lastUpdated: new Date().toISOString(),
         models
       }), "utf-8");
@@ -33522,8 +33635,8 @@ async function updateModelsFromOpenRouter() {
       source: "https://openrouter.ai/models?categories=programming&fmt=cards&order=top-weekly",
       models: recommendations
     };
-    mkdirSync10(CLAUDISH_CACHE_DIR2, { recursive: true });
-    writeFileSync10(CACHED_MODELS_PATH, JSON.stringify(updatedData, null, 2), "utf-8");
+    mkdirSync11(CLAUDISH_CACHE_DIR2, { recursive: true });
+    writeFileSync11(CACHED_MODELS_PATH, JSON.stringify(updatedData, null, 2), "utf-8");
     console.error(`\u2705 Updated ${recommendations.length} models (last updated: ${updatedData.lastUpdated})`);
   } catch (error2) {
     console.error(`\u274C Failed to update models: ${error2 instanceof Error ? error2.message : String(error2)}`);
@@ -34173,15 +34286,15 @@ async function initializeClaudishSkill() {
   }
   try {
     if (!existsSync21(claudeDir)) {
-      mkdirSync10(claudeDir, { recursive: true });
+      mkdirSync11(claudeDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/ directory");
     }
     if (!existsSync21(skillsDir)) {
-      mkdirSync10(skillsDir, { recursive: true });
+      mkdirSync11(skillsDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/ directory");
     }
     if (!existsSync21(claudishSkillDir)) {
-      mkdirSync10(claudishSkillDir, { recursive: true });
+      mkdirSync11(claudishSkillDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/claudish-usage/ directory");
     }
     copyFileSync(sourceSkillPath, skillFile);
@@ -34361,7 +34474,7 @@ async function fetchGLMCodingModels() {
     return [];
   }
 }
-var __filename4, __dirname4, VERSION = "6.6.3", CACHE_MAX_AGE_DAYS2 = 2, CLAUDISH_CACHE_DIR2, BUNDLED_MODELS_PATH, CACHED_MODELS_PATH, ALL_MODELS_JSON_PATH;
+var __filename4, __dirname4, VERSION = "6.8.0", 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();
@@ -34392,7 +34505,7 @@ __export(exports_update_checker, {
   checkForUpdates: () => checkForUpdates
 });
 import { execSync } from "child_process";
-import { existsSync as existsSync22, mkdirSync as mkdirSync11, readFileSync as readFileSync19, unlinkSync as unlinkSync7, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync12, readFileSync as readFileSync19, unlinkSync as unlinkSync7, writeFileSync as writeFileSync12 } from "fs";
 import { homedir as homedir23, platform as platform2, tmpdir } from "os";
 import { join as join24 } from "path";
 import { createInterface as createInterface2 } from "readline";
@@ -34413,7 +34526,7 @@ function getCacheFilePath() {
   }
   try {
     if (!existsSync22(cacheDir)) {
-      mkdirSync11(cacheDir, { recursive: true });
+      mkdirSync12(cacheDir, { recursive: true });
     }
     return join24(cacheDir, "update-check.json");
   } catch {
@@ -34439,7 +34552,7 @@ function writeCache(latestVersion) {
       lastCheck: Date.now(),
       latestVersion
     };
-    writeFileSync11(cachePath, JSON.stringify(data), "utf-8");
+    writeFileSync12(cachePath, JSON.stringify(data), "utf-8");
   } catch {}
 }
 function isCacheValid(cache) {
@@ -34715,7 +34828,7 @@ __export(exports_model_selector, {
   promptForApiKey: () => promptForApiKey,
   confirmAction: () => confirmAction
 });
-import { readFileSync as readFileSync20, writeFileSync as writeFileSync12, existsSync as existsSync23, mkdirSync as mkdirSync12 } from "fs";
+import { readFileSync as readFileSync20, writeFileSync as writeFileSync13, existsSync as existsSync23, mkdirSync as mkdirSync13 } from "fs";
 import { join as join25, dirname as dirname4 } from "path";
 import { homedir as homedir24 } from "os";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -34753,8 +34866,8 @@ async function fetchAllModels(forceUpdate = false) {
       throw new Error(`API returned ${response.status}`);
     const data = await response.json();
     const models = data.data;
-    mkdirSync12(CLAUDISH_CACHE_DIR3, { recursive: true });
-    writeFileSync12(ALL_MODELS_JSON_PATH2, JSON.stringify({
+    mkdirSync13(CLAUDISH_CACHE_DIR3, { recursive: true });
+    writeFileSync13(ALL_MODELS_JSON_PATH2, JSON.stringify({
       lastUpdated: new Date().toISOString(),
       models
     }), "utf-8");
@@ -36634,7 +36747,7 @@ import os from "os";
 import path from "path";
 import { EventEmitter as EventEmitter3 } from "events";
 import { dlopen, toArrayBuffer as toArrayBuffer4, JSCallback, ptr as ptr4 } from "bun:ffi";
-import { existsSync as existsSync25, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync25, writeFileSync as writeFileSync14 } from "fs";
 import { EventEmitter as EventEmitter4 } from "events";
 import { toArrayBuffer, ptr } from "bun:ffi";
 import { ptr as ptr2, toArrayBuffer as toArrayBuffer2 } from "bun:ffi";
@@ -41980,7 +42093,7 @@ function convertToDebugSymbols(symbols) {
   if (env.OTUI_DEBUG_FFI && globalFFILogPath) {
     const logPath = globalFFILogPath;
     const writeSync4 = (msg) => {
-      writeFileSync13(logPath, msg + `
+      writeFileSync14(logPath, msg + `
 `, { flag: "a" });
     };
     Object.entries(symbols).forEach(([key, value]) => {
@@ -95546,10 +95659,10 @@ import { spawn as spawn3 } from "child_process";
 import {
   appendFileSync,
   existsSync as existsSync26,
-  mkdirSync as mkdirSync13,
+  mkdirSync as mkdirSync14,
   readFileSync as readFileSync21,
   unlinkSync as unlinkSync8,
-  writeFileSync as writeFileSync14
+  writeFileSync as writeFileSync15
 } from "fs";
 import { dirname as dirname6, join as join27 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
@@ -95562,7 +95675,7 @@ function formatElapsed(ms) {
   const rem = s % 60;
   return `${m2}m ${rem}s`;
 }
-function findMultiplexerBinary() {
+function findMagmuxBinary() {
   const thisFile = fileURLToPath6(import.meta.url);
   const thisDir = dirname6(thisFile);
   const pkgRoot = join27(thisDir, "..");
@@ -95570,40 +95683,17 @@ function findMultiplexerBinary() {
   const arch = process.arch;
   const builtMagmux = join27(pkgRoot, "native", "magmux", "magmux");
   if (existsSync26(builtMagmux))
-    return { path: builtMagmux, kind: "magmux" };
+    return builtMagmux;
   const bundledMagmux = join27(pkgRoot, "native", "magmux", `magmux-${platform3}-${arch}`);
   if (existsSync26(bundledMagmux))
-    return { path: bundledMagmux, kind: "magmux" };
+    return bundledMagmux;
   try {
     const result = execSync3("which magmux", { encoding: "utf-8" }).trim();
     if (result)
-      return { path: result, kind: "magmux" };
-  } catch {}
-  const builtMtm = join27(pkgRoot, "native", "mtm", "mtm");
-  if (existsSync26(builtMtm))
-    return { path: builtMtm, kind: "mtm" };
-  const bundledMtm = join27(pkgRoot, "native", "mtm", `mtm-${platform3}-${arch}`);
-  if (existsSync26(bundledMtm))
-    return { path: bundledMtm, kind: "mtm" };
-  try {
-    const result = execSync3("which mtm", { encoding: "utf-8" }).trim();
-    if (result && isMtmForkWithGrid(result))
-      return { path: result, kind: "mtm" };
+      return result;
   } catch {}
-  throw new Error(`No terminal multiplexer found. Install magmux (recommended) or build mtm:
-` + `  brew install MadAppGang/tap/magmux
-` + "  # or: 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;
-  }
+  throw new Error(`magmux not found. Install it:
+  brew install MadAppGang/tap/magmux`);
 }
 function renderGridStatusBar(counts) {
   const elapsed = formatElapsed(counts.elapsedMs);
@@ -95671,7 +95761,7 @@ function pollStatus(state) {
       else
         failed++;
     } else {
-      if (elapsedMs > timeoutMs) {
+      if (!state.interactive && elapsedMs > timeoutMs) {
         const newState = {
           ...current,
           state: "TIMEOUT",
@@ -95696,7 +95786,7 @@ function pollStatus(state) {
     }
   }
   if (changed) {
-    writeFileSync14(statusPath, JSON.stringify(statusCache, null, 2), "utf-8");
+    writeFileSync15(statusPath, JSON.stringify(statusCache, null, 2), "utf-8");
   }
   const total = anonIds.length;
   const allDone = done + failed >= total;
@@ -95717,8 +95807,9 @@ function pollStatus(state) {
 }
 async function runWithGrid(sessionPath, models, input, opts) {
   const timeoutMs = (opts?.timeout ?? 300) * 1000;
+  const interactive = opts?.interactive ?? false;
   const manifest = setupSession(sessionPath, models, input);
-  mkdirSync13(join27(sessionPath, "errors"), { recursive: true });
+  mkdirSync14(join27(sessionPath, "errors"), { recursive: true });
   for (const anonId of Object.keys(manifest.models)) {
     const stale = join27(sessionPath, "work", anonId, ".exit-code");
     try {
@@ -95732,6 +95823,9 @@ async function runWithGrid(sessionPath, models, input, opts) {
     const exitCodeFile = join27(sessionPath, "work", anonId, ".exit-code");
     const model = manifest.models[anonId].model;
     const paneIndex = Object.keys(manifest.models).indexOf(anonId);
+    if (interactive) {
+      return `claudish --model ${model} --dangerously-skip-permissions '${prompt}'`;
+    }
     return [
       `claudish --model ${model} -y -v '${prompt}' 2>${errorLog};`,
       `_ec=$?; echo $_ec > ${exitCodeFile};`,
@@ -95747,10 +95841,10 @@ async function runWithGrid(sessionPath, models, input, opts) {
       `exec sleep 86400`
     ].join(" ");
   });
-  writeFileSync14(gridfilePath, gridLines.join(`
+  writeFileSync15(gridfilePath, gridLines.join(`
 `) + `
 `, "utf-8");
-  const mux = findMultiplexerBinary();
+  const magmuxPath = findMagmuxBinary();
   const statusbarPath = join27(sessionPath, "statusbar.txt");
   const statusPath = join27(sessionPath, "status.json");
   const statusCache = JSON.parse(readFileSync21(statusPath, "utf-8"));
@@ -95773,18 +95867,17 @@ async function runWithGrid(sessionPath, models, input, opts) {
     startTime,
     timeoutMs,
     statusbarPath,
-    completedAtMs: null
+    completedAtMs: null,
+    interactive
   };
   const pollInterval = setInterval(() => {
     pollStatus(pollState);
   }, 500);
   const spawnArgs = ["-g", gridfilePath, "-S", statusbarPath];
-  if (mux.kind === "mtm") {
-    spawnArgs.push("-t", "xterm-256color");
-  } else {
+  if (!interactive) {
     spawnArgs.push("-w");
   }
-  const proc = spawn3(mux.path, spawnArgs, {
+  const proc = spawn3(magmuxPath, spawnArgs, {
     stdio: "inherit",
     env: { ...process.env }
   });
@@ -95844,7 +95937,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
+  --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)
@@ -95861,11 +95954,13 @@ Examples:
 `);
 }
 async function teamCommand(args) {
-  const subcommand = args[0];
-  if (!subcommand || hasFlag(args, "--help") || hasFlag(args, "-h")) {
+  if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
     printHelp2();
     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 {
@@ -95876,22 +95971,36 @@ async function teamCommand(args) {
   }
   const modelsRaw = getFlag(args, "--models");
   const judgesRaw = getFlag(args, "--judges");
-  const input = getFlag(args, "--input");
+  const mode = getFlag(args, "--mode") ?? "default";
   const timeoutStr = getFlag(args, "--timeout");
   const timeout = timeoutStr ? 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((m2) => m2.trim()).filter(Boolean) : [];
   const judges = judgesRaw ? judgesRaw.split(",").map((m2) => m2.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 for 'run'");
+        console.error("Error: --models is required");
+        printHelp2();
         process.exit(1);
       }
-      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 {
+      if (effectiveMode === "json") {
         setupSession(sessionPath, models, input);
         const runStatus = await runModels(sessionPath, {
           timeout,
@@ -95901,17 +96010,22 @@ async function teamCommand(args) {
           }
         });
         printStatus(runStatus);
+      } else {
+        const { runWithGrid: runWithGrid2 } = await Promise.resolve().then(() => (init_team_grid(), exports_team_grid));
+        const interactive = effectiveMode === "interactive";
+        const gridStatus = await runWithGrid2(sessionPath, models, input ?? "", { timeout, interactive });
+        printStatus(gridStatus);
       }
       break;
     }
     case "judge": {
-      const verdict = await judgeResponses(sessionPath, { judges });
+      await judgeResponses(sessionPath, { judges });
       console.log(readFileSync22(join28(sessionPath, "verdict.md"), "utf-8"));
       break;
     }
     case "run-and-judge": {
       if (models.length === 0) {
-        console.error("Error: --models is required for 'run-and-judge'");
+        console.error("Error: --models is required");
         process.exit(1);
       }
       setupSession(sessionPath, models, input);
@@ -95928,15 +96042,10 @@ async function teamCommand(args) {
       break;
     }
     case "status": {
-      const status = getStatus(sessionPath);
-      printStatus(status);
+      const statusResult = getStatus(sessionPath);
+      printStatus(statusResult);
       break;
     }
-    default: {
-      console.error(`Unknown team subcommand: ${subcommand}`);
-      printHelp2();
-      process.exit(1);
-    }
   }
 }
 var init_team_cli = __esm(() => {
@@ -95950,7 +96059,7 @@ __export(exports_claude_runner, {
   checkClaudeInstalled: () => checkClaudeInstalled
 });
 import { spawn as spawn4 } from "child_process";
-import { writeFileSync as writeFileSync15, unlinkSync as unlinkSync9, mkdirSync as mkdirSync14, existsSync as existsSync28, readFileSync as readFileSync23 } from "fs";
+import { writeFileSync as writeFileSync16, unlinkSync as unlinkSync9, mkdirSync as mkdirSync15, existsSync as existsSync28, readFileSync as readFileSync23 } from "fs";
 import { tmpdir as tmpdir2, homedir as homedir25 } from "os";
 import { join as join29 } from "path";
 function hasNativeAnthropicMapping(config3) {
@@ -96059,14 +96168,14 @@ process.stdin.on('end', () => {
   }
 });
 `;
-  writeFileSync15(scriptPath, script, "utf-8");
+  writeFileSync16(scriptPath, script, "utf-8");
   return scriptPath;
 }
 function createTempSettingsFile(modelDisplay, port) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
   const claudishDir = join29(homeDir, ".claudish");
   try {
-    mkdirSync14(claudishDir, { recursive: true });
+    mkdirSync15(claudishDir, { recursive: true });
   } catch {}
   const timestamp = Date.now();
   const tempPath = join29(claudishDir, `settings-${timestamp}.json`);
@@ -96092,7 +96201,7 @@ function createTempSettingsFile(modelDisplay, port) {
     padding: 0
   };
   const settings = { statusLine };
-  writeFileSync15(tempPath, JSON.stringify(settings, null, 2), "utf-8");
+  writeFileSync16(tempPath, JSON.stringify(settings, null, 2), "utf-8");
   return { path: tempPath, statusLine };
 }
 function mergeUserSettingsIfPresent(config3, tempSettingsPath, statusLine) {
@@ -96110,7 +96219,7 @@ function mergeUserSettingsIfPresent(config3, tempSettingsPath, statusLine) {
       userSettings = JSON.parse(rawUserSettings);
     }
     userSettings.statusLine = statusLine;
-    writeFileSync15(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
+    writeFileSync16(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
   } catch {
     if (!config3.quiet) {
       console.warn(`[claudish] Warning: could not merge user settings: ${userSettingsValue}`);
@@ -96118,7 +96227,7 @@ function mergeUserSettingsIfPresent(config3, tempSettingsPath, statusLine) {
   }
   config3.claudeArgs.splice(idx, 2);
 }
-async function runClaudeWithProxy(config3, proxyUrl, onCleanup, ptyDiagRunner) {
+async function runClaudeWithProxy(config3, proxyUrl, onCleanup) {
   const hasProfileMappings = config3.modelOpus || config3.modelSonnet || config3.modelHaiku || config3.modelSubagent;
   const modelId = config3.model || (hasProfileMappings || config3.monitor ? undefined : "unknown");
   const portMatch = proxyUrl.match(/:(\d+)/);
@@ -96205,28 +96314,20 @@ Or set CLAUDE_PATH to your custom installation:`);
   }
   const needsShell = isWindows2() && claudeBinary.endsWith(".cmd");
   const spawnCommand = needsShell ? `"${claudeBinary}"` : claudeBinary;
-  let exitCode;
-  if (config3.interactive && ptyDiagRunner) {
-    exitCode = await ptyDiagRunner.run(spawnCommand, claudeArgs, env2);
-    try {
-      unlinkSync9(tempSettingsPath);
-    } catch {}
-  } else {
-    const proc = spawn4(spawnCommand, claudeArgs, {
-      env: env2,
-      stdio: "inherit",
-      shell: needsShell
-    });
-    setupSignalHandlers(proc, tempSettingsPath, config3.quiet, onCleanup);
-    exitCode = await new Promise((resolve4) => {
-      proc.on("exit", (code) => {
-        resolve4(code ?? 1);
-      });
+  const proc = spawn4(spawnCommand, claudeArgs, {
+    env: env2,
+    stdio: "inherit",
+    shell: needsShell
+  });
+  setupSignalHandlers(proc, tempSettingsPath, config3.quiet, onCleanup);
+  const exitCode = await new Promise((resolve4) => {
+    proc.on("exit", (code) => {
+      resolve4(code ?? 1);
     });
-    try {
-      unlinkSync9(tempSettingsPath);
-    } catch {}
-  }
+  });
+  try {
+    unlinkSync9(tempSettingsPath);
+  } catch {}
   return exitCode;
 }
 function setupSignalHandlers(proc, tempSettingsPath, quiet, onCleanup) {
@@ -96330,20 +96431,16 @@ var init_claude_runner = __esm(() => {
 var exports_diag_output = {};
 __export(exports_diag_output, {
   createDiagOutput: () => createDiagOutput,
-  TmuxDiagOutput: () => TmuxDiagOutput,
-  OpentUiDiagOutput: () => OpentUiDiagOutput,
   NullDiagOutput: () => NullDiagOutput,
-  MtmDiagOutput: () => MtmDiagOutput,
   LogFileDiagOutput: () => LogFileDiagOutput
 });
-import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync15, writeFileSync as writeFileSync16, unlinkSync as unlinkSync10 } from "fs";
-import { execFileSync } from "child_process";
+import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync16, writeFileSync as writeFileSync17, unlinkSync as unlinkSync10 } from "fs";
 import { homedir as homedir26 } from "os";
 import { join as join30 } from "path";
 function getClaudishDir() {
   const dir = join30(homedir26(), ".claudish");
   try {
-    mkdirSync15(dir, { recursive: true });
+    mkdirSync16(dir, { recursive: true });
   } catch {}
   return dir;
 }
@@ -96357,7 +96454,7 @@ class LogFileDiagOutput {
   constructor() {
     this.logPath = getDiagLogPath();
     try {
-      writeFileSync16(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
+      writeFileSync17(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
 `);
     } catch {}
     this.stream = createWriteStream3(this.logPath, { flags: "a" });
@@ -96384,30 +96481,6 @@ class LogFileDiagOutput {
   }
 }
 
-class MtmDiagOutput {
-  runner;
-  constructor(runner) {
-    this.runner = runner;
-  }
-  write(msg) {
-    this.runner.write(msg);
-  }
-  cleanup() {}
-}
-
-class OpentUiDiagOutput {
-  inner;
-  constructor(runner) {
-    this.inner = new MtmDiagOutput(runner);
-  }
-  write(msg) {
-    this.inner.write(msg);
-  }
-  cleanup() {
-    this.inner.cleanup();
-  }
-}
-
 class NullDiagOutput {
   write(_msg) {}
   cleanup() {}
@@ -96420,389 +96493,22 @@ function createDiagOutput(options) {
   if (mode === "off") {
     return new NullDiagOutput;
   }
-  const mtmRunner = options.mtmRunner ?? options.ptyRunner ?? null;
-  if (mode === "pty" || mode === "auto") {
-    if (mtmRunner) {
-      return new MtmDiagOutput(mtmRunner);
-    }
-    if (mode === "pty") {
-      return new LogFileDiagOutput;
-    }
-  }
-  if (mode === "tmux" || mode === "auto") {
-    if (process.env.TMUX) {
-      return new TmuxDiagOutput;
-    }
-    if (mode === "tmux") {
-      return new LogFileDiagOutput;
-    }
-  }
   return new LogFileDiagOutput;
 }
-var TmuxDiagOutput;
-var init_diag_output = __esm(() => {
-  TmuxDiagOutput = class TmuxDiagOutput extends LogFileDiagOutput {
-    paneId = null;
-    constructor() {
-      super();
-      this.openTmuxPane();
-    }
-    openTmuxPane() {
-      try {
-        const targetPane = process.env.TMUX_PANE || "";
-        const args = ["split-window", "-v", "-l", "5", "-d", "-P", "-F", "#{pane_id}"];
-        if (targetPane) {
-          args.push("-t", targetPane);
-        }
-        args.push("tail", "-f", this.logPath);
-        const output = execFileSync("tmux", args, {
-          encoding: "utf-8",
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-        this.paneId = output.trim();
-      } catch {
-        this.paneId = null;
-      }
-    }
-    cleanup() {
-      if (this.paneId) {
-        try {
-          execFileSync("tmux", ["kill-pane", "-t", this.paneId], {
-            stdio: ["pipe", "pipe", "pipe"]
-          });
-        } catch {}
-        this.paneId = null;
-      }
-      super.cleanup();
-    }
-  };
-});
-
-// src/pty-diag-runner.ts
-var exports_pty_diag_runner = {};
-__export(exports_pty_diag_runner, {
-  tryCreatePtyRunner: () => tryCreatePtyRunner,
-  tryCreateMtmRunner: () => tryCreateMtmRunner,
-  PtyDiagRunner: () => MtmDiagRunner,
-  MtmDiagRunner: () => MtmDiagRunner
-});
-import { spawn as spawn5 } from "child_process";
-import {
-  appendFileSync as appendFileSync2,
-  createWriteStream as createWriteStream4,
-  existsSync as existsSync29,
-  mkdirSync as mkdirSync16,
-  readFileSync as readFileSync24,
-  unlinkSync as unlinkSync11
-} from "fs";
-import { homedir as homedir27 } from "os";
-import { dirname as dirname7, join as join31 } from "path";
-import { execSync as execSync4 } from "child_process";
-import { fileURLToPath as fileURLToPath7 } from "url";
-
-class MtmDiagRunner {
-  mtmProc = null;
-  logPath;
-  statusPath;
-  logStream = null;
-  constructor() {
-    const dir = join31(homedir27(), ".claudish");
-    try {
-      mkdirSync16(dir, { recursive: true });
-    } catch {}
-    this.logPath = join31(dir, `diag-${process.pid}.log`);
-    this.statusPath = join31(dir, `status-${process.pid}.txt`);
-    this.logStream = createWriteStream4(this.logPath, { flags: "w" });
-    this.logStream.on("error", () => {});
-  }
-  async run(claudeCommand, claudeArgs, env2) {
-    const mtmBin = this.findMtmBinary();
-    const quotedArgs = claudeArgs.map((a) => shellQuote(a)).join(" ");
-    const claudeCmd = `${shellQuote(claudeCommand)} ${quotedArgs}`;
-    const mergedEnv = { ...process.env, ...env2 };
-    this.mtmProc = spawn5(mtmBin, ["-t", "xterm-256color", "-e", claudeCmd, "-S", this.statusPath, "-L", this.logPath], {
-      stdio: "inherit",
-      env: mergedEnv
-    });
-    const exitCode = await new Promise((resolve4) => {
-      this.mtmProc.on("exit", (code) => {
-        resolve4(code ?? 1);
-      });
-      this.mtmProc.on("error", (err) => {
-        if (this.logStream) {
-          try {
-            this.logStream.write(`[mtm] spawn error: ${err.message}
-`);
-          } catch {}
-        }
-        resolve4(1);
-      });
-    });
-    this.cleanup();
-    return exitCode;
-  }
-  write(msg) {
-    if (!this.logStream)
-      return;
-    const timestamp = new Date().toISOString();
-    try {
-      this.logStream.write(`[${timestamp}] ${msg}
-`);
-    } catch {}
-    const parsed = parseLogMessage(msg);
-    if (parsed.isError) {
-      this.errorCount++;
-      this.lastError = parsed.short;
-      if (parsed.provider)
-        this.provider = parsed.provider;
-    }
-    if (msg.includes("HANDLER STARTED") || msg.includes("=== Request")) {
-      this.requestCount++;
-    }
-    const rtMatch = msg.match(/(\d+)ms\b/);
-    if (rtMatch && msg.includes("Response")) {
-      const ms = parseInt(rtMatch[1], 10);
-      this.roundtripSamples.push(ms);
-      if (this.roundtripSamples.length > 20)
-        this.roundtripSamples.shift();
-      this.avgRoundtripMs = Math.round(this.roundtripSamples.reduce((a, b2) => a + b2, 0) / this.roundtripSamples.length);
-    }
-    if (msg.includes("Format:") || msg.includes("Transport:") || msg.includes("Translator:")) {
-      const parts = msg.split(":").slice(1).join(":").trim();
-      if (parts)
-        this.adapters = parts;
-    }
-    if (msg.includes("Auth refreshed") && msg.includes("tier:")) {
-      const tierMatch = msg.match(/tier:\s*(.+)$/);
-      if (tierMatch)
-        this.provider = tierMatch[1].trim();
-    }
-    if (msg.includes("[Fallback]") && msg.includes("succeeded")) {
-      const fbMatch = msg.match(/\[Fallback\]\s+(\S+)\s+succeeded/);
-      if (fbMatch)
-        this.provider = fbMatch[1];
-    }
-    if (msg.includes("Rate limited") && msg.includes("retrying")) {
-      this.lastError = msg.replace(/.*\]\s*/, "").substring(0, 60);
-    }
-    this.refreshStatusBar();
-  }
-  modelName = "";
-  provider = "";
-  port = "";
-  quotaRemaining;
-  tokenPollTimer = null;
-  lastError = "";
-  errorCount = 0;
-  requestCount = 0;
-  totalCost = 0;
-  avgRoundtripMs = 0;
-  roundtripSamples = [];
-  adapters = "";
-  setPort(port) {
-    this.port = String(port);
-    this.tokenPollTimer = setInterval(() => {
-      const changed = this.readTokenFile();
-      if (changed)
-        this.refreshStatusBar();
-    }, 3000);
-  }
-  setModel(name) {
-    this.modelName = name.includes("/") ? name.split("/").pop() : name;
-    if (name.includes("@")) {
-      this.provider = name.split("@")[0];
-    } else if (name.includes("/")) {
-      this.provider = name.split("/")[0];
-    }
-  }
-  readTokenFile() {
-    if (!this.port)
-      return false;
-    try {
-      const tokPath = join31(homedir27(), ".claudish", `tokens-${this.port}.json`);
-      const tok = JSON.parse(readFileSync24(tokPath, "utf-8"));
-      let changed = false;
-      if (typeof tok.quota_remaining === "number" && tok.quota_remaining !== this.quotaRemaining) {
-        this.quotaRemaining = tok.quota_remaining;
-        changed = true;
-      }
-      if (tok.provider_name && tok.provider_name !== this.provider) {
-        this.provider = tok.provider_name;
-        changed = true;
-      }
-      return changed;
-    } catch {
-      return false;
-    }
-  }
-  refreshStatusBar() {
-    this.readTokenFile();
-    const bar = renderStatusBar({
-      model: this.modelName,
-      provider: this.provider,
-      errorCount: this.errorCount,
-      lastError: this.lastError,
-      requestCount: this.requestCount,
-      avgRoundtripMs: this.avgRoundtripMs,
-      quotaRemaining: this.quotaRemaining
-    });
-    try {
-      appendFileSync2(this.statusPath, bar + `
-`);
-    } catch {}
-  }
-  getLogPath() {
-    return this.logPath;
-  }
-  cleanup() {
-    if (this.tokenPollTimer) {
-      clearInterval(this.tokenPollTimer);
-      this.tokenPollTimer = null;
-    }
-    if (this.logStream) {
-      try {
-        this.logStream.end();
-      } catch {}
-      this.logStream = null;
-    }
-    try {
-      unlinkSync11(this.logPath);
-    } catch {}
-    try {
-      unlinkSync11(this.statusPath);
-    } catch {}
-    if (this.mtmProc) {
-      try {
-        this.mtmProc.kill();
-      } catch {}
-      this.mtmProc = null;
-    }
-  }
-  findMtmBinary() {
-    const thisFile = fileURLToPath7(import.meta.url);
-    const thisDir = dirname7(thisFile);
-    const platform3 = process.platform;
-    const arch = process.arch;
-    const pkgRoot = join31(thisDir, "..");
-    const bundledPlatform = join31(pkgRoot, "native", "mtm", `mtm-${platform3}-${arch}`);
-    if (existsSync29(bundledPlatform))
-      return bundledPlatform;
-    const builtDev = join31(pkgRoot, "native", "mtm", "mtm");
-    if (existsSync29(builtDev))
-      return builtDev;
-    try {
-      const result = execSync4("which mtm", { encoding: "utf-8" }).trim();
-      if (result && this.isMtmFork(result))
-        return result;
-    } catch {}
-    throw new Error("mtm binary not found. Build it with: cd packages/cli/native/mtm && make");
-  }
-  isMtmFork(binPath) {
-    try {
-      const output = execSync4(`"${binPath}" --help 2>&1 || true`, {
-        encoding: "utf-8",
-        timeout: 2000
-      });
-      return output.includes("-e ");
-    } catch {
-      return false;
-    }
-  }
-}
-function shellQuote(s) {
-  return "'" + s.replace(/'/g, "'\\''") + "'";
-}
-function renderStatusBar(state) {
-  const { model, provider, errorCount, lastError, quotaRemaining } = state;
-  const parts = [];
-  parts.push("M: claudish ");
-  if (model)
-    parts.push(`C: ${model} `);
-  if (provider)
-    parts.push(`D: ${provider}`);
-  if (errorCount > 0) {
-    const errLabel = errorCount === 1 ? "\u26A0 1 error" : `\u26A0 ${errorCount} errors`;
-    parts.push(`R: ${errLabel} `);
-    if (lastError)
-      parts.push(`D: ${lastError}`);
-  }
-  if (typeof quotaRemaining === "number") {
-    const usedPct = Math.round((1 - quotaRemaining) * 100);
-    const barWidth = 8;
-    const usedCols = Math.max(usedPct > 0 ? 1 : 0, Math.round(usedPct / 100 * barWidth));
-    const freeCols = barWidth - usedCols;
-    const bar = "\u2588".repeat(usedCols) + "\u2591".repeat(freeCols);
-    const color = usedPct < 50 ? "g" : usedPct < 80 ? "y" : "r";
-    parts.push(`${color}: ${bar} ${usedPct}%`);
-  }
-  return parts.join("\t");
-}
-function parseLogMessage(msg) {
-  const providerMatch = msg.match(/\[(?!Fallback|Streaming|Auto-route|SSE)([^\]]+)\]/);
-  const provider = providerMatch?.[1];
-  if (msg.includes("All") && msg.includes("failed")) {
-    const countMatch = msg.match(/All (\d+)/);
-    return { isError: true, short: `all ${countMatch?.[1] || ""} providers failed`, provider };
-  }
-  if (msg.includes("[Fallback]")) {
-    if (msg.includes("succeeded")) {
-      const n = msg.match(/after (\d+)/)?.[1] || "?";
-      return { isError: false, short: `succeeded after ${n} retries`, provider };
-    }
-    const failMatch = msg.match(/\]\s*(.+?)\s+failed/);
-    return {
-      isError: false,
-      short: failMatch ? `${failMatch[1]} failed, retrying` : "fallback",
-      provider
-    };
-  }
-  const httpMatch = msg.match(/HTTP (\d{3})/);
-  if (httpMatch) {
-    const jsonMatch = msg.match(/"message"\s*:\s*"([^"]+)"/);
-    if (jsonMatch?.[1]) {
-      const detail = jsonMatch[1].replace(/is not a valid model ID/, "invalid model").replace(/Provider returned error/, "provider error");
-      return { isError: true, short: detail, provider };
-    }
-    const hintMatch = msg.match(/HTTP \d{3}\.\s*(.+?)\.?\s*$/);
-    if (hintMatch?.[1]) {
-      return { isError: true, short: hintMatch[1], provider };
-    }
-    return { isError: true, short: `HTTP ${httpMatch[1]}`, provider };
-  }
-  if (msg.toLowerCase().includes("error")) {
-    const short = msg.replace(/^Error\s*\[[^\]]+\]:\s*/, "").replace(/\.\s*$/, "");
-    return { isError: true, short: short.length > 80 ? short.slice(0, 79) + "\u2026" : short, provider };
-  }
-  return { isError: false, short: msg.length > 80 ? msg.slice(0, 79) + "\u2026" : msg };
-}
-async function tryCreateMtmRunner() {
-  if (process.env.MTM)
-    return null;
-  try {
-    const runner = new MtmDiagRunner;
-    runner.findMtmBinary();
-    return runner;
-  } catch {
-    return null;
-  }
-}
-var tryCreatePtyRunner;
-var init_pty_diag_runner = __esm(() => {
-  tryCreatePtyRunner = tryCreateMtmRunner;
-});
+var init_diag_output = () => {};
 
 // src/index.ts
 var import_dotenv3 = __toESM(require_main(), 1);
-import { existsSync as existsSync30, readFileSync as readFileSync25 } from "fs";
-import { homedir as homedir28 } from "os";
-import { join as join32 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync24 } from "fs";
+import { homedir as homedir27 } from "os";
+import { join as join31 } from "path";
 import_dotenv3.config({ quiet: true });
 function loadStoredApiKeys() {
   try {
-    const configPath = join32(homedir28(), ".claudish", "config.json");
-    if (!existsSync30(configPath))
+    const configPath = join31(homedir27(), ".claudish", "config.json");
+    if (!existsSync29(configPath))
       return;
-    const raw2 = readFileSync25(configPath, "utf-8");
+    const raw2 = readFileSync24(configPath, "utf-8");
     const cfg = JSON.parse(raw2);
     if (cfg.apiKeys) {
       for (const [envVar, value] of Object.entries(cfg.apiKeys)) {
@@ -96903,8 +96609,7 @@ async function runCli() {
     getMissingKeysError: getMissingKeysError2
   } = await Promise.resolve().then(() => (init_provider_resolver(), exports_provider_resolver));
   const { initLogger: initLogger2, getLogFilePath: getLogFilePath2, getAlwaysOnLogPath: getAlwaysOnLogPath2, setDiagOutput: setDiagOutput2 } = await Promise.resolve().then(() => (init_logger(), exports_logger));
-  const { createDiagOutput: createDiagOutput2, LogFileDiagOutput: LogFileDiagOutput2 } = await Promise.resolve().then(() => (init_diag_output(), exports_diag_output));
-  const { tryCreateMtmRunner: tryCreateMtmRunner2 } = await Promise.resolve().then(() => (init_pty_diag_runner(), exports_pty_diag_runner));
+  const { createDiagOutput: createDiagOutput2 } = await Promise.resolve().then(() => (init_diag_output(), exports_diag_output));
   const { findAvailablePort: findAvailablePort2 } = await Promise.resolve().then(() => (init_port_manager(), exports_port_manager));
   const { createProxyServer: createProxyServer2 } = await Promise.resolve().then(() => (init_proxy_server(), exports_proxy_server));
   const { checkForUpdates: checkForUpdates2 } = await Promise.resolve().then(() => (init_update_checker(), exports_update_checker));
@@ -97059,27 +96764,16 @@ async function runCli() {
       quiet: cliConfig.quiet,
       isInteractive: cliConfig.interactive
     });
-    const needsMtm = cliConfig.interactive && (cliConfig.diagMode === "auto" || cliConfig.diagMode === "pty");
-    const mtmRunner = needsMtm ? await tryCreateMtmRunner2() : null;
-    if (mtmRunner) {
-      if (explicitModel)
-        mtmRunner.setModel(explicitModel);
-      mtmRunner.setPort(port);
-    }
     const diag = createDiagOutput2({
       interactive: cliConfig.interactive,
-      mtmRunner,
       diagMode: cliConfig.diagMode
     });
     if (cliConfig.interactive) {
       setDiagOutput2(diag);
-      if (!mtmRunner && !process.env.TMUX && !cliConfig.quiet && diag instanceof LogFileDiagOutput2) {
-        console.log(`[claudish] Diagnostic log: ${diag.getLogPath()}`);
-      }
     }
     let exitCode = 0;
     try {
-      exitCode = await runClaudeWithProxy2(cliConfig, proxy.url, () => diag.cleanup(), mtmRunner);
+      exitCode = await runClaudeWithProxy2(cliConfig, proxy.url, () => diag.cleanup());
     } finally {
       setDiagOutput2(null);
       diag.cleanup();