claudish 6.13.2 → 6.14.0

package/dist/index.js

@@ -17321,188 +17321,6 @@ var init_openrouter_queue = __esm(() => {
   init_logger();
 });
 
-// src/model-loader.ts
-import { readFileSync as readFileSync2, existsSync as existsSync3, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
-import { join as join4, dirname } from "path";
-import { fileURLToPath } from "url";
-import { homedir as homedir3 } from "os";
-import { createHash } from "crypto";
-function getRecommendedModelsPath() {
-  return join4(__dirname2, "../recommended-models.json");
-}
-function loadRecommendedModelsJSON() {
-  if (_cachedRecommendedModels) {
-    return _cachedRecommendedModels;
-  }
-  if (existsSync3(RECOMMENDED_CACHE_PATH)) {
-    try {
-      const cacheData = JSON.parse(readFileSync2(RECOMMENDED_CACHE_PATH, "utf-8"));
-      if (cacheData.models && cacheData.models.length > 0) {
-        const generatedAt = cacheData.generatedAt;
-        if (generatedAt) {
-          const ageHours = (Date.now() - new Date(generatedAt).getTime()) / (1000 * 60 * 60);
-          if (ageHours <= RECOMMENDED_CACHE_MAX_AGE_HOURS) {
-            _cachedRecommendedModels = cacheData;
-            return cacheData;
-          }
-        } else {
-          _cachedRecommendedModels = cacheData;
-          return cacheData;
-        }
-      }
-    } catch {}
-  }
-  const jsonPath = getRecommendedModelsPath();
-  if (!existsSync3(jsonPath)) {
-    throw new Error(`recommended-models.json not found at ${jsonPath}. ` + `Run 'claudish --update-models' to fetch the latest model list.`);
-  }
-  try {
-    const jsonContent = readFileSync2(jsonPath, "utf-8");
-    _cachedRecommendedModels = JSON.parse(jsonContent);
-    return _cachedRecommendedModels;
-  } catch (error2) {
-    throw new Error(`Failed to parse recommended-models.json: ${error2}`);
-  }
-}
-function loadModelInfo() {
-  if (_cachedModelInfo) {
-    return _cachedModelInfo;
-  }
-  const data = loadRecommendedModelsJSON();
-  const modelInfo = {};
-  for (const model of data.models) {
-    modelInfo[model.id] = {
-      name: model.name,
-      description: model.description,
-      priority: model.priority,
-      provider: model.provider
-    };
-  }
-  modelInfo.custom = {
-    name: "Custom Model",
-    description: "Enter any OpenRouter model ID manually",
-    priority: 999,
-    provider: "Custom"
-  };
-  _cachedModelInfo = modelInfo;
-  return modelInfo;
-}
-function getAvailableModels() {
-  if (_cachedModelIds) {
-    return _cachedModelIds;
-  }
-  const data = loadRecommendedModelsJSON();
-  const modelIds = data.models.sort((a, b) => a.priority - b.priority).map((m) => m.id);
-  const result = [...modelIds, "custom"];
-  _cachedModelIds = result;
-  return result;
-}
-function getCachedOpenRouterModels() {
-  return _cachedOpenRouterModels;
-}
-async function ensureOpenRouterModelsLoaded() {
-  if (_cachedOpenRouterModels)
-    return _cachedOpenRouterModels;
-  try {
-    const response = await fetch("https://openrouter.ai/api/v1/models");
-    if (response.ok) {
-      const data = await response.json();
-      _cachedOpenRouterModels = data.data || [];
-      return _cachedOpenRouterModels;
-    }
-  } catch {}
-  return [];
-}
-async function fetchLiteLLMModels(baseUrl, apiKey, forceUpdate = false) {
-  const hash = createHash("sha256").update(baseUrl).digest("hex").substring(0, 16);
-  const cacheDir = join4(homedir3(), ".claudish");
-  const cachePath = join4(cacheDir, `litellm-models-${hash}.json`);
-  if (!forceUpdate && existsSync3(cachePath)) {
-    try {
-      const cacheData = JSON.parse(readFileSync2(cachePath, "utf-8"));
-      const timestamp = new Date(cacheData.timestamp);
-      const now = new Date;
-      const ageInHours = (now.getTime() - timestamp.getTime()) / (1000 * 60 * 60);
-      if (ageInHours < LITELLM_CACHE_MAX_AGE_HOURS) {
-        return cacheData.models;
-      }
-    } catch {}
-  }
-  try {
-    const url = `${baseUrl.replace(/\/$/, "")}/model_group/info`;
-    const response = await fetch(url, {
-      headers: {
-        Authorization: `Bearer ${apiKey}`
-      },
-      signal: AbortSignal.timeout(1e4)
-    });
-    if (!response.ok) {
-      console.error(`Failed to fetch LiteLLM models: ${response.status} ${response.statusText}`);
-      if (existsSync3(cachePath)) {
-        try {
-          const cacheData2 = JSON.parse(readFileSync2(cachePath, "utf-8"));
-          return cacheData2.models;
-        } catch {
-          return [];
-        }
-      }
-      return [];
-    }
-    const responseData = await response.json();
-    const rawModels = responseData.data || responseData;
-    const transformedModels = rawModels.filter((m) => m.mode === "chat" && m.supports_function_calling).map((m) => {
-      const inputCostPerM = (m.input_cost_per_token || 0) * 1e6;
-      const outputCostPerM = (m.output_cost_per_token || 0) * 1e6;
-      const avgCost = (inputCostPerM + outputCostPerM) / 2;
-      const isFree = inputCostPerM === 0 && outputCostPerM === 0;
-      const contextLength = m.max_input_tokens || 128000;
-      const contextStr = contextLength >= 1e6 ? `${Math.round(contextLength / 1e6)}M` : `${Math.round(contextLength / 1000)}K`;
-      return {
-        id: `litellm@${m.model_group}`,
-        name: m.model_group,
-        description: `LiteLLM model (providers: ${m.providers.join(", ")})`,
-        provider: "LiteLLM",
-        pricing: {
-          input: isFree ? "FREE" : `$${inputCostPerM.toFixed(2)}`,
-          output: isFree ? "FREE" : `$${outputCostPerM.toFixed(2)}`,
-          average: isFree ? "FREE" : `$${avgCost.toFixed(2)}/1M`
-        },
-        context: contextStr,
-        contextLength,
-        supportsTools: m.supports_function_calling || false,
-        supportsReasoning: m.supports_reasoning || false,
-        supportsVision: m.supports_vision || false,
-        isFree,
-        source: "LiteLLM"
-      };
-    });
-    mkdirSync4(cacheDir, { recursive: true });
-    const cacheData = {
-      timestamp: new Date().toISOString(),
-      models: transformedModels
-    };
-    writeFileSync4(cachePath, JSON.stringify(cacheData, null, 2), "utf-8");
-    return transformedModels;
-  } catch (error2) {
-    console.error(`Failed to fetch LiteLLM models: ${error2}`);
-    if (existsSync3(cachePath)) {
-      try {
-        const cacheData = JSON.parse(readFileSync2(cachePath, "utf-8"));
-        return cacheData.models;
-      } catch {
-        return [];
-      }
-    }
-    return [];
-  }
-}
-var __filename2, __dirname2, _cachedModelInfo = null, _cachedModelIds = null, _cachedRecommendedModels = null, RECOMMENDED_CACHE_PATH, RECOMMENDED_CACHE_MAX_AGE_HOURS = 12, _cachedOpenRouterModels = null, LITELLM_CACHE_MAX_AGE_HOURS = 24;
-var init_model_loader = __esm(() => {
-  __filename2 = fileURLToPath(import.meta.url);
-  __dirname2 = dirname(__filename2);
-  RECOMMENDED_CACHE_PATH = join4(homedir3(), ".claudish", "recommended-models-cache.json");
-});
-
 // src/providers/transport/openrouter.ts
 class OpenRouterProviderTransport {
   name = "openrouter";
@@ -17510,10 +17328,8 @@ class OpenRouterProviderTransport {
   streamFormat = "openai-sse";
   apiKey;
   queue;
-  modelId;
-  constructor(apiKey, modelId) {
+  constructor(apiKey, _modelId) {
     this.apiKey = apiKey;
-    this.modelId = modelId || "";
     this.queue = OpenRouterRequestQueue.getInstance();
   }
   overrideStreamFormat() {
@@ -17533,15 +17349,12 @@ class OpenRouterProviderTransport {
     return this.queue.enqueue(fetchFn);
   }
   getContextWindow() {
-    const models = this.modelId ? getCachedOpenRouterModels() : null;
-    const model = models?.find((m) => m.id === this.modelId);
-    return model?.context_length || model?.top_provider?.context_length || 0;
+    return 0;
   }
 }
 var OPENROUTER_API_URL = "https://openrouter.ai/api/v1/chat/completions";
 var init_openrouter = __esm(() => {
   init_openrouter_queue();
-  init_model_loader();
 });
 
 // src/adapters/tool-name-utils.ts
@@ -20945,9 +20758,9 @@ var init_middleware = __esm(() => {
 });
 
 // src/handlers/shared/token-tracker.ts
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join5 } from "path";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
 
 class TokenTracker {
   port;
@@ -21081,9 +20894,9 @@ class TokenTracker {
       if (this.quotaRemaining !== undefined) {
         data.quota_remaining = this.quotaRemaining;
       }
-      const claudishDir = join5(homedir4(), ".claudish");
-      mkdirSync5(claudishDir, { recursive: true });
-      writeFileSync5(join5(claudishDir, `tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
+      const claudishDir = join4(homedir3(), ".claudish");
+      mkdirSync4(claudishDir, { recursive: true });
+      writeFileSync4(join4(claudishDir, `tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
     } catch (e) {
       log(`[TokenTracker] Error writing token file: ${e}`);
     }
@@ -22037,21 +21850,21 @@ __export(exports_profile_config, {
   configExistsForScope: () => configExistsForScope,
   configExists: () => configExists
 });
-import { existsSync as existsSync4, mkdirSync as mkdirSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join6 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join5 } from "path";
 function ensureConfigDir() {
-  if (!existsSync4(CONFIG_DIR)) {
-    mkdirSync6(CONFIG_DIR, { recursive: true });
+  if (!existsSync3(CONFIG_DIR)) {
+    mkdirSync5(CONFIG_DIR, { recursive: true });
   }
 }
 function loadConfig() {
   ensureConfigDir();
-  if (!existsSync4(CONFIG_FILE)) {
+  if (!existsSync3(CONFIG_FILE)) {
     return { ...DEFAULT_CONFIG };
   }
   try {
-    const content = readFileSync3(CONFIG_FILE, "utf-8");
+    const content = readFileSync2(CONFIG_FILE, "utf-8");
     const config2 = JSON.parse(content);
     const merged = {
       version: config2.version || DEFAULT_CONFIG.version,
@@ -22084,31 +21897,31 @@ function loadConfig() {
 }
 function saveConfig(config2) {
   ensureConfigDir();
-  writeFileSync6(CONFIG_FILE, JSON.stringify(config2, null, 2), "utf-8");
+  writeFileSync5(CONFIG_FILE, JSON.stringify(config2, null, 2), "utf-8");
 }
 function configExists() {
-  return existsSync4(CONFIG_FILE);
+  return existsSync3(CONFIG_FILE);
 }
 function getConfigPath() {
   return CONFIG_FILE;
 }
 function getLocalConfigPath() {
-  return join6(process.cwd(), LOCAL_CONFIG_FILENAME);
+  return join5(process.cwd(), LOCAL_CONFIG_FILENAME);
 }
 function localConfigExists() {
-  return existsSync4(getLocalConfigPath());
+  return existsSync3(getLocalConfigPath());
 }
 function isProjectDirectory() {
   const cwd = process.cwd();
-  return [".git", "package.json", "Cargo.toml", "go.mod", "pyproject.toml", ".claudish.json"].some((f) => existsSync4(join6(cwd, f)));
+  return [".git", "package.json", "Cargo.toml", "go.mod", "pyproject.toml", ".claudish.json"].some((f) => existsSync3(join5(cwd, f)));
 }
 function loadLocalConfig() {
   const localPath = getLocalConfigPath();
-  if (!existsSync4(localPath)) {
+  if (!existsSync3(localPath)) {
     return null;
   }
   try {
-    const content = readFileSync3(localPath, "utf-8");
+    const content = readFileSync2(localPath, "utf-8");
     const config2 = JSON.parse(content);
     const local = {
       version: config2.version || DEFAULT_CONFIG.version,
@@ -22125,7 +21938,7 @@ function loadLocalConfig() {
   }
 }
 function saveLocalConfig(config2) {
-  writeFileSync6(getLocalConfigPath(), JSON.stringify(config2, null, 2), "utf-8");
+  writeFileSync5(getLocalConfigPath(), JSON.stringify(config2, null, 2), "utf-8");
 }
 function loadConfigForScope(scope) {
   if (scope === "local") {
@@ -22345,8 +22158,8 @@ function removeEndpoint(name) {
 }
 var CONFIG_DIR, CONFIG_FILE, LOCAL_CONFIG_FILENAME = ".claudish.json", DEFAULT_CONFIG;
 var init_profile_config = __esm(() => {
-  CONFIG_DIR = join6(homedir5(), ".claudish");
-  CONFIG_FILE = join6(CONFIG_DIR, "config.json");
+  CONFIG_DIR = join5(homedir4(), ".claudish");
+  CONFIG_FILE = join5(CONFIG_DIR, "config.json");
   DEFAULT_CONFIG = {
     version: "1.0.0",
     defaultProfile: "default",
@@ -22363,11 +22176,12 @@ var init_profile_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "6.13.2";
+var VERSION = "6.14.0";
 
 // src/telemetry.ts
 var exports_telemetry = {};
 __export(exports_telemetry, {
+  setClaudeCodeRunning: () => setClaudeCodeRunning,
   sanitizeModelId: () => sanitizeModelId,
   sanitizeMessage: () => sanitizeMessage,
   runConsentPrompt: () => runConsentPrompt,
@@ -22577,6 +22391,8 @@ async function sendReport(report) {
 function showConsentPromptAsync(ctx) {
   if (consentPromptActive)
     return;
+  if (claudeCodeRunning)
+    return;
   try {
     const profileConfig = loadConfig();
     if (profileConfig.telemetry?.askedAt !== undefined)
@@ -22650,9 +22466,12 @@ function initTelemetry(config2) {
   claudishVersion = getVersion();
   installMethod = detectInstallMethod();
 }
+function setClaudeCodeRunning(running) {
+  claudeCodeRunning = running;
+}
 function reportError2(ctx) {
   if (!initialized || !consentEnabled) {
-    if (initialized && !consentEnabled && ctx.isInteractive && process.stderr.isTTY) {
+    if (initialized && !consentEnabled && ctx.isInteractive && process.stderr.isTTY && !claudeCodeRunning) {
       showConsentPromptAsync(ctx);
     }
     return;
@@ -22755,7 +22574,7 @@ Usage: claudish telemetry on|off|status|reset
       process.exit(1);
   }
 }
-var TELEMETRY_ENDPOINT = "https://claudish.com/v1/report", MAX_REPORT_BYTES = 4096, KNOWN_PUBLIC_HOSTS, PUBLIC_PROVIDERS, consentEnabled = false, sessionId = "", initialized = false, claudishVersion = "", installMethod = "unknown", consentPromptActive = false;
+var TELEMETRY_ENDPOINT = "https://claudish.com/v1/report", MAX_REPORT_BYTES = 4096, KNOWN_PUBLIC_HOSTS, PUBLIC_PROVIDERS, consentEnabled = false, sessionId = "", initialized = false, claudishVersion = "", installMethod = "unknown", consentPromptActive = false, claudeCodeRunning = false;
 var init_telemetry = __esm(() => {
   init_profile_config();
   init_logger();
@@ -22787,9 +22606,9 @@ var init_telemetry = __esm(() => {
 });
 
 // src/providers/provider-definitions.ts
-import { existsSync as existsSync5 } from "fs";
-import { join as join7 } from "path";
-import { homedir as homedir6 } from "os";
+import { existsSync as existsSync4 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir5 } from "os";
 function ensureProviderByNameCache() {
   if (!_providerByNameCache) {
     _providerByNameCache = new Map;
@@ -22929,7 +22748,7 @@ function isProviderAvailable(def) {
   }
   if (def.oauthFallback) {
     try {
-      if (existsSync5(join7(homedir6(), ".claudish", def.oauthFallback)))
+      if (existsSync4(join6(homedir5(), ".claudish", def.oauthFallback)))
         return true;
     } catch {}
   }
@@ -23548,25 +23367,25 @@ var init_model_parser = __esm(() => {
 
 // src/stats-buffer.ts
 import {
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync7,
-  readFileSync as readFileSync4,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync3,
   renameSync,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync6
 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join8 } from "path";
+import { homedir as homedir6 } from "os";
+import { join as join7 } from "path";
 function ensureDir() {
-  if (!existsSync6(CLAUDISH_DIR)) {
-    mkdirSync7(CLAUDISH_DIR, { recursive: true });
+  if (!existsSync5(CLAUDISH_DIR)) {
+    mkdirSync6(CLAUDISH_DIR, { recursive: true });
   }
 }
 function readFromDisk() {
   try {
-    if (!existsSync6(BUFFER_FILE))
+    if (!existsSync5(BUFFER_FILE))
       return [];
-    const raw2 = readFileSync4(BUFFER_FILE, "utf-8");
+    const raw2 = readFileSync3(BUFFER_FILE, "utf-8");
     const parsed = JSON.parse(raw2);
     if (!Array.isArray(parsed.events))
       return [];
@@ -23590,8 +23409,8 @@ function writeToDisk(events) {
     ensureDir();
     const trimmed = enforceSizeCap([...events]);
     const payload = { version: 1, events: trimmed };
-    const tmpFile = join8(CLAUDISH_DIR, `stats-buffer.tmp.${process.pid}.json`);
-    writeFileSync7(tmpFile, JSON.stringify(payload, null, 2), "utf-8");
+    const tmpFile = join7(CLAUDISH_DIR, `stats-buffer.tmp.${process.pid}.json`);
+    writeFileSync6(tmpFile, JSON.stringify(payload, null, 2), "utf-8");
     renameSync(tmpFile, BUFFER_FILE);
     memoryCache = trimmed;
   } catch {}
@@ -23635,7 +23454,7 @@ function clearBuffer() {
   try {
     memoryCache = [];
     eventsSinceLastFlush = 0;
-    if (existsSync6(BUFFER_FILE)) {
+    if (existsSync5(BUFFER_FILE)) {
       unlinkSync2(BUFFER_FILE);
     }
   } catch {}
@@ -23664,8 +23483,8 @@ function syncFlushOnExit() {
 var BUFFER_MAX_BYTES, CLAUDISH_DIR, BUFFER_FILE, memoryCache = null, eventsSinceLastFlush = 0, lastFlushTime, flushScheduled = false;
 var init_stats_buffer = __esm(() => {
   BUFFER_MAX_BYTES = 64 * 1024;
-  CLAUDISH_DIR = join8(homedir7(), ".claudish");
-  BUFFER_FILE = join8(CLAUDISH_DIR, "stats-buffer.json");
+  CLAUDISH_DIR = join7(homedir6(), ".claudish");
+  BUFFER_FILE = join7(CLAUDISH_DIR, "stats-buffer.json");
   lastFlushTime = Date.now();
   process.on("exit", syncFlushOnExit);
   process.on("SIGTERM", () => {
@@ -24863,18 +24682,18 @@ var init_remote_provider_registry = __esm(() => {
 });
 
 // src/auth/oauth-registry.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
-import { join as join9 } from "path";
-import { homedir as homedir8 } from "os";
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir7 } from "os";
 function hasValidOAuthCredentials(descriptor) {
-  const credPath = join9(homedir8(), ".claudish", descriptor.credentialFile);
-  if (!existsSync7(credPath))
+  const credPath = join8(homedir7(), ".claudish", descriptor.credentialFile);
+  if (!existsSync6(credPath))
     return false;
   if (descriptor.validationMode === "file-exists") {
     return true;
   }
   try {
-    const data = JSON.parse(readFileSync5(credPath, "utf-8"));
+    const data = JSON.parse(readFileSync4(credPath, "utf-8"));
     if (!data.access_token)
       return false;
     if (data.refresh_token)
@@ -24962,15 +24781,15 @@ var init_static_fallback = __esm(() => {
 });
 
 // src/providers/all-models-cache.ts
-import { readFileSync as readFileSync6, existsSync as existsSync8, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8 } from "fs";
-import { join as join10, dirname as dirname2 } from "path";
-import { homedir as homedir9 } from "os";
+import { readFileSync as readFileSync5, existsSync as existsSync7, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
+import { join as join9, dirname } from "path";
+import { homedir as homedir8 } from "os";
 function readAllModelsCache(path = ALL_MODELS_CACHE_PATH) {
-  if (!existsSync8(path))
+  if (!existsSync7(path))
     return null;
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync6(path, "utf-8"));
+    raw2 = JSON.parse(readFileSync5(path, "utf-8"));
   } catch {
     return null;
   }
@@ -24995,12 +24814,12 @@ function writeAllModelsCache(data, path = ALL_MODELS_CACHE_PATH) {
     entries: data.entries ?? existing?.entries ?? [],
     models: data.models ?? existing?.models ?? []
   };
-  mkdirSync8(dirname2(path), { recursive: true });
-  writeFileSync8(path, JSON.stringify(merged), "utf-8");
+  mkdirSync7(dirname(path), { recursive: true });
+  writeFileSync7(path, JSON.stringify(merged), "utf-8");
 }
 var ALL_MODELS_CACHE_PATH;
 var init_all_models_cache = __esm(() => {
-  ALL_MODELS_CACHE_PATH = join10(homedir9(), ".claudish", "all-models.json");
+  ALL_MODELS_CACHE_PATH = join9(homedir8(), ".claudish", "all-models.json");
 });
 
 // src/providers/catalog-resolvers/openrouter.ts
@@ -25139,16 +24958,16 @@ var init_openrouter2 = __esm(() => {
 });
 
 // src/providers/catalog-resolvers/litellm.ts
-import { readFileSync as readFileSync7, existsSync as existsSync9 } from "fs";
-import { join as join11 } from "path";
-import { homedir as homedir10 } from "os";
-import { createHash as createHash2 } from "crypto";
+import { readFileSync as readFileSync6, existsSync as existsSync8 } from "fs";
+import { join as join10 } from "path";
+import { homedir as homedir9 } from "os";
+import { createHash } from "crypto";
 function getCachePath() {
   const baseUrl = process.env.LITELLM_BASE_URL;
   if (!baseUrl)
     return null;
-  const hash = createHash2("sha256").update(baseUrl).digest("hex").substring(0, 16);
-  return join11(homedir10(), ".claudish", `litellm-models-${hash}.json`);
+  const hash = createHash("sha256").update(baseUrl).digest("hex").substring(0, 16);
+  return join10(homedir9(), ".claudish", `litellm-models-${hash}.json`);
 }
 
 class LiteLLMCatalogResolver {
@@ -25176,10 +24995,10 @@ class LiteLLMCatalogResolver {
   }
   async warmCache() {
     const path = getCachePath();
-    if (!path || !existsSync9(path))
+    if (!path || !existsSync8(path))
       return;
     try {
-      const data = JSON.parse(readFileSync7(path, "utf-8"));
+      const data = JSON.parse(readFileSync6(path, "utf-8"));
       if (Array.isArray(data.models)) {
         _memCache2 = data.models.map((m) => m.name ?? m.id?.replace("litellm@", "") ?? "");
       }
@@ -25196,10 +25015,10 @@ class LiteLLMCatalogResolver {
     if (_memCache2)
       return _memCache2;
     const path = getCachePath();
-    if (!path || !existsSync9(path))
+    if (!path || !existsSync8(path))
       return null;
     try {
-      const data = JSON.parse(readFileSync7(path, "utf-8"));
+      const data = JSON.parse(readFileSync6(path, "utf-8"));
       if (Array.isArray(data.models)) {
         _memCache2 = data.models.map((m) => m.name ?? m.id?.replace("litellm@", "") ?? "");
         return _memCache2;
@@ -25264,17 +25083,17 @@ var init_model_catalog_resolver = __esm(() => {
 });
 
 // src/providers/auto-route.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
-import { join as join12 } from "path";
-import { homedir as homedir11 } from "os";
-import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+import { join as join11 } from "path";
+import { homedir as homedir10 } from "os";
+import { createHash as createHash2 } from "crypto";
 function readLiteLLMCacheSync(baseUrl) {
-  const hash = createHash3("sha256").update(baseUrl).digest("hex").substring(0, 16);
-  const cachePath = join12(homedir11(), ".claudish", `litellm-models-${hash}.json`);
-  if (!existsSync10(cachePath))
+  const hash = createHash2("sha256").update(baseUrl).digest("hex").substring(0, 16);
+  const cachePath = join11(homedir10(), ".claudish", `litellm-models-${hash}.json`);
+  if (!existsSync9(cachePath))
     return null;
   try {
-    const data = JSON.parse(readFileSync8(cachePath, "utf-8"));
+    const data = JSON.parse(readFileSync7(cachePath, "utf-8"));
     if (!Array.isArray(data.models))
       return null;
     return data.models;
@@ -25395,17 +25214,17 @@ async function warmZenModelCache() {
   const models = (data.data ?? []).map((m) => ({ id: m.id }));
   if (models.length === 0)
     return;
-  const cacheDir = join12(homedir11(), ".claudish");
-  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() }));
+  const cacheDir = join11(homedir10(), ".claudish");
+  const { mkdirSync: mkdirSync8, writeFileSync: writeSync } = await import("fs");
+  mkdirSync8(cacheDir, { recursive: true });
+  writeSync(join11(cacheDir, "zen-models.json"), JSON.stringify({ models, fetchedAt: new Date().toISOString() }));
 }
 function readZenGoModelCacheSync() {
-  const cachePath = join12(homedir11(), ".claudish", "zen-go-models.json");
-  if (!existsSync10(cachePath))
+  const cachePath = join11(homedir10(), ".claudish", "zen-go-models.json");
+  if (!existsSync9(cachePath))
     return null;
   try {
-    const data = JSON.parse(readFileSync8(cachePath, "utf-8"));
+    const data = JSON.parse(readFileSync7(cachePath, "utf-8"));
     if (!Array.isArray(data.models))
       return null;
     return new Set(data.models.map((m) => m.id));
@@ -25432,10 +25251,10 @@ async function warmZenGoModelCache() {
   const models = (data.data ?? []).map((m) => ({ id: m.id }));
   if (models.length === 0)
     return;
-  const cacheDir = join12(homedir11(), ".claudish");
-  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() }));
+  const cacheDir = join11(homedir10(), ".claudish");
+  const { mkdirSync: mkdirSync8, writeFileSync: writeSync } = await import("fs");
+  mkdirSync8(cacheDir, { recursive: true });
+  writeSync(join11(cacheDir, "zen-go-models.json"), JSON.stringify({ models, fetchedAt: new Date().toISOString() }));
 }
 function hasProviderCredentials(provider) {
   const keyInfo = getApiKeyEnvVars(provider);
@@ -25572,9 +25391,9 @@ __export(exports_provider_resolver, {
   getMissingKeyResolutions: () => getMissingKeyResolutions,
   getMissingKeyError: () => getMissingKeyError
 });
-import { existsSync as existsSync11 } from "fs";
-import { join as join13 } from "path";
-import { homedir as homedir12 } from "os";
+import { existsSync as existsSync10 } from "fs";
+import { join as join12 } from "path";
+import { homedir as homedir11 } from "os";
 function getApiKeyInfoForProvider(providerName) {
   const lookupName = providerName === "gemini" ? "google" : providerName;
   const info = getApiKeyInfo(lookupName);
@@ -25609,8 +25428,8 @@ function isApiKeyAvailable(info) {
   }
   if (info.oauthFallback) {
     try {
-      const credPath = join13(homedir12(), ".claudish", info.oauthFallback);
-      if (existsSync11(credPath)) {
+      const credPath = join12(homedir11(), ".claudish", info.oauthFallback);
+      if (existsSync10(credPath)) {
         return true;
       }
     } catch {}
@@ -25911,9 +25730,9 @@ var init_provider_resolver = __esm(() => {
 });
 
 // src/services/pricing-cache.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync9, existsSync as existsSync12, mkdirSync as mkdirSync9, statSync } from "fs";
-import { homedir as homedir13 } from "os";
-import { join as join14 } from "path";
+import { readFileSync as readFileSync8, existsSync as existsSync11, statSync } from "fs";
+import { homedir as homedir12 } from "os";
+import { join as join13 } from "path";
 function getDynamicPricingSync(provider, modelName) {
   if (provider === "openrouter") {
     const direct = pricingMap.get(modelName);
@@ -25954,36 +25773,21 @@ async function warmPricingCache() {
     const diskFresh = loadDiskCache();
     if (diskFresh) {
       log("[PricingCache] Loaded pricing from disk cache");
-      return;
-    }
-    log("[PricingCache] Disk cache stale or missing, fetching from OpenRouter API...");
-    const models = await ensureOpenRouterModelsLoaded();
-    if (models.length === 0) {
-      const cached2 = getCachedOpenRouterModels();
-      if (cached2 && cached2.length > 0) {
-        populateFromOpenRouterModels(cached2);
-        saveDiskCache();
-        log(`[PricingCache] Populated from existing model-loader cache (${pricingMap.size} models)`);
-        return;
-      }
-      log("[PricingCache] No models available, will use provider defaults");
-      return;
+    } else {
+      log("[PricingCache] Disk cache stale or missing, using provider defaults");
     }
-    populateFromOpenRouterModels(models);
-    saveDiskCache();
-    log(`[PricingCache] Fetched and cached pricing for ${pricingMap.size} models`);
   } catch (error2) {
     log(`[PricingCache] Error warming cache: ${error2}`);
   }
 }
 function loadDiskCache() {
   try {
-    if (!existsSync12(CACHE_FILE))
+    if (!existsSync11(CACHE_FILE))
       return false;
     const stat = statSync(CACHE_FILE);
     const age = Date.now() - stat.mtimeMs;
     const isFresh = age < CACHE_TTL_MS;
-    const raw2 = readFileSync9(CACHE_FILE, "utf-8");
+    const raw2 = readFileSync8(CACHE_FILE, "utf-8");
     const data = JSON.parse(raw2);
     for (const [key, pricing] of Object.entries(data)) {
       pricingMap.set(key, pricing);
@@ -25993,45 +25797,13 @@ function loadDiskCache() {
     return false;
   }
 }
-function saveDiskCache() {
-  try {
-    mkdirSync9(CACHE_DIR, { recursive: true });
-    const data = {};
-    for (const [key, pricing] of pricingMap) {
-      data[key] = pricing;
-    }
-    writeFileSync9(CACHE_FILE, JSON.stringify(data), "utf-8");
-  } catch (error2) {
-    log(`[PricingCache] Error saving disk cache: ${error2}`);
-  }
-}
-function populateFromOpenRouterModels(models) {
-  for (const model of models) {
-    if (!model.id || !model.pricing)
-      continue;
-    const promptPrice = parseFloat(model.pricing.prompt || "0");
-    const completionPrice = parseFloat(model.pricing.completion || "0");
-    if (isNaN(promptPrice) || isNaN(completionPrice))
-      continue;
-    const inputCostPer1M = promptPrice * 1e6;
-    const outputCostPer1M = completionPrice * 1e6;
-    const isFree = inputCostPer1M === 0 && outputCostPer1M === 0;
-    pricingMap.set(model.id, {
-      inputCostPer1M,
-      outputCostPer1M,
-      isEstimate: true,
-      ...isFree ? { isFree: true } : {}
-    });
-  }
-}
 var pricingMap, CACHE_DIR, CACHE_FILE, CACHE_TTL_MS, cacheWarmed = false, PROVIDER_TO_OR_PREFIX;
 var init_pricing_cache = __esm(() => {
   init_logger();
-  init_model_loader();
   init_remote_provider_types();
   pricingMap = new Map;
-  CACHE_DIR = join14(homedir13(), ".claudish");
-  CACHE_FILE = join14(CACHE_DIR, "pricing-cache.json");
+  CACHE_DIR = join13(homedir12(), ".claudish");
+  CACHE_FILE = join13(CACHE_DIR, "pricing-cache.json");
   CACHE_TTL_MS = 24 * 60 * 60 * 1000;
   PROVIDER_TO_OR_PREFIX = {
     openai: ["openai/"],
@@ -26049,6 +25821,358 @@ var init_pricing_cache = __esm(() => {
   };
 });
 
+// src/model-loader.ts
+import { readFileSync as readFileSync9, existsSync as existsSync12, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8 } from "fs";
+import { join as join14, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+import { homedir as homedir13 } from "os";
+import { createHash as createHash3 } from "crypto";
+function getBundledRecommendedModelsPath() {
+  return join14(__dirname2, "../recommended-models.json");
+}
+function groupRecommendedModels(entries) {
+  const byId = new Map;
+  for (const entry of entries) {
+    const list = byId.get(entry.id);
+    if (list)
+      list.push(entry);
+    else
+      byId.set(entry.id, [entry]);
+  }
+  const flagship = [];
+  const fast = [];
+  for (const [id, members] of byId.entries()) {
+    const primary = members.find((m) => m.category !== "subscription") ?? members[0];
+    const subscriptions = members.filter((m) => m.category === "subscription");
+    const bucket = primary.category === "programming" || primary.category === "vision" || primary.category === "reasoning" ? "flagship" : "fast";
+    const group = { id, primary, subscriptions, bucket };
+    if (bucket === "flagship")
+      flagship.push(group);
+    else
+      fast.push(group);
+  }
+  return { flagship, fast };
+}
+function collectRoutingPrefixes(group, getNativePrefix) {
+  const slug = (group.primary.provider || "").toLowerCase();
+  const native = getNativePrefix(slug);
+  const seen = new Set;
+  const out = [];
+  if (native) {
+    out.push(native);
+    seen.add(native);
+  }
+  for (const sub of group.subscriptions) {
+    const p = sub.subscription?.prefix;
+    if (!p || seen.has(p))
+      continue;
+    seen.add(p);
+    out.push(p);
+  }
+  return out;
+}
+function parsePriceAvg(s) {
+  if (!s || s === "N/A")
+    return Infinity;
+  if (s === "FREE")
+    return 0;
+  const m = s.match(/\$([\d.]+)/);
+  return m ? parseFloat(m[1]) : Infinity;
+}
+function parseCtx(s) {
+  if (!s || s === "N/A")
+    return 0;
+  const upper = s.toUpperCase();
+  if (upper.includes("M"))
+    return parseFloat(upper) * 1e6;
+  if (upper.includes("K"))
+    return parseFloat(upper) * 1000;
+  return parseInt(s, 10) || 0;
+}
+function normalizePricingDisplay(raw2) {
+  const pricing = raw2 || "N/A";
+  if (pricing.includes("-1000000"))
+    return "varies";
+  if (pricing === "$0.00/1M" || pricing === "FREE")
+    return "FREE";
+  return pricing;
+}
+function computeQuickPicks(primaries) {
+  if (primaries.length === 0) {
+    return {
+      budget: null,
+      largeContext: null,
+      mostCapable: null,
+      visionCoding: null,
+      agentic: null
+    };
+  }
+  const priced = primaries.filter((m) => {
+    const p = parsePriceAvg(m.pricing?.average);
+    return p > 0 && p !== Infinity;
+  }).sort((a, b) => parsePriceAvg(a.pricing?.average) - parsePriceAvg(b.pricing?.average));
+  const budget = priced[0] ?? null;
+  const byCtx = [...primaries].sort((a, b) => parseCtx(b.context) - parseCtx(a.context));
+  const largeContext = byCtx[0] ?? null;
+  const byPrice = [...primaries].sort((a, b) => parsePriceAvg(b.pricing?.average) - parsePriceAvg(a.pricing?.average));
+  const mostCapable = byPrice.find((m) => parsePriceAvg(m.pricing?.average) !== Infinity) ?? null;
+  const visionCoding = primaries.find((m) => m.supportsVision === true && m.id !== budget?.id && m.id !== mostCapable?.id) ?? null;
+  const agentic = primaries.find((m) => m.supportsReasoning === true && m.id !== mostCapable?.id) ?? null;
+  return { budget, largeContext, mostCapable, visionCoding, agentic };
+}
+async function getRecommendedModels(opts = {}) {
+  const { forceRefresh = false } = opts;
+  if (!forceRefresh && _cachedRecommendedModels) {
+    return _cachedRecommendedModels;
+  }
+  if (!forceRefresh && existsSync12(RECOMMENDED_MODELS_CACHE_PATH)) {
+    try {
+      const cacheData = JSON.parse(readFileSync9(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
+      if (cacheData.models && cacheData.models.length > 0 && isFreshEnough(cacheData)) {
+        _cachedRecommendedModels = cacheData;
+        return cacheData;
+      }
+    } catch {}
+  }
+  try {
+    const response = await fetch(FIREBASE_RECOMMENDED_URL, {
+      signal: AbortSignal.timeout(RECOMMENDED_FETCH_TIMEOUT_MS)
+    });
+    if (response.ok) {
+      const data = await response.json();
+      if (data.models && data.models.length > 0) {
+        _cachedRecommendedModels = data;
+        try {
+          const cacheDir = join14(homedir13(), ".claudish");
+          mkdirSync8(cacheDir, { recursive: true });
+          writeFileSync8(RECOMMENDED_MODELS_CACHE_PATH, JSON.stringify(data), "utf-8");
+        } catch {}
+        return data;
+      }
+    }
+  } catch {}
+  return loadBundledRecommendedModels();
+}
+function getRecommendedModelsSync() {
+  if (_cachedRecommendedModels)
+    return _cachedRecommendedModels;
+  if (existsSync12(RECOMMENDED_MODELS_CACHE_PATH)) {
+    try {
+      const cacheData = JSON.parse(readFileSync9(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
+      if (cacheData.models && cacheData.models.length > 0) {
+        _cachedRecommendedModels = cacheData;
+        return cacheData;
+      }
+    } catch {}
+  }
+  return loadBundledRecommendedModels();
+}
+async function warmRecommendedModels() {
+  try {
+    return await getRecommendedModels({ forceRefresh: true });
+  } catch {
+    return null;
+  }
+}
+function isFreshEnough(doc2) {
+  const generatedAt = doc2.generatedAt;
+  if (!generatedAt)
+    return true;
+  const ageHours = (Date.now() - new Date(generatedAt).getTime()) / (1000 * 60 * 60);
+  return ageHours <= RECOMMENDED_CACHE_MAX_AGE_HOURS;
+}
+function loadBundledRecommendedModels() {
+  const jsonPath = getBundledRecommendedModelsPath();
+  if (!existsSync12(jsonPath)) {
+    throw new Error(`recommended-models.json not found at ${jsonPath}. ` + `Run 'claudish --top-models --force-update' to refresh from Firebase.`);
+  }
+  try {
+    const doc2 = JSON.parse(readFileSync9(jsonPath, "utf-8"));
+    _cachedRecommendedModels = doc2;
+    return doc2;
+  } catch (error2) {
+    throw new Error(`Failed to parse bundled recommended-models.json: ${error2}`);
+  }
+}
+async function searchModels(query, limit = 50) {
+  const url = `${FIREBASE_BASE_URL}?search=${encodeURIComponent(query)}&limit=${limit}&status=active`;
+  const response = await fetch(url, {
+    signal: AbortSignal.timeout(SEARCH_FETCH_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    throw new Error(`Firebase search returned ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  return data.models ?? [];
+}
+async function getTop100Models() {
+  const url = `${FIREBASE_BASE_URL}?catalog=top100`;
+  const response = await fetch(url, {
+    signal: AbortSignal.timeout(SEARCH_FETCH_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    throw new Error(`Firebase top100 fetch failed: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  return data;
+}
+async function getProviderList() {
+  const url = `${FIREBASE_BASE_URL}?catalog=providers`;
+  const response = await fetch(url, {
+    signal: AbortSignal.timeout(SEARCH_FETCH_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    throw new Error(`Firebase providers fetch failed: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  return data.providers ?? [];
+}
+async function getModelsByProvider(provider, limit = 200) {
+  const url = `${FIREBASE_BASE_URL}?provider=${encodeURIComponent(provider)}&status=active&limit=${limit}`;
+  const response = await fetch(url, {
+    signal: AbortSignal.timeout(SEARCH_FETCH_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    throw new Error(`Firebase provider query returned ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  if (Array.isArray(data))
+    return data;
+  return data.models ?? [];
+}
+function loadModelInfo() {
+  if (_cachedModelInfo) {
+    return _cachedModelInfo;
+  }
+  const data = getRecommendedModelsSync();
+  const modelInfo = {};
+  for (const model of data.models) {
+    modelInfo[model.id] = {
+      name: model.name,
+      description: model.description,
+      priority: model.priority,
+      provider: model.provider
+    };
+  }
+  modelInfo.custom = {
+    name: "Custom Model",
+    description: "Enter any model ID manually",
+    priority: 999,
+    provider: "Custom"
+  };
+  _cachedModelInfo = modelInfo;
+  return modelInfo;
+}
+function getAvailableModels() {
+  if (_cachedModelIds) {
+    return _cachedModelIds;
+  }
+  const data = getRecommendedModelsSync();
+  const modelIds = data.models.sort((a, b) => a.priority - b.priority).map((m) => m.id);
+  const result = [...modelIds, "custom"];
+  _cachedModelIds = result;
+  return result;
+}
+async function fetchLiteLLMModels(baseUrl, apiKey, forceUpdate = false) {
+  const hash = createHash3("sha256").update(baseUrl).digest("hex").substring(0, 16);
+  const cacheDir = join14(homedir13(), ".claudish");
+  const cachePath = join14(cacheDir, `litellm-models-${hash}.json`);
+  if (!forceUpdate && existsSync12(cachePath)) {
+    try {
+      const cacheData = JSON.parse(readFileSync9(cachePath, "utf-8"));
+      const timestamp = new Date(cacheData.timestamp);
+      const now = new Date;
+      const ageInHours = (now.getTime() - timestamp.getTime()) / (1000 * 60 * 60);
+      if (ageInHours < LITELLM_CACHE_MAX_AGE_HOURS) {
+        return cacheData.models;
+      }
+    } catch {}
+  }
+  try {
+    const url = `${baseUrl.replace(/\/$/, "")}/model_group/info`;
+    const response = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      console.error(`Failed to fetch LiteLLM models: ${response.status} ${response.statusText}`);
+      if (existsSync12(cachePath)) {
+        try {
+          const cacheData2 = JSON.parse(readFileSync9(cachePath, "utf-8"));
+          return cacheData2.models;
+        } catch {
+          return [];
+        }
+      }
+      return [];
+    }
+    const responseData = await response.json();
+    const rawModels = Array.isArray(responseData) ? responseData : responseData.data || [];
+    const transformedModels = rawModels.filter((m) => m.mode === "chat" && m.supports_function_calling).map((m) => {
+      const inputCostPerM = (m.input_cost_per_token || 0) * 1e6;
+      const outputCostPerM = (m.output_cost_per_token || 0) * 1e6;
+      const avgCost = (inputCostPerM + outputCostPerM) / 2;
+      const isFree = inputCostPerM === 0 && outputCostPerM === 0;
+      const contextLength = m.max_input_tokens || 128000;
+      const contextStr = contextLength >= 1e6 ? `${Math.round(contextLength / 1e6)}M` : `${Math.round(contextLength / 1000)}K`;
+      return {
+        id: `litellm@${m.model_group}`,
+        name: m.model_group,
+        description: `LiteLLM model (providers: ${m.providers.join(", ")})`,
+        provider: "LiteLLM",
+        pricing: {
+          input: isFree ? "FREE" : `$${inputCostPerM.toFixed(2)}`,
+          output: isFree ? "FREE" : `$${outputCostPerM.toFixed(2)}`,
+          average: isFree ? "FREE" : `$${avgCost.toFixed(2)}/1M`
+        },
+        context: contextStr,
+        contextLength,
+        supportsTools: m.supports_function_calling || false,
+        supportsReasoning: m.supports_reasoning || false,
+        supportsVision: m.supports_vision || false,
+        isFree,
+        source: "LiteLLM"
+      };
+    });
+    mkdirSync8(cacheDir, { recursive: true });
+    const cacheData = {
+      timestamp: new Date().toISOString(),
+      models: transformedModels
+    };
+    writeFileSync8(cachePath, JSON.stringify(cacheData, null, 2), "utf-8");
+    return transformedModels;
+  } catch (error2) {
+    console.error(`Failed to fetch LiteLLM models: ${error2}`);
+    if (existsSync12(cachePath)) {
+      try {
+        const cacheData = JSON.parse(readFileSync9(cachePath, "utf-8"));
+        return cacheData.models;
+      } catch {
+        return [];
+      }
+    }
+    return [];
+  }
+}
+var __filename2, __dirname2, _cachedModelInfo = null, _cachedModelIds = null, _cachedRecommendedModels = null, FIREBASE_BASE_URL = "https://us-central1-claudish-6da10.cloudfunctions.net/queryModels", FIREBASE_RECOMMENDED_URL, RECOMMENDED_MODELS_CACHE_PATH, RECOMMENDED_CACHE_MAX_AGE_HOURS = 12, RECOMMENDED_FETCH_TIMEOUT_MS = 5000, SEARCH_FETCH_TIMEOUT_MS = 1e4, FIREBASE_SLUG_TO_PROVIDER_NAME, LITELLM_CACHE_MAX_AGE_HOURS = 24;
+var init_model_loader = __esm(() => {
+  __filename2 = fileURLToPath(import.meta.url);
+  __dirname2 = dirname2(__filename2);
+  FIREBASE_RECOMMENDED_URL = `${FIREBASE_BASE_URL}?catalog=recommended`;
+  RECOMMENDED_MODELS_CACHE_PATH = join14(homedir13(), ".claudish", "recommended-models-cache.json");
+  FIREBASE_SLUG_TO_PROVIDER_NAME = {
+    openai: "openai",
+    google: "google",
+    "x-ai": "xai",
+    "z-ai": "zai",
+    moonshotai: "kimi",
+    minimax: "minimax",
+    qwen: "qwen"
+  };
+});
+
 // src/handlers/fallback-handler.ts
 class FallbackHandler {
   candidates;
@@ -26567,8 +26691,8 @@ Details: ${e.message}`);
     const credPath = this.getCredentialsPath();
     const claudishDir = join15(homedir14(), ".claudish");
     if (!existsSync13(claudishDir)) {
-      const { mkdirSync: mkdirSync10 } = __require("fs");
-      mkdirSync10(claudishDir, { recursive: true });
+      const { mkdirSync: mkdirSync9 } = __require("fs");
+      mkdirSync9(claudishDir, { recursive: true });
     }
     const fd = openSync(credPath, "w", 384);
     try {
@@ -27414,8 +27538,8 @@ Details: ${e.message}`);
     const credPath = this.getCredentialsPath();
     const claudishDir = join16(homedir15(), ".claudish");
     if (!existsSync14(claudishDir)) {
-      const { mkdirSync: mkdirSync10 } = __require("fs");
-      mkdirSync10(claudishDir, { recursive: true });
+      const { mkdirSync: mkdirSync9 } = __require("fs");
+      mkdirSync9(claudishDir, { recursive: true });
     }
     const fd = openSync2(credPath, "w", 384);
     try {
@@ -27717,8 +27841,8 @@ class KimiOAuth {
     const deviceIdPath = this.getDeviceIdPath();
     const claudishDir = join18(homedir17(), ".claudish");
     if (!existsSync16(claudishDir)) {
-      const { mkdirSync: mkdirSync10 } = __require("fs");
-      mkdirSync10(claudishDir, { recursive: true });
+      const { mkdirSync: mkdirSync9 } = __require("fs");
+      mkdirSync9(claudishDir, { recursive: true });
     }
     if (existsSync16(deviceIdPath)) {
       try {
@@ -27996,8 +28120,8 @@ Waiting for authorization...`);
     const credPath = this.getCredentialsPath();
     const claudishDir = join18(homedir17(), ".claudish");
     if (!existsSync16(claudishDir)) {
-      const { mkdirSync: mkdirSync10 } = __require("fs");
-      mkdirSync10(claudishDir, { recursive: true });
+      const { mkdirSync: mkdirSync9 } = __require("fs");
+      mkdirSync9(claudishDir, { recursive: true });
     }
     const fd = openSync3(credPath, "w", 384);
     try {
@@ -29338,6 +29462,7 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
     port = actualPort;
   log(`[Proxy] Server started on port ${port}`);
   warmPricingCache().catch(() => {});
+  warmRecommendedModels().catch(() => {});
   const catalogProvidersToWarm = ["openrouter"];
   if (process.env.LITELLM_BASE_URL)
     catalogProvidersToWarm.push("litellm");
@@ -29346,7 +29471,7 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
     port,
     url: `http://127.0.0.1:${port}`,
     shutdown: async () => {
-      return new Promise((resolve3) => server.close((e) => resolve3()));
+      return new Promise((resolve3) => server.close(() => resolve3()));
     }
   };
 }
@@ -29415,47 +29540,10 @@ __export(exports_mcp_server, {
   runPromptViaProxy: () => runPromptViaProxy,
   parseAnthropicSse: () => parseAnthropicSse
 });
-import { readFileSync as readFileSync18, existsSync as existsSync21, writeFileSync as writeFileSync10, mkdirSync as mkdirSync10, readdirSync as readdirSync3 } from "fs";
+import { readFileSync as readFileSync18, existsSync as existsSync21, writeFileSync as writeFileSync9, mkdirSync as mkdirSync9, readdirSync as readdirSync3 } from "fs";
 import { join as join23, dirname as dirname3 } from "path";
 import { homedir as homedir22 } from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
-function loadRecommendedModels() {
-  const cachedPath = join23(CLAUDISH_CACHE_DIR, "recommended-models-cache.json");
-  if (existsSync21(cachedPath)) {
-    try {
-      const data = JSON.parse(readFileSync18(cachedPath, "utf-8"));
-      if (data.models && data.models.length > 0)
-        return data.models;
-    } catch {}
-  }
-  if (existsSync21(RECOMMENDED_MODELS_PATH)) {
-    try {
-      const data = JSON.parse(readFileSync18(RECOMMENDED_MODELS_PATH, "utf-8"));
-      return data.models || [];
-    } catch {
-      return [];
-    }
-  }
-  return [];
-}
-function parsePriceAvg(s) {
-  if (!s || s === "N/A")
-    return Infinity;
-  if (s === "FREE")
-    return 0;
-  const m = s.match(/\$([\d.]+)/);
-  return m ? parseFloat(m[1]) : Infinity;
-}
-function parseCtx(s) {
-  if (!s || s === "N/A")
-    return 0;
-  const upper = s.toUpperCase();
-  if (upper.includes("M"))
-    return parseFloat(upper) * 1e6;
-  if (upper.includes("K"))
-    return parseFloat(upper) * 1000;
-  return parseInt(s) || 0;
-}
 async function loadAllModels(forceRefresh = false) {
   if (!forceRefresh && existsSync21(ALL_MODELS_CACHE_PATH2)) {
     try {
@@ -29473,8 +29561,8 @@ async function loadAllModels(forceRefresh = false) {
       throw new Error(`API returned ${response.status}`);
     const data = await response.json();
     const models = data.data || [];
-    mkdirSync10(CLAUDISH_CACHE_DIR, { recursive: true });
-    writeFileSync10(ALL_MODELS_CACHE_PATH2, JSON.stringify({ lastUpdated: new Date().toISOString(), models }), "utf-8");
+    mkdirSync9(CLAUDISH_CACHE_DIR, { recursive: true });
+    writeFileSync9(ALL_MODELS_CACHE_PATH2, JSON.stringify({ lastUpdated: new Date().toISOString(), models }), "utf-8");
     return models;
   } catch {
     if (existsSync21(ALL_MODELS_CACHE_PATH2)) {
@@ -29683,8 +29771,20 @@ Tokens: ${result.usage.input} input, ${result.usage.output} output`;
     inputSchema: { type: "object" },
     group: "low-level",
     handler: async () => {
-      const models = loadRecommendedModels();
-      if (models.length === 0) {
+      let doc2;
+      try {
+        doc2 = getRecommendedModelsSync();
+      } catch {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No recommended models found. Try search_models instead."
+            }
+          ]
+        };
+      }
+      if (!doc2.models || doc2.models.length === 0) {
         return {
           content: [
             {
@@ -29694,43 +29794,81 @@ Tokens: ${result.usage.input} input, ${result.usage.output} output`;
           ]
         };
       }
+      const { flagship, fast } = groupRecommendedModels(doc2.models);
+      const providerByName = new Map(BUILTIN_PROVIDERS.map((p) => [p.name, p]));
+      const getNativePrefix = (firebaseSlug) => {
+        const canonical = FIREBASE_SLUG_TO_PROVIDER_NAME[firebaseSlug];
+        if (!canonical)
+          return null;
+        const def = providerByName.get(canonical);
+        if (!def || !def.shortcuts || def.shortcuts.length === 0)
+          return null;
+        return def.shortcuts[0];
+      };
+      const renderGroup = (group) => {
+        const m = group.primary;
+        const pricing = normalizePricingDisplay(m.pricing?.average);
+        const ctx = m.context || "N/A";
+        const caps = [];
+        if (m.supportsTools)
+          caps.push("tools");
+        if (m.supportsReasoning)
+          caps.push("reasoning");
+        if (m.supportsVision)
+          caps.push("vision");
+        const capsLine = caps.length > 0 ? caps.join(", ") : "none";
+        const prefixes = collectRoutingPrefixes(group, getNativePrefix);
+        const accessLine = prefixes.length > 0 ? prefixes.map((p) => `\`${p}@${m.id}\``).join(" \xB7 ") : `\`${m.id}\``;
+        return [
+          `### ${m.id}`,
+          `- **Pricing**: ${pricing} avg \xB7 ${ctx} context`,
+          `- **Capabilities**: ${capsLine}`,
+          `- **Access**: ${accessLine}`,
+          ""
+        ].join(`
+`);
+      };
       let output = `# Recommended Models
 
 `;
-      output += `| Model | Provider | Pricing | Context | Tools | Reasoning | Vision |
-`;
-      output += `|-------|----------|---------|---------|-------|-----------|--------|
+      output += `_Last updated: ${doc2.lastUpdated || "unknown"}_
+
 `;
-      for (const model of models) {
-        const t = model.supportsTools ? "\u2713" : "\xB7";
-        const r = model.supportsReasoning ? "\u2713" : "\xB7";
-        const v = model.supportsVision ? "\u2713" : "\xB7";
-        output += `| ${model.id} | ${model.provider} | ${model.pricing?.average || "N/A"} | ${model.context || "N/A"} | ${t} | ${r} | ${v} |
+      if (flagship.length > 0) {
+        output += `## Flagship models
+
 `;
+        for (const group of flagship)
+          output += renderGroup(group);
       }
-      output += `
-## Quick Picks
-`;
-      const cheapest = [...models].sort((a, b) => parsePriceAvg(a.pricing?.average) - parsePriceAvg(b.pricing?.average))[0];
-      const bigCtx = [...models].sort((a, b) => parseCtx(b.context) - parseCtx(a.context))[0];
-      const priciest = [...models].sort((a, b) => parsePriceAvg(b.pricing?.average) - parsePriceAvg(a.pricing?.average))[0];
-      const vision = models.find((m) => m.supportsVision);
-      const reasoning = models.find((m) => m.supportsReasoning && m.id !== priciest?.id);
-      if (cheapest)
-        output += `- **Budget**: \`${cheapest.id}\` (${cheapest.pricing?.average || "N/A"})
-`;
-      if (bigCtx && bigCtx.id !== cheapest?.id)
-        output += `- **Large context**: \`${bigCtx.id}\` (${bigCtx.context || "N/A"} tokens)
-`;
-      if (priciest && priciest.id !== cheapest?.id)
-        output += `- **Most advanced**: \`${priciest.id}\` (${priciest.pricing?.average || "N/A"})
+      if (fast.length > 0) {
+        output += `## Fast variants
+
 `;
-      if (vision && vision.id !== cheapest?.id && vision.id !== priciest?.id)
-        output += `- **Vision + coding**: \`${vision.id}\` (${vision.pricing?.average || "N/A"})
+        for (const group of fast)
+          output += renderGroup(group);
+      }
+      const primaries = [...flagship, ...fast].map((g) => g.primary);
+      const picks = computeQuickPicks(primaries);
+      const pickLines = [];
+      if (picks.budget)
+        pickLines.push(`- **Budget**: \`${picks.budget.id}\` (${normalizePricingDisplay(picks.budget.pricing?.average)})`);
+      if (picks.largeContext)
+        pickLines.push(`- **Large context**: \`${picks.largeContext.id}\` (${picks.largeContext.context || "N/A"})`);
+      if (picks.mostCapable)
+        pickLines.push(`- **Most capable**: \`${picks.mostCapable.id}\``);
+      if (picks.visionCoding)
+        pickLines.push(`- **Vision + coding**: \`${picks.visionCoding.id}\``);
+      if (picks.agentic)
+        pickLines.push(`- **Agentic**: \`${picks.agentic.id}\``);
+      if (pickLines.length > 0) {
+        output += `## Quick picks
+
 `;
-      if (reasoning && reasoning.id !== cheapest?.id)
-        output += `- **Agentic**: \`${reasoning.id}\` (${reasoning.pricing?.average || "N/A"})
+        output += pickLines.join(`
+`) + `
 `;
+      }
       return { content: [{ type: "text", text: output }] };
     }
   });
@@ -30354,7 +30492,7 @@ function startMcpServer() {
     process.exit(1);
   });
 }
-var import_dotenv2, __filename3, __dirname3, RECOMMENDED_MODELS_PATH, CLAUDISH_CACHE_DIR, ALL_MODELS_CACHE_PATH2, CACHE_MAX_AGE_DAYS = 2, INSTRUCTIONS = `Claudish MCP server provides access to external AI models (OpenRouter, Ollama, LM Studio, etc.) for coding tasks.
+var import_dotenv2, __filename3, __dirname3, CLAUDISH_CACHE_DIR, ALL_MODELS_CACHE_PATH2, CACHE_MAX_AGE_DAYS = 2, INSTRUCTIONS = `Claudish MCP server provides access to external AI models (OpenRouter, Ollama, LM Studio, etc.) for coding tasks.
 
 ## Channel Mode \u2014 External Model Sessions
 
@@ -30387,11 +30525,12 @@ var init_mcp_server = __esm(() => {
   init_channel();
   init_proxy_server();
   init_port_manager();
+  init_model_loader();
+  init_provider_definitions();
   import_dotenv2 = __toESM(require_main(), 1);
   import_dotenv2.config();
   __filename3 = fileURLToPath2(import.meta.url);
   __dirname3 = dirname3(__filename3);
-  RECOMMENDED_MODELS_PATH = join23(__dirname3, "../recommended-models.json");
   CLAUDISH_CACHE_DIR = join23(homedir22(), ".claudish");
   ALL_MODELS_CACHE_PATH2 = join23(CLAUDISH_CACHE_DIR, "all-models.json");
 });
@@ -41667,7 +41806,7 @@ 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 } from "child_process";
-import { readFileSync as readFileSync19, unlinkSync as unlinkSync6, writeFileSync as writeFileSync11 } from "fs";
+import { readFileSync as readFileSync19, unlinkSync as unlinkSync6, writeFileSync as writeFileSync10 } from "fs";
 import path from "path";
 import os from "os";
 import { randomUUID as randomUUID3 } from "crypto";
@@ -41776,7 +41915,7 @@ class ExternalEditor {
       if (Object.prototype.hasOwnProperty.call(this.fileOptions, "mode")) {
         opt.mode = this.fileOptions.mode;
       }
-      writeFileSync11(this.tempFile, this.text, opt);
+      writeFileSync10(this.tempFile, this.text, opt);
     } catch (createFileError) {
       throw new CreateFileError(createFileError);
     }
@@ -43190,50 +43329,6 @@ var init_config = __esm(() => {
   };
 });
 
-// src/utils.ts
-function fuzzyScore2(text, query) {
-  if (!text || !query)
-    return 0;
-  const t = text.toLowerCase();
-  const q = query.toLowerCase();
-  if (t === q)
-    return 1;
-  if (t.startsWith(q))
-    return 0.9;
-  if (t.includes(` ${q}`) || t.includes(`-${q}`) || t.includes(`/${q}`))
-    return 0.8;
-  if (t.includes(q))
-    return 0.6;
-  const normSep = (s) => s.replace(/[\s\-_.]/g, "");
-  const tn = normSep(t);
-  const qn = normSep(q);
-  if (tn === qn)
-    return 0.95;
-  if (tn.startsWith(qn))
-    return 0.85;
-  if (tn.includes(qn))
-    return 0.65;
-  let score = 0;
-  let tIdx = 0;
-  let qIdx = 0;
-  let consecutive = 0;
-  while (tIdx < t.length && qIdx < q.length) {
-    if (t[tIdx] === q[qIdx]) {
-      score += 1 + consecutive * 0.5;
-      consecutive++;
-      qIdx++;
-    } else {
-      consecutive = 0;
-    }
-    tIdx++;
-  }
-  if (qIdx === q.length) {
-    const compactness = q.length / (tIdx + 1);
-    return 0.1 + 0.4 * compactness * (score / (q.length * 2));
-  }
-  return 0;
-}
-
 // src/providers/api-key-map.ts
 var API_KEY_MAP;
 var init_api_key_map = __esm(() => {
@@ -43582,7 +43677,7 @@ import os2 from "os";
 import path2 from "path";
 import { EventEmitter as EventEmitter3 } from "events";
 import { dlopen, toArrayBuffer as toArrayBuffer4, JSCallback, ptr as ptr4 } from "bun:ffi";
-import { existsSync as existsSync23, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync23, writeFileSync as writeFileSync11 } from "fs";
 import { EventEmitter as EventEmitter4 } from "events";
 import { toArrayBuffer, ptr } from "bun:ffi";
 import { ptr as ptr2, toArrayBuffer as toArrayBuffer2 } from "bun:ffi";
@@ -48928,7 +49023,7 @@ function convertToDebugSymbols(symbols) {
   if (env.OTUI_DEBUG_FFI && globalFFILogPath) {
     const logPath = globalFFILogPath;
     const writeSync4 = (msg) => {
-      writeFileSync12(logPath, msg + `
+      writeFileSync11(logPath, msg + `
 `, { flag: "a" });
     };
     Object.entries(symbols).forEach(([key, value]) => {
@@ -100262,9 +100357,8 @@ __export(exports_cli, {
 });
 import {
   readFileSync as readFileSync20,
-  writeFileSync as writeFileSync13,
   existsSync as existsSync24,
-  mkdirSync as mkdirSync11,
+  mkdirSync as mkdirSync10,
   copyFileSync,
   readdirSync as readdirSync4,
   unlinkSync as unlinkSync7
@@ -100279,7 +100373,7 @@ function clearAllModelCaches() {
   const cacheDir = join25(homedir23(), ".claudish");
   if (!existsSync24(cacheDir))
     return;
-  const cachePatterns = ["all-models.json", "pricing-cache.json"];
+  const cachePatterns = ["pricing-cache.json", "recommended-models-cache.json"];
   let cleared = 0;
   try {
     const files = readdirSync4(cacheDir);
@@ -100477,25 +100571,54 @@ async function parseArgs(args) {
       const forceUpdate = args.includes("--force-update");
       if (forceUpdate)
         clearAllModelCaches();
-      await checkAndUpdateModelsCache(forceUpdate);
-      if (hasJsonFlag) {
-        printAvailableModelsJSON();
-      } else {
-        printAvailableModels();
-      }
+      await printRecommendedModels(hasJsonFlag, forceUpdate);
       process.exit(0);
+    } else if (arg === "--list-providers") {
+      const hasJsonFlag = args.includes("--json");
+      try {
+        const providers = await getProviderList();
+        if (hasJsonFlag) {
+          console.log(JSON.stringify({ providers, total: providers.length }, null, 2));
+        } else {
+          console.log(`
+Providers in Firebase catalog:
+`);
+          console.log("  Slug                 Active models");
+          console.log("  " + "\u2500".repeat(40));
+          for (const { slug, count } of providers) {
+            console.log(`  ${slug.padEnd(20)} ${String(count).padStart(5)}`);
+          }
+          console.log(`
+Usage:  claudish --list-models --provider <slug>`);
+          console.log(`        claudish -s <query>                    (fuzzy search)
+`);
+        }
+        process.exit(0);
+      } catch (err) {
+        console.error(`Failed to fetch providers: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+      }
     } else if (arg === "--models" || arg === "--list-models" || arg === "-s" || arg === "--search") {
       const nextArg = args[i + 1];
       const hasQuery = nextArg && !nextArg.startsWith("--");
       const query = hasQuery ? args[++i] : null;
       const hasJsonFlag = args.includes("--json");
       const forceUpdate = args.includes("--force-update");
+      const providerIdx = args.indexOf("--provider");
+      const providerSlug = providerIdx !== -1 && providerIdx + 1 < args.length ? args[providerIdx + 1] : null;
       if (forceUpdate)
         clearAllModelCaches();
+      if (query && providerSlug) {
+        console.error("Use --provider together with --list-models (without a query) to filter the catalog.");
+        console.error("For keyword search, drop --provider: claudish -s <query>");
+        process.exit(1);
+      }
       if (query) {
-        await searchAndPrintModels(query, forceUpdate);
+        await searchAndPrintModels(query, hasJsonFlag);
+      } else if (providerSlug) {
+        await printByProvider(providerSlug, hasJsonFlag);
       } else {
-        await printAllModels(hasJsonFlag, forceUpdate);
+        await printTop100(hasJsonFlag);
       }
       process.exit(0);
     } else if (arg === "--summarize-tools") {
@@ -100618,502 +100741,298 @@ async function fetchOllamaModels() {
     return [];
   }
 }
-async function searchAndPrintModels(query, forceUpdate) {
-  let models = [];
-  if (!forceUpdate && existsSync24(ALL_MODELS_JSON_PATH)) {
-    try {
-      const cacheData = JSON.parse(readFileSync20(ALL_MODELS_JSON_PATH, "utf-8"));
-      const lastUpdated = new Date(cacheData.lastUpdated);
-      const now = new Date;
-      const ageInDays = (now.getTime() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24);
-      if (ageInDays <= CACHE_MAX_AGE_DAYS2) {
-        models = cacheData.models;
-      }
-    } catch (e) {}
+function formatModelDocPricing(pricing) {
+  if (!pricing)
+    return "N/A";
+  const input = typeof pricing.input === "number" ? pricing.input : undefined;
+  const output = typeof pricing.output === "number" ? pricing.output : undefined;
+  if (input === undefined && output === undefined)
+    return "N/A";
+  if ((input ?? 0) === 0 && (output ?? 0) === 0)
+    return "FREE";
+  const avg = ((input ?? 0) + (output ?? 0)) / 2;
+  return `$${avg.toFixed(2)}/1M`;
+}
+function formatModelDocContext(ctx) {
+  if (!ctx || ctx <= 0)
+    return "N/A";
+  if (ctx >= 1e6)
+    return `${Math.round(ctx / 1e6)}M`;
+  return `${Math.round(ctx / 1000)}K`;
+}
+function formatModelDocCaps(caps) {
+  if (!caps)
+    return "\xB7";
+  const parts = [];
+  if (caps.tools)
+    parts.push("T");
+  if (caps.thinking)
+    parts.push("R");
+  if (caps.vision)
+    parts.push("V");
+  return parts.length > 0 ? parts.join("") : "\xB7";
+}
+async function searchAndPrintModels(query, jsonOutput) {
+  let results;
+  try {
+    console.error(`\uD83D\uDD04 Searching Firebase catalog for "${query}"...`);
+    results = await searchModels(query, 50);
+  } catch (error2) {
+    console.error(`\u274C Failed to reach Firebase model catalog: ${error2 instanceof Error ? error2.message : String(error2)}`);
+    console.error("   Check your network connection.");
+    process.exit(1);
   }
-  if (models.length === 0) {
-    console.error("\uD83D\uDD04 Fetching all models from OpenRouter (this may take a moment)...");
-    try {
-      const response = await fetch("https://openrouter.ai/api/v1/models");
-      if (!response.ok)
-        throw new Error(`API returned ${response.status}`);
-      const data = await response.json();
-      models = data.data;
-      mkdirSync11(CLAUDISH_CACHE_DIR2, { recursive: true });
-      writeFileSync13(ALL_MODELS_JSON_PATH, JSON.stringify({
-        lastUpdated: new Date().toISOString(),
-        models
-      }), "utf-8");
-      console.error(`\u2705 Cached ${models.length} models`);
-    } catch (error2) {
-      console.error(`\u274C Failed to fetch models: ${error2}`);
-      process.exit(1);
+  if (results.length === 0) {
+    if (jsonOutput) {
+      console.log(JSON.stringify({ query, count: 0, models: [] }, null, 2));
+    } else {
+      console.log(`No models found matching "${query}"`);
     }
+    return;
   }
-  const ollamaModels = await fetchOllamaModels();
-  if (ollamaModels.length > 0) {
-    console.error(`\uD83C\uDFE0 Found ${ollamaModels.length} local Ollama models`);
-    models = [...ollamaModels, ...models];
-  }
-  if (process.env.OPENAI_API_KEY) {
-    try {
-      const modelsDevResponse = await fetch("https://models.dev/api.json", {
-        signal: AbortSignal.timeout(5000)
-      });
-      if (modelsDevResponse.ok) {
-        const modelsDevData = await modelsDevResponse.json();
-        const openaiData = modelsDevData.openai;
-        if (openaiData?.models) {
-          const openaiModels = Object.entries(openaiData.models).filter(([id, _2]) => {
-            const lowerId = id.toLowerCase();
-            return lowerId.startsWith("gpt-") || lowerId.startsWith("o1-") || lowerId.startsWith("o3-") || lowerId.startsWith("o4-") || lowerId.startsWith("chatgpt-");
-          }).map(([id, m2]) => {
-            const inputCost = m2.cost?.input || 2;
-            const outputCost = m2.cost?.output || 8;
-            const contextLen = m2.limit?.context || 128000;
-            const inputModalities = m2.modalities?.input || [];
-            return {
-              id: `oai/${id}`,
-              name: m2.name || id,
-              description: `OpenAI direct model`,
-              context_length: contextLen,
-              pricing: {
-                prompt: String(inputCost / 1e6),
-                completion: String(outputCost / 1e6)
-              },
-              isOAIDirect: true,
-              supportsTools: m2.tool_call === true,
-              supportsReasoning: m2.reasoning === true,
-              supportsVision: inputModalities.includes("image") || inputModalities.includes("video")
-            };
-          });
-          console.error(`\uD83D\uDD11 Found ${openaiModels.length} OpenAI direct models`);
-          models = [...openaiModels, ...models];
-        }
-      }
-    } catch {}
-  }
-  if (process.env.GLM_CODING_API_KEY) {
-    try {
-      const glmCodingModels = await fetchGLMCodingModels();
-      if (glmCodingModels.length > 0) {
-        console.error(`\uD83D\uDD11 Found ${glmCodingModels.length} GLM Coding Plan models`);
-        models = [...glmCodingModels, ...models];
-      }
-    } catch {}
-  }
-  if (process.env.LITELLM_BASE_URL && process.env.LITELLM_API_KEY) {
-    try {
-      const litellmModels = await fetchLiteLLMModels(process.env.LITELLM_BASE_URL, process.env.LITELLM_API_KEY, forceUpdate);
-      if (litellmModels.length > 0) {
-        console.error(`\uD83D\uDD17 Found ${litellmModels.length} LiteLLM models`);
-        models = [...litellmModels, ...models];
-      }
-    } catch {}
-  }
-  const results = models.map((model) => {
-    const nameScore = fuzzyScore2(model.name || "", query);
-    const idScore = fuzzyScore2(model.id || "", query);
-    const descScore = fuzzyScore2(model.description || "", query) * 0.5;
-    return {
-      model,
-      score: Math.max(nameScore, idScore, descScore)
-    };
-  }).filter((item) => item.score > 0.2).sort((a, b2) => b2.score - a.score).slice(0, 20);
-  if (results.length === 0) {
-    console.log(`No models found matching "${query}"`);
+  if (jsonOutput) {
+    console.log(JSON.stringify({
+      query,
+      count: results.length,
+      models: results.map((m2) => ({
+        id: m2.modelId,
+        provider: m2.provider,
+        contextWindow: m2.contextWindow,
+        pricing: m2.pricing,
+        capabilities: m2.capabilities,
+        aliases: m2.aliases,
+        status: m2.status
+      }))
+    }, null, 2));
     return;
   }
-  const RED2 = "\x1B[31m";
-  const GREEN = "\x1B[32m";
-  const RESET = "\x1B[0m";
-  const DIM = "\x1B[2m";
   console.log(`
 Found ${results.length} matching models:
 `);
-  console.log("  Model                          Provider    Pricing     Context  Score");
+  console.log("  Model                          Provider    Pricing     Context  Caps");
   console.log("  " + "\u2500".repeat(80));
-  for (const { model, score } of results) {
-    let fullModelId;
-    if (model.isLocal) {
-      fullModelId = model.id.replace("ollama/", "ollama@");
-    } else if (model.id.startsWith("zen/")) {
-      fullModelId = model.id.replace("zen/", "zen@");
-    } else if (model.id.startsWith("oai/") || model.isOAIDirect) {
-      fullModelId = model.id.replace("oai/", "oai@");
-    } else if (model.source === "LiteLLM" || model.id.startsWith("litellm@")) {
-      fullModelId = model.id;
-    } else {
-      fullModelId = `openrouter@${model.id}`;
-    }
-    const modelId = fullModelId.length > 30 ? fullModelId.substring(0, 27) + "..." : fullModelId;
-    const modelIdPadded = modelId.padEnd(30);
-    const providerName = model.id.split("/")[0];
-    const provider = providerName.length > 10 ? providerName.substring(0, 7) + "..." : providerName;
-    const providerPadded = provider.padEnd(10);
-    let pricing;
-    if (model.isLocal) {
-      pricing = "LOCAL";
-    } else {
-      const promptPrice = parseFloat(model.pricing?.prompt || "0") * 1e6;
-      const completionPrice = parseFloat(model.pricing?.completion || "0") * 1e6;
-      const avg = (promptPrice + completionPrice) / 2;
-      if (avg < 0) {
-        pricing = "varies";
-      } else if (avg === 0) {
-        pricing = "FREE";
-      } else {
-        pricing = `$${avg.toFixed(2)}/1M`;
-      }
-    }
-    const pricingPadded = pricing.padEnd(10);
-    const contextLen = model.context_length || model.top_provider?.context_length || 0;
-    const context = contextLen > 0 ? `${Math.round(contextLen / 1000)}K` : "N/A";
-    const contextPadded = context.padEnd(7);
-    if (model.isLocal && model.supportsTools === false) {
-      console.log(`  ${RED2}${modelIdPadded} ${providerPadded} ${pricingPadded} ${contextPadded} ${(score * 100).toFixed(0)}% \u2717 no tools${RESET}`);
-    } else if (model.isLocal && model.supportsTools === true) {
-      console.log(`  ${GREEN}${modelIdPadded}${RESET} ${providerPadded} ${pricingPadded} ${contextPadded} ${(score * 100).toFixed(0)}%`);
-    } else {
-      console.log(`  ${modelIdPadded} ${providerPadded} ${pricingPadded} ${contextPadded} ${(score * 100).toFixed(0)}%`);
-    }
+  for (const m2 of results) {
+    const id = m2.modelId.length > 30 ? m2.modelId.substring(0, 27) + "..." : m2.modelId;
+    const idPadded = id.padEnd(30);
+    const prov = (m2.provider || "").padEnd(10);
+    const price = formatModelDocPricing(m2.pricing).padEnd(10);
+    const ctx = formatModelDocContext(m2.contextWindow).padEnd(7);
+    const caps = formatModelDocCaps(m2.capabilities);
+    console.log(`  ${idPadded} ${prov} ${price} ${ctx} ${caps}`);
   }
   console.log("");
-  console.log(`${DIM}Local models: ${RED2}red${RESET}${DIM} = no tool support (incompatible), ${GREEN}green${RESET}${DIM} = compatible${RESET}`);
+  console.log("Caps: T = tools  R = reasoning  V = vision");
   console.log("");
-  console.log("Use OpenRouter model: claudish --model openrouter@<provider/model-id>");
-  console.log("OpenAI direct model:  claudish --model oai@<model-name>");
-  console.log("Local Ollama model:   claudish --model ollama@<model-name>");
-  console.log("OpenCode Zen model:   claudish --model zen@<model-id>");
-  console.log("LiteLLM proxy model:  claudish --model litellm@<model-group>");
-}
-async function printAllModels(jsonOutput, forceUpdate) {
-  let models = [];
-  const [ollamaModels, zenModels] = await Promise.all([fetchOllamaModels(), fetchZenModels()]);
-  if (!forceUpdate && existsSync24(ALL_MODELS_JSON_PATH)) {
+  console.log("Use any model by its ID: claudish --model <model-id>");
+  console.log("Provider shortcuts:      claudish --model or@<id> | google@<id> | oai@<id>");
+}
+function renderModelDocTable(models, showRank) {
+  const header = showRank ? "  #    Model                          Provider    Pricing     Context  Caps" : "       Model                          Provider    Pricing     Context  Caps";
+  console.log(header);
+  console.log("  " + "\u2500".repeat(80));
+  for (const m2 of models) {
+    const rankCell = showRank ? String(m2.rank ?? "").padStart(3) + "  " : "     ";
+    const rawId = m2.modelId;
+    const id = rawId.length > 30 ? rawId.substring(0, 27) + "..." : rawId;
+    const idPadded = id.padEnd(30);
+    const prov = (m2.provider || "").padEnd(10);
+    const price = formatModelDocPricing(m2.pricing).padEnd(10);
+    const ctx = formatModelDocContext(m2.contextWindow).padEnd(7);
+    const caps = formatModelDocCaps(m2.capabilities);
+    console.log(`  ${rankCell}${idPadded} ${prov} ${price} ${ctx} ${caps}`);
+  }
+}
+async function printLocalProvidersFooter() {
+  console.log(`
+Local providers`);
+  console.log("  " + "\u2500".repeat(70));
+  let ollamaLine = "  Ollama:    not running";
+  try {
+    const ollamaModels = await fetchOllamaModels();
+    if (ollamaModels.length > 0) {
+      const toolCount = ollamaModels.filter((m2) => m2.supportsTools).length;
+      ollamaLine = `  Ollama:    ${ollamaModels.length} models installed (${toolCount} with tools) \u2014 use: claudish --model ollama@<name>`;
+    }
+  } catch {}
+  console.log(ollamaLine);
+  let litellmLine = "  LiteLLM:   not configured (set LITELLM_BASE_URL + LITELLM_API_KEY)";
+  if (process.env.LITELLM_BASE_URL && process.env.LITELLM_API_KEY) {
     try {
-      const cacheData = JSON.parse(readFileSync20(ALL_MODELS_JSON_PATH, "utf-8"));
-      const lastUpdated = new Date(cacheData.lastUpdated);
-      const now = new Date;
-      const ageInDays = (now.getTime() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24);
-      if (ageInDays <= CACHE_MAX_AGE_DAYS2) {
-        models = cacheData.models;
-        if (!jsonOutput) {
-          console.error(`\u2713 Using cached models (last updated: ${cacheData.lastUpdated.split("T")[0]})`);
-        }
+      const litellmModels = await fetchLiteLLMModels(process.env.LITELLM_BASE_URL, process.env.LITELLM_API_KEY, false);
+      if (litellmModels.length > 0) {
+        litellmLine = `  LiteLLM:   ${litellmModels.length} model groups configured \u2014 use: claudish --model litellm@<group>`;
+      } else {
+        litellmLine = "  LiteLLM:   reachable but no model groups returned";
       }
-    } catch (e) {}
-  }
-  if (models.length === 0) {
-    console.error("\uD83D\uDD04 Fetching all models from OpenRouter...");
-    try {
-      const response = await fetch("https://openrouter.ai/api/v1/models");
-      if (!response.ok)
-        throw new Error(`API returned ${response.status}`);
-      const data = await response.json();
-      models = data.data;
-      mkdirSync11(CLAUDISH_CACHE_DIR2, { recursive: true });
-      writeFileSync13(ALL_MODELS_JSON_PATH, JSON.stringify({
-        lastUpdated: new Date().toISOString(),
-        models
-      }), "utf-8");
-      console.error(`\u2705 Cached ${models.length} models`);
-    } catch (error2) {
-      console.error(`\u274C Failed to fetch models: ${error2}`);
-      process.exit(1);
+    } catch {
+      litellmLine = "  LiteLLM:   configured but unreachable";
     }
   }
+  console.log(litellmLine);
+}
+async function printTop100(jsonOutput) {
+  let response;
+  try {
+    response = await getTop100Models();
+  } catch (error2) {
+    console.error(`\u274C Failed to load top-100 models from Firebase: ${error2 instanceof Error ? error2.message : String(error2)}`);
+    console.error("   Check your network connection.");
+    process.exit(1);
+  }
   if (jsonOutput) {
-    const allModels = [...ollamaModels, ...zenModels, ...models];
-    console.log(JSON.stringify({
-      count: allModels.length,
-      localCount: ollamaModels.length,
-      zenCount: zenModels.length,
-      lastUpdated: new Date().toISOString().split("T")[0],
-      models: allModels.map((m2) => {
-        let id;
-        if (m2.isLocal) {
-          id = m2.id.replace("ollama/", "ollama@");
-        } else if (m2.isZen || m2.id.startsWith("zen/")) {
-          id = m2.id.replace("zen/", "zen@");
-        } else if (m2.source === "LiteLLM" || m2.id.startsWith("litellm@")) {
-          id = m2.id;
-        } else {
-          id = `openrouter@${m2.id}`;
-        }
-        return {
-          id,
-          name: m2.name,
-          context: m2.context_length || m2.top_provider?.context_length,
-          pricing: m2.pricing,
-          isLocal: m2.isLocal || false,
-          isZen: m2.isZen || false
-        };
-      })
-    }, null, 2));
+    console.log(JSON.stringify(response, null, 2));
     return;
   }
-  const RED2 = "\x1B[31m";
-  const GREEN = "\x1B[32m";
-  const RESET = "\x1B[0m";
-  const DIM = "\x1B[2m";
-  if (ollamaModels.length > 0) {
-    const toolCapableCount = ollamaModels.filter((m2) => m2.supportsTools).length;
-    console.log(`
-\uD83C\uDFE0 LOCAL OLLAMA MODELS (${ollamaModels.length} installed, ${toolCapableCount} with tool support):
+  console.log(`
+Top ${response.total} models from Firebase (pool: ${response.poolSize} eligible)
 `);
-    console.log("    Model                                     Size         Params    Tools");
-    console.log("  " + "\u2500".repeat(76));
-    for (const model of ollamaModels) {
-      const fullId = model.id.replace("ollama/", "ollama@");
-      const modelId = fullId.length > 35 ? fullId.substring(0, 32) + "..." : fullId;
-      const modelIdPadded = modelId.padEnd(38);
-      const size = model.size ? `${(model.size / 1e9).toFixed(1)}GB` : "N/A";
-      const sizePadded = size.padEnd(12);
-      const params = model.details?.parameter_size || "N/A";
-      const paramsPadded = params.padEnd(8);
-      if (model.supportsTools) {
-        console.log(`    ${modelIdPadded} ${sizePadded} ${paramsPadded}  ${GREEN}\u2713${RESET}`);
-      } else {
-        console.log(`    ${RED2}${modelIdPadded} ${sizePadded} ${paramsPadded}  \u2717 no tools${RESET}`);
-      }
-    }
-    console.log("");
-    console.log(`  ${GREEN}\u2713${RESET} = Compatible with Claude Code (supports tool calling)`);
-    console.log(`  ${RED2}\u2717${RESET} = Not compatible ${DIM}(Claude Code requires tool support)${RESET}`);
-    console.log("");
-    console.log("  Use: claudish --model ollama@<model-name>");
-    console.log("  Pull a compatible model: ollama pull llama3.2");
+  if (response.models.length === 0) {
+    console.log("  No eligible models in the catalog.");
   } else {
-    console.log(`
-\uD83C\uDFE0 LOCAL OLLAMA: Not running or no models installed`);
-    console.log("   Start Ollama: ollama serve");
-    console.log("   Pull a model: ollama pull llama3.2");
-  }
-  if (zenModels.length > 0) {
-    const freeCount = zenModels.filter((m2) => m2.isFree).length;
-    console.log(`
-\uD83D\uDD2E OPENCODE ZEN (${zenModels.length} models, ${freeCount} FREE - no API key needed):
-`);
-    console.log("    Model                          Context    Pricing      Tools");
-    console.log("  " + "\u2500".repeat(68));
-    const sortedModels = [...zenModels].sort((a, b2) => {
-      if (a.isFree && !b2.isFree)
-        return -1;
-      if (!a.isFree && b2.isFree)
-        return 1;
-      return (b2.context_length || 0) - (a.context_length || 0);
-    });
-    for (const model of sortedModels) {
-      const fullId = model.id.replace("zen/", "zen@");
-      const modelId = fullId.length > 30 ? fullId.substring(0, 27) + "..." : fullId;
-      const modelIdPadded = modelId.padEnd(32);
-      const contextLen = model.context_length || 0;
-      const context = contextLen > 0 ? `${Math.round(contextLen / 1000)}K` : "N/A";
-      const contextPadded = context.padEnd(10);
-      const pricing = model.isFree ? `${GREEN}FREE${RESET}` : `$${(parseFloat(model.pricing?.prompt || "0") + parseFloat(model.pricing?.completion || "0")).toFixed(1)}/M`;
-      const pricingPadded = model.isFree ? "FREE        " : pricing.padEnd(12);
-      const tools = model.supportsTools ? `${GREEN}\u2713${RESET}` : `${RED2}\u2717${RESET}`;
-      console.log(`    ${modelIdPadded} ${contextPadded} ${pricingPadded} ${tools}`);
-    }
+    renderModelDocTable(response.models, true);
     console.log("");
-    console.log(`  ${DIM}FREE models work without API key!${RESET}`);
-    console.log("  Use: claudish --model zen@<model-id>");
+    console.log("  Caps: T = tools  R = reasoning  V = vision");
   }
-  if (process.env.LITELLM_BASE_URL && process.env.LITELLM_API_KEY) {
-    try {
-      const litellmModels = await fetchLiteLLMModels(process.env.LITELLM_BASE_URL, process.env.LITELLM_API_KEY, forceUpdate);
-      if (litellmModels.length > 0) {
-        console.log(`
-\uD83D\uDD17 LITELLM PROXY (${litellmModels.length} model groups):
-`);
-        console.log("    Model                          Context    Pricing      Tools");
-        console.log("  " + "\u2500".repeat(68));
-        for (const model of litellmModels) {
-          const modelId = model.id.length > 30 ? model.id.substring(0, 27) + "..." : model.id;
-          const modelIdPadded = modelId.padEnd(32);
-          const contextPadded = (model.context || "N/A").padEnd(10);
-          const pricingStr = model.isFree ? `${GREEN}FREE${RESET}` : model.pricing?.average || "N/A";
-          const pricingPadded = model.isFree ? "FREE        " : pricingStr.padEnd(12);
-          const tools = model.supportsTools ? `${GREEN}\u2713${RESET}` : `${RED2}\u2717${RESET}`;
-          console.log(`    ${modelIdPadded} ${contextPadded} ${pricingPadded} ${tools}`);
-        }
-        console.log("");
-        console.log("  Use: claudish --model litellm@<model-group>");
-      }
-    } catch {}
+  await printLocalProvidersFooter();
+  console.log("");
+  console.log("Filter by provider: claudish --list-models --provider <slug>");
+  console.log("                    (e.g. opencode-zen, anthropic, openai, google, x-ai)");
+  console.log("All providers:      claudish --list-providers");
+  console.log("Search by keyword:  claudish -s <query>");
+  console.log("Top recommended:    claudish --top-models");
+  console.log("");
+}
+async function printByProvider(providerSlug, jsonOutput) {
+  let models;
+  try {
+    models = await getModelsByProvider(providerSlug, 200);
+  } catch (error2) {
+    console.error(`\u274C Failed to load provider catalog from Firebase: ${error2 instanceof Error ? error2.message : String(error2)}`);
+    console.error("   Check your network connection.");
+    process.exit(1);
   }
-  const byProvider = new Map;
-  for (const model of models) {
-    const provider = model.id.split("/")[0];
-    if (!byProvider.has(provider)) {
-      byProvider.set(provider, []);
-    }
-    byProvider.get(provider).push(model);
+  if (jsonOutput) {
+    console.log(JSON.stringify({ provider: providerSlug, count: models.length, models }, null, 2));
+    return;
   }
-  const sortedProviders = [...byProvider.keys()].sort();
-  console.log(`
-\u2601\uFE0F  OPENROUTER MODELS (${models.length} total):
-`);
-  for (const provider of sortedProviders) {
-    const providerModels = byProvider.get(provider);
+  if (models.length === 0) {
     console.log(`
-  ${provider.toUpperCase()} (${providerModels.length} models)`);
-    console.log("  " + "\u2500".repeat(70));
-    for (const model of providerModels) {
-      const fullId = `openrouter@${model.id}`;
-      const modelId = fullId.length > 40 ? fullId.substring(0, 37) + "..." : fullId;
-      const modelIdPadded = modelId.padEnd(42);
-      const promptPrice = parseFloat(model.pricing?.prompt || "0") * 1e6;
-      const completionPrice = parseFloat(model.pricing?.completion || "0") * 1e6;
-      const avg = (promptPrice + completionPrice) / 2;
-      let pricing;
-      if (avg < 0) {
-        pricing = "varies";
-      } else if (avg === 0) {
-        pricing = "FREE";
-      } else {
-        pricing = `$${avg.toFixed(2)}/1M`;
-      }
-      const pricingPadded = pricing.padEnd(12);
-      const contextLen = model.context_length || model.top_provider?.context_length || 0;
-      const context = contextLen > 0 ? `${Math.round(contextLen / 1000)}K` : "N/A";
-      const contextPadded = context.padEnd(8);
-      console.log(`    ${modelIdPadded} ${pricingPadded} ${contextPadded}`);
-    }
+No active models found for provider "${providerSlug}". Try \`claudish -s <query>\` to search the full catalog.
+`);
+    return;
   }
   console.log(`
+Provider: ${providerSlug} (${models.length} active models)
 `);
-  console.log("Use OpenRouter model:  claudish --model openrouter@<provider/model-id>");
-  console.log("  Example:             claudish --model openrouter@google/gemini-2.0-flash-exp:free");
-  console.log("Local Ollama model:    claudish --model ollama@<model-name>");
-  console.log("OpenCode Zen model:    claudish --model zen@<model-id>");
-  console.log("LiteLLM proxy model:   claudish --model litellm@<model-group>");
-  console.log("Search:                claudish --search <query>");
-  console.log("Top models:            claudish --top-models");
-}
-function isCacheStale() {
-  const cachePath = existsSync24(CACHED_MODELS_PATH) ? CACHED_MODELS_PATH : BUNDLED_MODELS_PATH;
-  if (!existsSync24(cachePath)) {
-    return true;
-  }
+  renderModelDocTable(models, false);
+  console.log("");
+  console.log("  Caps: T = tools  R = reasoning  V = vision");
+  console.log("");
+  console.log("Use any model:      claudish --model <model-id>");
+  console.log("Provider shortcuts: claudish --model or@<id> | google@<id> | oai@<id>");
+  console.log("");
+}
+async function printRecommendedModels(jsonOutput, forceUpdate) {
+  let doc2;
   try {
-    const jsonContent = readFileSync20(cachePath, "utf-8");
-    const data = JSON.parse(jsonContent);
-    if (!data.lastUpdated) {
-      return true;
-    }
-    const lastUpdated = new Date(data.lastUpdated);
-    const now = new Date;
-    const ageInDays = (now.getTime() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24);
-    return ageInDays > CACHE_MAX_AGE_DAYS2;
+    doc2 = await getRecommendedModels({ forceRefresh: forceUpdate });
   } catch (error2) {
-    return true;
+    console.error(`\u274C Failed to load recommended models: ${error2 instanceof Error ? error2.message : String(error2)}`);
+    process.exit(1);
   }
-}
-async function updateModelsFromOpenRouter() {
-  console.error("\uD83D\uDD04 Updating model recommendations from OpenRouter...");
-  try {
-    const apiResponse = await fetch("https://openrouter.ai/api/v1/models?category=programming&order=top-weekly");
-    if (!apiResponse.ok) {
-      throw new Error(`OpenRouter API returned ${apiResponse.status}`);
-    }
-    const openrouterData = await apiResponse.json();
-    const topModels = openrouterData.data;
-    const recommendations = [];
-    const providers = new Set;
-    for (const model of topModels) {
-      const modelId = model.id;
-      const provider = modelId.split("/")[0];
-      if (provider === "anthropic") {
-        continue;
-      }
-      if (provider === "openrouter") {
-        continue;
-      }
-      if (providers.has(provider)) {
-        continue;
-      }
-      const name = model.name || modelId;
-      const description = model.description || `${name} model`;
-      const architecture = model.architecture || {};
-      const topProvider = model.top_provider || {};
-      const supportedParams = model.supported_parameters || [];
-      const promptPrice = parseFloat(model.pricing?.prompt || "0");
-      const completionPrice = parseFloat(model.pricing?.completion || "0");
-      const inputPrice = promptPrice > 0 ? `$${(promptPrice * 1e6).toFixed(2)}/1M` : "FREE";
-      const outputPrice = completionPrice > 0 ? `$${(completionPrice * 1e6).toFixed(2)}/1M` : "FREE";
-      const avgPrice = promptPrice > 0 || completionPrice > 0 ? `$${((promptPrice + completionPrice) / 2 * 1e6).toFixed(2)}/1M` : "FREE";
-      let category = "programming";
-      const lowerDesc = description.toLowerCase() + " " + name.toLowerCase();
-      if (lowerDesc.includes("vision") || lowerDesc.includes("vl-") || lowerDesc.includes("multimodal")) {
-        category = "vision";
-      } else if (lowerDesc.includes("reason")) {
-        category = "reasoning";
-      }
-      const bareId = modelId.split("/").pop().replace(/:free$/, "");
-      recommendations.push({
-        id: bareId,
-        openrouterId: modelId,
-        name,
-        description,
-        provider: provider.charAt(0).toUpperCase() + provider.slice(1),
-        category,
-        priority: recommendations.length + 1,
-        pricing: {
-          input: inputPrice,
-          output: outputPrice,
-          average: avgPrice
-        },
-        context: topProvider.context_length ? `${Math.floor(topProvider.context_length / 1000)}K` : "N/A",
-        maxOutputTokens: topProvider.max_completion_tokens || null,
-        modality: architecture.modality || "text->text",
-        supportsTools: supportedParams.includes("tools") || supportedParams.includes("tool_choice"),
-        supportsReasoning: supportedParams.includes("reasoning") || supportedParams.includes("include_reasoning"),
-        supportsVision: (architecture.input_modalities || []).includes("image") || (architecture.input_modalities || []).includes("video"),
-        isModerated: topProvider.is_moderated || false,
-        recommended: true
-      });
-      providers.add(provider);
+  if (jsonOutput) {
+    console.log(JSON.stringify(doc2, null, 2));
+    return;
+  }
+  const lastUpdated = doc2.lastUpdated || "unknown";
+  const { flagship, fast } = groupRecommendedModels(doc2.models);
+  const providerByName = new Map(BUILTIN_PROVIDERS.map((p) => [p.name, p]));
+  const getNativePrefix = (firebaseSlug) => {
+    const canonical = FIREBASE_SLUG_TO_PROVIDER_NAME[firebaseSlug];
+    if (!canonical)
+      return null;
+    const def = providerByName.get(canonical);
+    if (!def || !def.shortcuts || def.shortcuts.length === 0)
+      return null;
+    return def.shortcuts[0];
+  };
+  const renderGroup = (group) => {
+    const m2 = group.primary;
+    const rawId = m2.id;
+    const modelId = rawId.length > 28 ? rawId.substring(0, 25) + "..." : rawId;
+    const modelIdPadded = modelId.padEnd(28);
+    const pricing = normalizePricingDisplay(m2.pricing?.average);
+    const pricingPadded = pricing.padEnd(10);
+    const context = m2.context || "N/A";
+    const contextPadded = context.padEnd(6);
+    const caps = [];
+    if (m2.supportsTools)
+      caps.push("\uD83D\uDD27");
+    if (m2.supportsReasoning)
+      caps.push("\uD83E\uDDE0");
+    if (m2.supportsVision)
+      caps.push("\uD83D\uDC41\uFE0F");
+    const capabilities = caps.join(" ");
+    console.log(`  ${modelIdPadded} ${pricingPadded} ${contextPadded} ${capabilities}`);
+    const prefixes = collectRoutingPrefixes(group, getNativePrefix);
+    if (prefixes.length > 0) {
+      const viaLine = prefixes.map((p) => `${p}@`).join(" \xB7 ");
+      console.log(`      via: ${viaLine}`);
     }
-    let version2 = "1.2.0";
-    const existingPath = existsSync24(CACHED_MODELS_PATH) ? CACHED_MODELS_PATH : BUNDLED_MODELS_PATH;
-    if (existsSync24(existingPath)) {
-      try {
-        const existing = JSON.parse(readFileSync20(existingPath, "utf-8"));
-        version2 = existing.version || version2;
-      } catch {}
+  };
+  console.log(`
+Recommended Models (last updated: ${lastUpdated}):
+`);
+  if (flagship.length > 0) {
+    console.log("Flagship models");
+    console.log("  " + "\u2500".repeat(70));
+    for (let i = 0;i < flagship.length; i++) {
+      renderGroup(flagship[i]);
+      if (i < flagship.length - 1)
+        console.log("");
     }
-    const updatedData = {
-      version: version2,
-      lastUpdated: new Date().toISOString().split("T")[0],
-      source: "https://openrouter.ai/models?categories=programming&fmt=cards&order=top-weekly",
-      models: recommendations
-    };
-    mkdirSync11(CLAUDISH_CACHE_DIR2, { recursive: true });
-    writeFileSync13(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)}`);
-    console.error("   Using cached models (if available)");
   }
-}
-async function checkAndUpdateModelsCache(forceUpdate = false) {
-  if (forceUpdate) {
-    console.error("\uD83D\uDD04 Force update requested...");
-    await updateModelsFromOpenRouter();
-    return;
+  if (fast.length > 0) {
+    if (flagship.length > 0)
+      console.log("");
+    console.log("Fast variants");
+    console.log("  " + "\u2500".repeat(70));
+    for (let i = 0;i < fast.length; i++) {
+      renderGroup(fast[i]);
+      if (i < fast.length - 1)
+        console.log("");
+    }
   }
-  if (isCacheStale()) {
-    console.error("\u26A0\uFE0F  Model cache is stale (>2 days old), updating...");
-    await updateModelsFromOpenRouter();
-  } else {
-    try {
-      const cachePath = existsSync24(CACHED_MODELS_PATH) ? CACHED_MODELS_PATH : BUNDLED_MODELS_PATH;
-      const data = JSON.parse(readFileSync20(cachePath, "utf-8"));
-      console.error(`\u2713 Using cached models (last updated: ${data.lastUpdated})`);
-    } catch {}
+  console.log("");
+  console.log("  Capabilities: \uD83D\uDD27 Tools  \uD83E\uDDE0 Reasoning  \uD83D\uDC41\uFE0F  Vision");
+  const primaries = [...flagship, ...fast].map((g2) => g2.primary);
+  const picks = computeQuickPicks(primaries);
+  const pickLines = [];
+  if (picks.budget)
+    pickLines.push(`    Budget       \u2192 ${picks.budget.id} (${normalizePricingDisplay(picks.budget.pricing?.average)})`);
+  if (picks.largeContext)
+    pickLines.push(`    Large ctx    \u2192 ${picks.largeContext.id} (${picks.largeContext.context || "N/A"})`);
+  if (picks.mostCapable)
+    pickLines.push(`    Most capable \u2192 ${picks.mostCapable.id}`);
+  if (picks.visionCoding)
+    pickLines.push(`    Vision+code  \u2192 ${picks.visionCoding.id}`);
+  if (picks.agentic)
+    pickLines.push(`    Agentic      \u2192 ${picks.agentic.id}`);
+  if (pickLines.length > 0) {
+    console.log("");
+    console.log("  Quick picks:");
+    for (const line of pickLines)
+      console.log(line);
   }
+  console.log("");
+  console.log("  Set default:  export CLAUDISH_MODEL=<model>");
+  console.log("                 or:  claudish --model <model> ...");
+  console.log("");
+  console.log("  For more: claudish --list-models                (browse full catalog)");
+  console.log("            claudish --list-providers              (list all providers + counts)");
+  console.log("            claudish -s <query>                    (search by keyword)");
+  console.log("            claudish --top-models --force-update   (refresh from Firebase)");
+  console.log("");
 }
 function printVersion() {
   console.log(`claudish version ${VERSION}`);
@@ -101563,9 +101482,15 @@ OPTIONS:
   --cost-tracker           Enable cost tracking for API usage (NB!)
   --audit-costs            Show cost analysis report
   --reset-costs            Reset accumulated cost statistics
-  --models                 List ALL models (OpenRouter + OpenCode Zen + Ollama)
-  --models <query>         Fuzzy search all models by name, ID, or description
-  --top-models             List recommended/top programming models (curated)
+  --list-models            Top 100 ranked models from Firebase + local providers
+  --list-models --provider <slug>
+                           Filter Firebase catalog to one provider
+                           (e.g. --provider opencode-zen, --provider anthropic)
+  --list-providers         List every provider + active-model count
+  -s, --search <query>     Search Firebase catalog by keyword \u2014 matches model ID,
+                           brand synonyms (chatgpt, claude, grok), gateway names
+                           (zen, oc, codex), or capabilities (reasoning, vision, free)
+  --top-models             List the curated recommended models (flagship + fast)
   --team <models>          Run multiple models in parallel (comma-separated)
                            Example: --team minimax-m2.5,kimi-k2.5 "prompt"
   --mode <mode>            Team mode: default (grid), interactive, json
@@ -101574,7 +101499,7 @@ OPTIONS:
                            1-token request (diagnostic, may incur tiny cost)
   --no-probe               Skip live requests, show static chain only
   --probe-timeout <secs>   Per-link timeout for live probes (default: 40)
-  --json                   Output in JSON format (use with --models, --top-models, --probe)
+  --json                   Output in JSON format (use with --list-models, --top-models, --probe)
   --force-update           Force refresh model cache from OpenRouter API
   --version                Show version information
   -h, --help               Show this help message
@@ -101623,7 +101548,7 @@ MODEL MAPPING (per-role override):
   --model-subagent <model> Model for sub-agents (Task tool)
 
 CUSTOM MODELS:
-  Claudish accepts ANY valid OpenRouter model ID, even if not in --list-models
+  Claudish accepts ANY valid model ID from the Firebase catalog, even if not in --list-models
   Example: claudish --model openrouter@your_provider/custom-model-123 "task"
 
 MODES:
@@ -101791,14 +101716,14 @@ LOCAL MODELS (Ollama, LM Studio, vLLM):
   OLLAMA_HOST=http://192.168.1.50:11434 claudish --model ollama/llama3.2 "task"
 
 AVAILABLE MODELS:
-  List all models:     claudish --models  (includes OpenRouter, OpenCode Zen, Ollama)
-  Search models:       claudish --models <query>
-  Top recommended:     claudish --top-models
+  Top 100 ranked:      claudish --list-models                 (Firebase-ranked list + local providers)
+  By provider:         claudish --list-models --provider <slug>  (e.g. opencode-zen, anthropic, openai, google, x-ai)
+  All providers:       claudish --list-providers              (every provider + active-model count)
+  Search models:       claudish -s <query>                    (fuzzy: id, brand synonyms, gateways, capabilities)
+  Top recommended:     claudish --top-models                  (curated flagship + fast)
   Probe routing:       claudish --probe minimax-m2.5 kimi-k2.5 gemini-3.1-pro-preview
-  Free models only:    claudish --free  (interactive selector with free models)
-  JSON output:         claudish --models --json
-  Force cache update:  claudish --models --force-update
-  (Cache auto-updates every 2 days)
+  Free models only:    claudish --free                        (interactive selector with free models)
+  JSON output:         claudish --list-models --json | claudish --top-models --json
 
 MORE INFO:
   GitHub: https://github.com/MadAppGang/claude-code
@@ -101846,15 +101771,15 @@ async function initializeClaudishSkill() {
   }
   try {
     if (!existsSync24(claudeDir)) {
-      mkdirSync11(claudeDir, { recursive: true });
+      mkdirSync10(claudeDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/ directory");
     }
     if (!existsSync24(skillsDir)) {
-      mkdirSync11(skillsDir, { recursive: true });
+      mkdirSync10(skillsDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/ directory");
     }
     if (!existsSync24(claudishSkillDir)) {
-      mkdirSync11(claudishSkillDir, { recursive: true });
+      mkdirSync10(claudishSkillDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/claudish-usage/ directory");
     }
     copyFileSync(sourceSkillPath, skillFile);
@@ -101893,151 +101818,27 @@ async function initializeClaudishSkill() {
   }
 }
 function printAvailableModels() {
-  let lastUpdated = "unknown";
-  let models = [];
   try {
-    const cachePath = existsSync24(CACHED_MODELS_PATH) ? CACHED_MODELS_PATH : BUNDLED_MODELS_PATH;
-    if (existsSync24(cachePath)) {
-      const data = JSON.parse(readFileSync20(cachePath, "utf-8"));
-      lastUpdated = data.lastUpdated || "unknown";
-      models = data.models || [];
-    }
-  } catch {
     const basicModels = getAvailableModels();
     const modelInfo = loadModelInfo();
+    console.log("\nAvailable models (type `claudish --top-models` for full table):\n");
     for (const model of basicModels) {
       const info = modelInfo[model];
+      if (!info)
+        continue;
       console.log(`  ${model}`);
       console.log(`    ${info.name} - ${info.description}`);
-      console.log("");
     }
-    return;
-  }
-  console.log(`
-Recommended Models (last updated: ${lastUpdated}):
-`);
-  console.log("  Model                        Pricing     Context  Capabilities");
-  console.log("  " + "\u2500".repeat(66));
-  for (const model of models) {
-    const modelId = model.id.length > 28 ? model.id.substring(0, 25) + "..." : model.id;
-    const modelIdPadded = modelId.padEnd(28);
-    let pricing = model.pricing?.average || "N/A";
-    if (pricing.includes("-1000000")) {
-      pricing = "varies";
-    } else if (pricing === "$0.00/1M" || pricing === "FREE") {
-      pricing = "FREE";
-    }
-    const pricingPadded = pricing.padEnd(10);
-    const context = model.context || "N/A";
-    const contextPadded = context.padEnd(7);
-    const tools = model.supportsTools ? "\uD83D\uDD27" : "  ";
-    const reasoning = model.supportsReasoning ? "\uD83E\uDDE0" : "  ";
-    const vision = model.supportsVision ? "\uD83D\uDC41\uFE0F " : "  ";
-    const capabilities = `${tools} ${reasoning} ${vision}`;
-    console.log(`  ${modelIdPadded} ${pricingPadded} ${contextPadded} ${capabilities}`);
-  }
-  console.log("");
-  console.log("  Capabilities: \uD83D\uDD27 Tools  \uD83E\uDDE0 Reasoning  \uD83D\uDC41\uFE0F  Vision");
-  console.log("");
-  console.log("Set default with: export CLAUDISH_MODEL=<model>");
-  console.log("               or: export ANTHROPIC_MODEL=<model>");
-  console.log("Or use: claudish --model <model> ...");
-  console.log(`
-Force update: claudish --list-models --force-update
-`);
-}
-function printAvailableModelsJSON() {
-  const jsonPath = existsSync24(CACHED_MODELS_PATH) ? CACHED_MODELS_PATH : BUNDLED_MODELS_PATH;
-  try {
-    const jsonContent = readFileSync20(jsonPath, "utf-8");
-    const data = JSON.parse(jsonContent);
-    console.log(JSON.stringify(data, null, 2));
+    console.log("");
   } catch (error2) {
-    const models = getAvailableModels();
-    const modelInfo = loadModelInfo();
-    const output = {
-      version: VERSION,
-      lastUpdated: new Date().toISOString().split("T")[0],
-      source: "runtime",
-      models: models.filter((m2) => m2 !== "custom").map((modelId) => {
-        const info = modelInfo[modelId];
-        return {
-          id: modelId,
-          name: info.name,
-          description: info.description,
-          provider: info.provider,
-          priority: info.priority
-        };
-      })
-    };
-    console.log(JSON.stringify(output, null, 2));
+    console.error(`Failed to load available models: ${error2 instanceof Error ? error2.message : String(error2)}`);
   }
 }
-async function fetchZenModels() {
-  try {
-    const response = await fetch("https://models.dev/api.json", {
-      signal: AbortSignal.timeout(1e4)
-    });
-    if (!response.ok) {
-      return [];
-    }
-    const data = await response.json();
-    const opencode = data.opencode;
-    if (!opencode?.models)
-      return [];
-    return Object.entries(opencode.models).map(([id, m2]) => {
-      const isFree = m2.cost?.input === 0 && m2.cost?.output === 0;
-      return {
-        id: `zen/${id}`,
-        name: m2.name || id,
-        context_length: m2.limit?.context || 128000,
-        max_output: m2.limit?.output || 32000,
-        pricing: isFree ? { prompt: "0", completion: "0" } : { prompt: String(m2.cost?.input || 0), completion: String(m2.cost?.output || 0) },
-        isZen: true,
-        isFree,
-        supportsTools: m2.tool_call || false,
-        supportsReasoning: m2.reasoning || false
-      };
-    });
-  } catch {
-    return [];
-  }
-}
-async function fetchGLMCodingModels() {
-  try {
-    const response = await fetch("https://models.dev/api.json", {
-      signal: AbortSignal.timeout(5000)
-    });
-    if (!response.ok) {
-      return [];
-    }
-    const data = await response.json();
-    const codingPlan = data["zai-coding-plan"];
-    if (!codingPlan?.models)
-      return [];
-    return Object.entries(codingPlan.models).map(([id, m2]) => {
-      const inputModalities = m2.modalities?.input || [];
-      return {
-        id: `gc/${id}`,
-        name: m2.name || id,
-        description: `GLM Coding Plan model (subscription)`,
-        context_length: m2.limit?.context || 131072,
-        pricing: { prompt: "0", completion: "0" },
-        isGLMCoding: true,
-        isSubscription: true,
-        supportsTools: m2.tool_call || false,
-        supportsReasoning: m2.reasoning || false,
-        supportsVision: inputModalities.includes("image") || inputModalities.includes("video")
-      };
-    });
-  } catch {
-    return [];
-  }
-}
-var __filename4, __dirname4, CACHE_MAX_AGE_DAYS2 = 2, CLAUDISH_CACHE_DIR2, BUNDLED_MODELS_PATH, CACHED_MODELS_PATH, ALL_MODELS_JSON_PATH;
+var __filename4, __dirname4;
 var init_cli = __esm(async () => {
   init_config();
   init_model_loader();
+  init_provider_definitions();
   init_profile_config();
   init_model_parser();
   init_auto_route();
@@ -102050,10 +101851,6 @@ var init_cli = __esm(async () => {
   await init_probe_tui_runtime();
   __filename4 = fileURLToPath4(import.meta.url);
   __dirname4 = dirname5(__filename4);
-  CLAUDISH_CACHE_DIR2 = join25(homedir23(), ".claudish");
-  BUNDLED_MODELS_PATH = join25(__dirname4, "../recommended-models.json");
-  CACHED_MODELS_PATH = join25(CLAUDISH_CACHE_DIR2, "recommended-models.json");
-  ALL_MODELS_JSON_PATH = join25(CLAUDISH_CACHE_DIR2, "all-models.json");
 });
 
 // src/update-checker.ts
@@ -102064,7 +101861,7 @@ __export(exports_update_checker, {
   clearCache: () => clearCache,
   checkForUpdates: () => checkForUpdates
 });
-import { existsSync as existsSync26, mkdirSync as mkdirSync12, readFileSync as readFileSync21, unlinkSync as unlinkSync8, writeFileSync as writeFileSync14 } from "fs";
+import { existsSync as existsSync26, mkdirSync as mkdirSync11, readFileSync as readFileSync21, unlinkSync as unlinkSync8, writeFileSync as writeFileSync12 } from "fs";
 import { homedir as homedir24, platform as platform2, tmpdir } from "os";
 import { join as join26 } from "path";
 function getCacheFilePath() {
@@ -102077,7 +101874,7 @@ function getCacheFilePath() {
   }
   try {
     if (!existsSync26(cacheDir)) {
-      mkdirSync12(cacheDir, { recursive: true });
+      mkdirSync11(cacheDir, { recursive: true });
     }
     return join26(cacheDir, "update-check.json");
   } catch {
@@ -102103,7 +101900,7 @@ function writeCache(latestVersion) {
       lastCheck: Date.now(),
       latestVersion
     };
-    writeFileSync14(cachePath, JSON.stringify(data), "utf-8");
+    writeFileSync12(cachePath, JSON.stringify(data), "utf-8");
   } catch {}
 }
 function isCacheValid(cache) {
@@ -102414,218 +102211,36 @@ __export(exports_model_selector, {
   promptForApiKey: () => promptForApiKey,
   confirmAction: () => confirmAction
 });
-import { readFileSync as readFileSync22, writeFileSync as writeFileSync15, existsSync as existsSync27, mkdirSync as mkdirSync13 } from "fs";
-import { join as join27, dirname as dirname6 } from "path";
-import { homedir as homedir25 } from "os";
-import { fileURLToPath as fileURLToPath5 } from "url";
-function loadRecommendedModels2() {
-  const cachedPath = join27(CLAUDISH_CACHE_DIR3, "recommended-models-cache.json");
-  if (existsSync27(cachedPath)) {
-    try {
-      const data = JSON.parse(readFileSync22(cachedPath, "utf-8"));
-      if (data.models && data.models.length > 0) {
-        return data.models.map((model) => ({
-          ...model,
-          source: "Recommended"
-        }));
-      }
-    } catch {}
-  }
-  if (existsSync27(RECOMMENDED_MODELS_JSON_PATH)) {
-    try {
-      const content = readFileSync22(RECOMMENDED_MODELS_JSON_PATH, "utf-8");
-      const data = JSON.parse(content);
-      return (data.models || []).map((model) => ({
-        ...model,
-        source: "Recommended"
-      }));
-    } catch {
-      return [];
-    }
-  }
-  return [];
-}
-async function fetchAllModels(forceUpdate = false) {
-  if (!forceUpdate && existsSync27(ALL_MODELS_JSON_PATH2)) {
-    try {
-      const cacheData = JSON.parse(readFileSync22(ALL_MODELS_JSON_PATH2, "utf-8"));
-      const lastUpdated = new Date(cacheData.lastUpdated);
-      const now = new Date;
-      const ageInDays = (now.getTime() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24);
-      if (ageInDays <= CACHE_MAX_AGE_DAYS3) {
-        return cacheData.models;
-      }
-    } catch {}
-  }
-  console.log("Fetching models from OpenRouter...");
-  try {
-    const response = await fetch("https://openrouter.ai/api/v1/models");
-    if (!response.ok)
-      throw new Error(`API returned ${response.status}`);
-    const data = await response.json();
-    const models = data.data;
-    mkdirSync13(CLAUDISH_CACHE_DIR3, { recursive: true });
-    writeFileSync15(ALL_MODELS_JSON_PATH2, JSON.stringify({
-      lastUpdated: new Date().toISOString(),
-      models
-    }), "utf-8");
-    console.log(`Cached ${models.length} models`);
-    return models;
-  } catch (error2) {
-    console.error(`Failed to fetch models: ${error2}`);
-    return [];
-  }
-}
-function toModelInfo(model) {
-  const provider = model.id.split("/")[0];
-  const contextLen = model.context_length || model.top_provider?.context_length || 0;
-  const promptPrice = parseFloat(model.pricing?.prompt || "0");
-  const completionPrice = parseFloat(model.pricing?.completion || "0");
-  const isFree = promptPrice === 0 && completionPrice === 0;
-  let pricingStr = "N/A";
-  if (isFree) {
-    pricingStr = "FREE";
-  } else if (model.pricing) {
-    const avgPrice = (promptPrice + completionPrice) / 2;
-    if (avgPrice < 0.001) {
-      pricingStr = `$${(avgPrice * 1e6).toFixed(2)}/1M`;
-    } else {
-      pricingStr = `$${avgPrice.toFixed(4)}/1K`;
-    }
-  }
-  return {
-    id: `openrouter@${model.id}`,
-    name: model.name || model.id,
-    description: model.description || "",
-    provider: provider.charAt(0).toUpperCase() + provider.slice(1),
-    pricing: {
-      input: model.pricing?.prompt || "N/A",
-      output: model.pricing?.completion || "N/A",
-      average: pricingStr
-    },
-    context: contextLen > 0 ? `${Math.round(contextLen / 1000)}K` : "N/A",
-    contextLength: contextLen,
-    supportsTools: (model.supported_parameters || []).includes("tools"),
-    supportsReasoning: (model.supported_parameters || []).includes("reasoning"),
-    supportsVision: (model.architecture?.input_modalities || []).includes("image"),
-    isFree,
-    source: "OpenRouter"
-  };
-}
-async function fetchZenGoModels() {
-  const apiKey = process.env.OPENCODE_API_KEY;
-  if (!apiKey)
-    return [];
-  const ZEN_GO_BASE = process.env.OPENCODE_BASE_URL ? process.env.OPENCODE_BASE_URL.replace("/zen", "/zen/go") : "https://opencode.ai/zen/go";
+function loadRecommendedModels() {
   try {
-    const mdevResp = await fetch("https://models.dev/api.json", {
-      signal: AbortSignal.timeout(5000)
-    });
-    if (!mdevResp.ok)
-      return [];
-    const mdevData = await mdevResp.json();
-    const ocModels = mdevData?.opencode?.models ?? {};
-    const candidateIds = Object.keys(ocModels);
-    const fallbackIds = ["glm-5"];
-    const probeResults = await Promise.all(candidateIds.map(async (modelId) => {
-      try {
-        const r = await fetch(`${ZEN_GO_BASE}/v1/chat/completions`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
-          body: JSON.stringify({
-            model: modelId,
-            messages: [{ role: "user", content: "hi" }],
-            max_tokens: 1
-          }),
-          signal: AbortSignal.timeout(8000)
-        });
-        if (!r.ok)
-          return null;
-        const body = await r.json().catch(() => ({}));
-        return Array.isArray(body?.choices) && body.choices.length > 0 ? modelId : null;
-      } catch {
-        return null;
-      }
+    const doc2 = getRecommendedModelsSync();
+    return doc2.models.map((model) => ({
+      id: model.id,
+      name: model.name,
+      description: model.description,
+      provider: model.provider,
+      pricing: model.pricing,
+      context: model.context,
+      contextLength: parseContextString(model.context),
+      supportsTools: model.supportsTools,
+      supportsReasoning: model.supportsReasoning,
+      supportsVision: model.supportsVision,
+      source: "Recommended"
     }));
-    const discoveredIds = probeResults.filter(Boolean);
-    const goModelIds = discoveredIds.length > 0 ? discoveredIds : fallbackIds;
-    return goModelIds.map((id) => {
-      const m2 = ocModels[id];
-      if (!m2)
-        return null;
-      const inputModalities = m2.modalities?.input ?? [];
-      return {
-        id: `zgo@${id}`,
-        name: m2.name || id,
-        description: `OpenCode Zen Go plan model`,
-        provider: "Zen Go",
-        pricing: { input: "PLAN", output: "PLAN", average: "PLAN" },
-        context: m2.limit?.context ? `${Math.round(m2.limit.context / 1000)}K` : "128K",
-        contextLength: m2.limit?.context || 128000,
-        supportsTools: m2.tool_call === true,
-        supportsReasoning: m2.reasoning || false,
-        supportsVision: inputModalities.includes("image") || inputModalities.includes("video"),
-        isFree: false,
-        source: "Zen"
-      };
-    }).filter(Boolean);
   } catch {
     return [];
   }
 }
-async function fetchZenFreeModels() {
-  try {
-    const ZEN_BASE = process.env.OPENCODE_BASE_URL || "https://opencode.ai/zen";
-    const ZEN_API_KEY = process.env.OPENCODE_API_KEY || "public";
-    const [mdevResp, liveResp] = await Promise.all([
-      fetch("https://models.dev/api.json", { signal: AbortSignal.timeout(5000) }),
-      fetch(`${ZEN_BASE}/v1/models`, {
-        headers: { Authorization: `Bearer ${ZEN_API_KEY}` },
-        signal: AbortSignal.timeout(5000)
-      })
-    ]);
-    if (!mdevResp.ok)
-      return [];
-    const mdevData = await mdevResp.json();
-    const opencode = mdevData.opencode;
-    if (!opencode?.models)
-      return [];
-    const liveIds = new Set;
-    if (liveResp.ok) {
-      const liveData = await liveResp.json();
-      for (const m2 of liveData.data ?? [])
-        liveIds.add(m2.id);
-    }
-    return Object.entries(opencode.models).filter(([id, m2]) => {
-      const isFree = m2.cost?.input === 0 && m2.cost?.output === 0;
-      const supportsTools = m2.tool_call === true;
-      const isLive = liveIds.size === 0 || liveIds.has(id);
-      return isFree && supportsTools && isLive;
-    }).map(([id, m2]) => {
-      const inputModalities = m2.modalities?.input || [];
-      const supportsVision = inputModalities.includes("image") || inputModalities.includes("video");
-      return {
-        id: `zen@${id}`,
-        name: m2.name || id,
-        description: `OpenCode Zen free model`,
-        provider: "Zen",
-        pricing: {
-          input: "FREE",
-          output: "FREE",
-          average: "FREE"
-        },
-        context: m2.limit?.context ? `${Math.round(m2.limit.context / 1000)}K` : "128K",
-        contextLength: m2.limit?.context || 128000,
-        supportsTools: true,
-        supportsReasoning: m2.reasoning || false,
-        supportsVision,
-        isFree: true,
-        source: "Zen"
-      };
-    });
-  } catch {
-    return [];
-  }
+function parseContextString(ctx) {
+  if (!ctx || ctx === "N/A")
+    return 0;
+  const upper = ctx.toUpperCase();
+  if (upper.endsWith("M"))
+    return parseFloat(upper) * 1e6;
+  if (upper.endsWith("K"))
+    return parseFloat(upper) * 1000;
+  const n = parseInt(upper, 10);
+  return isNaN(n) ? 0 : n;
 }
 function getXAIContextWindow(modelId) {
   const id = modelId.toLowerCase();
@@ -102776,239 +102391,15 @@ async function fetchGeminiModels() {
     return [];
   }
 }
-async function fetchOpenAIModels() {
-  const apiKey = process.env.OPENAI_API_KEY;
-  if (!apiKey) {
-    return [];
-  }
-  try {
-    const response = await fetch("https://models.dev/api.json", {
-      signal: AbortSignal.timeout(5000)
-    });
-    if (!response.ok) {
-      return [];
-    }
-    const data = await response.json();
-    const openaiData = data.openai;
-    if (!openaiData?.models)
-      return [];
-    return Object.entries(openaiData.models).filter(([id, _2]) => {
-      const lowerId = id.toLowerCase();
-      return lowerId.startsWith("gpt-") || lowerId.startsWith("o1-") || lowerId.startsWith("o3-") || lowerId.startsWith("o4-") || lowerId.startsWith("chatgpt-");
-    }).map(([id, m2]) => {
-      const inputCost = m2.cost?.input || 2;
-      const outputCost = m2.cost?.output || 8;
-      const avgCost = (inputCost + outputCost) / 2;
-      const contextLength = m2.limit?.context || 128000;
-      const contextStr = contextLength >= 1e6 ? `${Math.round(contextLength / 1e6)}M` : `${Math.round(contextLength / 1000)}K`;
-      const inputModalities = m2.modalities?.input || [];
-      const supportsVision = inputModalities.includes("image") || inputModalities.includes("video");
-      return {
-        id: `oai@${id}`,
-        name: m2.name || id,
-        description: `OpenAI model`,
-        provider: "OpenAI",
-        pricing: {
-          input: `$${inputCost.toFixed(2)}`,
-          output: `$${outputCost.toFixed(2)}`,
-          average: `$${avgCost.toFixed(2)}/1M`
-        },
-        context: contextStr,
-        contextLength,
-        supportsTools: m2.tool_call === true,
-        supportsReasoning: m2.reasoning === true,
-        supportsVision,
-        isFree: false,
-        source: "OpenAI"
-      };
-    });
-  } catch {
-    return [];
-  }
-}
-async function fetchGLMCodingModels2() {
-  const apiKey = process.env.GLM_CODING_API_KEY;
-  if (!apiKey) {
-    return [];
-  }
-  try {
-    const response = await fetch("https://models.dev/api.json", {
-      signal: AbortSignal.timeout(5000)
-    });
-    if (!response.ok) {
-      return [];
-    }
-    const data = await response.json();
-    const codingPlan = data["zai-coding-plan"];
-    if (!codingPlan?.models)
-      return [];
-    return Object.entries(codingPlan.models).filter(([_2, m2]) => m2.tool_call === true).map(([id, m2]) => {
-      const inputModalities = m2.modalities?.input || [];
-      const supportsVision = inputModalities.includes("image") || inputModalities.includes("video");
-      const contextLength = m2.limit?.context || 131072;
-      return {
-        id: `gc@${id}`,
-        name: m2.name || id,
-        description: `GLM Coding Plan (subscription)`,
-        provider: "GLM Coding",
-        pricing: {
-          input: "SUB",
-          output: "SUB",
-          average: "SUB"
-        },
-        context: contextLength >= 1e6 ? `${Math.round(contextLength / 1e6)}M` : `${Math.round(contextLength / 1000)}K`,
-        contextLength,
-        supportsTools: true,
-        supportsReasoning: m2.reasoning || false,
-        supportsVision,
-        isFree: false,
-        source: "GLM Coding"
-      };
-    });
-  } catch {
-    return [];
-  }
-}
-async function fetchGLMDirectModels() {
-  try {
-    const response = await fetch("https://models.dev/api.json", {
-      signal: AbortSignal.timeout(5000)
-    });
-    if (!response.ok) {
-      return [];
-    }
-    const data = await response.json();
-    const codingPlan = data["zai-coding-plan"];
-    if (!codingPlan?.models)
-      return [];
-    return Object.entries(codingPlan.models).filter(([_2, m2]) => m2.tool_call === true).map(([id, m2]) => {
-      const inputModalities = m2.modalities?.input || [];
-      const supportsVision = inputModalities.includes("image") || inputModalities.includes("video");
-      const contextLength = m2.limit?.context || 131072;
-      const inputCost = m2.cost?.input || 0;
-      const outputCost = m2.cost?.output || 0;
-      const isFree = inputCost === 0 && outputCost === 0;
-      return {
-        id: `glm@${id}`,
-        name: m2.name || id,
-        description: `GLM/Zhipu direct API`,
-        provider: "GLM",
-        pricing: {
-          input: isFree ? "FREE" : `$${inputCost.toFixed(2)}`,
-          output: isFree ? "FREE" : `$${outputCost.toFixed(2)}`,
-          average: isFree ? "FREE" : `$${((inputCost + outputCost) / 2).toFixed(2)}/1M`
-        },
-        context: contextLength >= 1e6 ? `${Math.round(contextLength / 1e6)}M` : `${Math.round(contextLength / 1000)}K`,
-        contextLength,
-        supportsTools: true,
-        supportsReasoning: m2.reasoning || false,
-        supportsVision,
-        isFree,
-        source: "GLM"
-      };
-    });
-  } catch {
-    return [];
-  }
-}
-async function fetchOllamaCloudModels() {
-  try {
-    const response = await fetch("https://models.dev/api.json", {
-      signal: AbortSignal.timeout(5000)
-    });
-    if (!response.ok) {
-      return [];
-    }
-    const data = await response.json();
-    const ollamaCloud = data["ollama-cloud"];
-    if (!ollamaCloud?.models)
-      return [];
-    return Object.entries(ollamaCloud.models).filter(([_2, m2]) => m2.tool_call === true).map(([id, m2]) => {
-      const inputModalities = m2.modalities?.input || [];
-      const supportsVision = inputModalities.includes("image") || inputModalities.includes("video");
-      const contextLength = m2.limit?.context || 131072;
-      return {
-        id: `oc@${id}`,
-        name: m2.name || id,
-        description: `OllamaCloud`,
-        provider: "OllamaCloud",
-        pricing: {
-          input: "N/A",
-          output: "N/A",
-          average: "N/A"
-        },
-        context: contextLength >= 1e6 ? `${Math.round(contextLength / 1e6)}M` : `${Math.round(contextLength / 1000)}K`,
-        contextLength,
-        supportsTools: true,
-        supportsReasoning: m2.reasoning || false,
-        supportsVision,
-        source: "OllamaCloud"
-      };
-    });
-  } catch {
-    return [];
-  }
-}
-function shouldRefreshForFreeModels() {
-  if (!existsSync27(ALL_MODELS_JSON_PATH2)) {
-    return true;
-  }
-  try {
-    const cacheData = JSON.parse(readFileSync22(ALL_MODELS_JSON_PATH2, "utf-8"));
-    const lastUpdated = new Date(cacheData.lastUpdated);
-    const now = new Date;
-    const ageInHours = (now.getTime() - lastUpdated.getTime()) / (1000 * 60 * 60);
-    return ageInHours > FREE_MODELS_CACHE_MAX_AGE_HOURS;
-  } catch {
-    return true;
-  }
-}
 async function getFreeModels() {
-  const forceUpdate = shouldRefreshForFreeModels();
-  const [allModels, zenModels] = await Promise.all([
-    fetchAllModels(forceUpdate),
-    fetchZenFreeModels()
-  ]);
-  const openRouterFreeModels = allModels.filter((model) => {
-    if (!model.id?.endsWith(":free"))
-      return false;
-    const supportsTools = (model.supported_parameters || []).includes("tools");
-    if (!supportsTools)
-      return false;
-    return true;
-  });
-  openRouterFreeModels.sort((a, b2) => {
-    const contextA = a.context_length || a.top_provider?.context_length || 0;
-    const contextB = b2.context_length || b2.top_provider?.context_length || 0;
-    return contextB - contextA;
-  });
-  const openRouterModels = openRouterFreeModels.slice(0, 20).map(toModelInfo);
-  const combined = [...zenModels, ...openRouterModels];
-  combined.sort((a, b2) => {
-    if (a.source === "Zen" && b2.source !== "Zen")
-      return -1;
-    if (a.source !== "Zen" && b2.source === "Zen")
-      return 1;
-    return (b2.contextLength || 0) - (a.contextLength || 0);
-  });
-  return combined;
+  return [];
 }
 async function getAllModelsForSearch(forceUpdate = false) {
   const litellmBaseUrl = process.env.LITELLM_BASE_URL;
   const litellmApiKey = process.env.LITELLM_API_KEY;
   const allEntries = [
-    {
-      name: "OpenRouter",
-      promise: () => fetchAllModels(forceUpdate).then((models) => models.map(toModelInfo))
-    },
     { name: "xAI", provider: "xai", promise: () => fetchXAIModels() },
     { name: "Gemini", provider: "google", promise: () => fetchGeminiModels() },
-    { name: "OpenAI", provider: "openai", promise: () => fetchOpenAIModels() },
-    { name: "GLM", provider: "glm", promise: () => fetchGLMDirectModels() },
-    { name: "GLM Coding", provider: "glm-coding", promise: () => fetchGLMCodingModels2() },
-    { name: "OllamaCloud", provider: "ollamacloud", promise: () => fetchOllamaCloudModels() },
-    { name: "Zen", provider: "opencode-zen", promise: () => fetchZenFreeModels() },
-    { name: "Zen Go", provider: "opencode-zen-go", promise: () => fetchZenGoModels() },
     {
       name: "MiniMax",
       provider: "minimax",
@@ -103053,22 +102444,15 @@ async function getAllModelsForSearch(forceUpdate = false) {
   }
   const r = (name) => fetchResults[name] || [];
   const allModels = [
-    ...r("Zen"),
-    ...r("Zen Go"),
-    ...r("OllamaCloud"),
     ...r("xAI"),
     ...r("Gemini"),
-    ...r("OpenAI"),
     ...r("OpenAI Codex"),
-    ...r("GLM"),
-    ...r("GLM Coding"),
     ...r("MiniMax"),
     ...r("MiniMax Coding"),
     ...r("Kimi"),
     ...r("Kimi Coding"),
     ...r("Z.AI"),
-    ...r("LiteLLM"),
-    ...r("OpenRouter")
+    ...r("LiteLLM")
   ];
   return allModels;
 }
@@ -103164,23 +102548,17 @@ async function selectModel(options = {}) {
   } else {
     const [allModels, recommendedModels] = await Promise.all([
       getAllModelsForSearch(forceUpdate),
-      Promise.resolve(recommended ? loadRecommendedModels2() : [])
+      Promise.resolve(recommended ? loadRecommendedModels() : [])
     ]);
     const seenIds = new Set;
     models = [];
-    for (const m2 of allModels.filter((m3) => m3.source === "Zen")) {
-      if (!seenIds.has(m2.id)) {
-        seenIds.add(m2.id);
-        models.push(m2);
-      }
-    }
     for (const m2 of recommendedModels) {
       if (!seenIds.has(m2.id)) {
         seenIds.add(m2.id);
         models.push(m2);
       }
     }
-    for (const m2 of allModels.filter((m3) => m3.source && m3.source !== "Zen" && m3.source !== "OpenRouter")) {
+    for (const m2 of allModels.filter((m3) => m3.source && m3.source !== "OpenRouter")) {
       if (!seenIds.has(m2.id)) {
         seenIds.add(m2.id);
         models.push(m2);
@@ -103550,7 +102928,7 @@ async function selectModelsForProfile() {
 Loading available models...`);
   const [fetchedModels, recommendedModels] = await Promise.all([
     getAllModelsForSearch(),
-    Promise.resolve(loadRecommendedModels2())
+    Promise.resolve(loadRecommendedModels())
   ]);
   const tiers = [
     { key: "opus", name: "Opus", description: "Most capable, used for complex reasoning" },
@@ -103644,16 +103022,11 @@ async function selectProfile(profiles) {
 async function confirmAction(message) {
   return dist_default4({ message, default: false });
 }
-var __filename5, __dirname5, CLAUDISH_CACHE_DIR3, ALL_MODELS_JSON_PATH2, RECOMMENDED_MODELS_JSON_PATH, CACHE_MAX_AGE_DAYS3 = 2, FREE_MODELS_CACHE_MAX_AGE_HOURS = 3, PROVIDER_FILTER_ALIASES, ALL_PROVIDER_CHOICES, PROVIDER_MODEL_PREFIX, PROVIDER_SOURCE_FILTER;
+var PROVIDER_FILTER_ALIASES, ALL_PROVIDER_CHOICES, PROVIDER_MODEL_PREFIX, PROVIDER_SOURCE_FILTER;
 var init_model_selector = __esm(() => {
   init_dist17();
   init_model_loader();
   init_provider_definitions();
-  __filename5 = fileURLToPath5(import.meta.url);
-  __dirname5 = dirname6(__filename5);
-  CLAUDISH_CACHE_DIR3 = join27(homedir25(), ".claudish");
-  ALL_MODELS_JSON_PATH2 = join27(CLAUDISH_CACHE_DIR3, "all-models.json");
-  RECOMMENDED_MODELS_JSON_PATH = join27(__dirname5, "../recommended-models.json");
   PROVIDER_FILTER_ALIASES = {
     zen: "Zen",
     openrouter: "OpenRouter",
@@ -107310,9 +106683,9 @@ __export(exports_claude_runner, {
   checkClaudeInstalled: () => checkClaudeInstalled
 });
 import { spawn as spawn4 } from "child_process";
-import { writeFileSync as writeFileSync16, unlinkSync as unlinkSync9, mkdirSync as mkdirSync14, existsSync as existsSync28, readFileSync as readFileSync23 } from "fs";
-import { tmpdir as tmpdir2, homedir as homedir26 } from "os";
-import { join as join28 } from "path";
+import { writeFileSync as writeFileSync13, unlinkSync as unlinkSync9, mkdirSync as mkdirSync12, existsSync as existsSync27, readFileSync as readFileSync22 } from "fs";
+import { tmpdir as tmpdir2, homedir as homedir25 } from "os";
+import { join as join27 } from "path";
 function hasNativeAnthropicMapping(config3) {
   const models = [
     config3.model,
@@ -107328,9 +106701,9 @@ function isWindows2() {
 }
 function createStatusLineScript(tokenFilePath) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join28(homeDir, ".claudish");
+  const claudishDir = join27(homeDir, ".claudish");
   const timestamp = Date.now();
-  const scriptPath = join28(claudishDir, `status-${timestamp}.js`);
+  const scriptPath = join27(claudishDir, `status-${timestamp}.js`);
   const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
   const script = `
 const fs = require('fs');
@@ -107422,18 +106795,18 @@ process.stdin.on('end', () => {
   }
 });
 `;
-  writeFileSync16(scriptPath, script, "utf-8");
+  writeFileSync13(scriptPath, script, "utf-8");
   return scriptPath;
 }
 function createTempSettingsFile(modelDisplay, port) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join28(homeDir, ".claudish");
+  const claudishDir = join27(homeDir, ".claudish");
   try {
-    mkdirSync14(claudishDir, { recursive: true });
+    mkdirSync12(claudishDir, { recursive: true });
   } catch {}
   const timestamp = Date.now();
-  const tempPath = join28(claudishDir, `settings-${timestamp}.json`);
-  const tokenFilePath = join28(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);
@@ -107455,7 +106828,7 @@ function createTempSettingsFile(modelDisplay, port) {
     padding: 0
   };
   const settings = { statusLine };
-  writeFileSync16(tempPath, JSON.stringify(settings, null, 2), "utf-8");
+  writeFileSync13(tempPath, JSON.stringify(settings, null, 2), "utf-8");
   return { path: tempPath, statusLine };
 }
 function mergeUserSettingsIfPresent(config3, tempSettingsPath, statusLine) {
@@ -107469,11 +106842,11 @@ function mergeUserSettingsIfPresent(config3, tempSettingsPath, statusLine) {
     if (userSettingsValue.trimStart().startsWith("{")) {
       userSettings = JSON.parse(userSettingsValue);
     } else {
-      const rawUserSettings = readFileSync23(userSettingsValue, "utf-8");
+      const rawUserSettings = readFileSync22(userSettingsValue, "utf-8");
       userSettings = JSON.parse(rawUserSettings);
     }
     userSettings.statusLine = statusLine;
-    writeFileSync16(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
+    writeFileSync13(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
   } catch {
     if (!config3.quiet) {
       console.warn(`[claudish] Warning: could not merge user settings: ${userSettingsValue}`);
@@ -107561,13 +106934,14 @@ async function runClaudeWithProxy(config3, proxyUrl, onCleanup) {
     console.error("Install it from: https://claude.com/claude-code");
     console.error(`
 Or set CLAUDE_PATH to your custom installation:`);
-    const home = homedir26();
-    const localPath = isWindows2() ? join28(home, ".claude", "local", "claude.exe") : join28(home, ".claude", "local", "claude");
+    const home = homedir25();
+    const localPath = isWindows2() ? join27(home, ".claude", "local", "claude.exe") : join27(home, ".claude", "local", "claude");
     console.error(`  export CLAUDE_PATH=${localPath}`);
     process.exit(1);
   }
   const needsShell = isWindows2() && claudeBinary.endsWith(".cmd");
   const spawnCommand = needsShell ? `"${claudeBinary}"` : claudeBinary;
+  setClaudeCodeRunning(true);
   const proc = spawn4(spawnCommand, claudeArgs, {
     env: env2,
     stdio: "inherit",
@@ -107576,6 +106950,7 @@ Or set CLAUDE_PATH to your custom installation:`);
   setupSignalHandlers(proc, tempSettingsPath, config3.quiet, onCleanup);
   const exitCode = await new Promise((resolve4) => {
     proc.on("exit", (code) => {
+      setClaudeCodeRunning(false);
       resolve4(code ?? 1);
     });
   });
@@ -107608,23 +106983,23 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet, onCleanup) {
 async function findClaudeBinary() {
   const isWindows3 = process.platform === "win32";
   if (process.env.CLAUDE_PATH) {
-    if (existsSync28(process.env.CLAUDE_PATH)) {
+    if (existsSync27(process.env.CLAUDE_PATH)) {
       return process.env.CLAUDE_PATH;
     }
   }
-  const home = homedir26();
-  const localPath = isWindows3 ? join28(home, ".claude", "local", "claude.exe") : join28(home, ".claude", "local", "claude");
-  if (existsSync28(localPath)) {
+  const home = homedir25();
+  const localPath = isWindows3 ? join27(home, ".claude", "local", "claude.exe") : join27(home, ".claude", "local", "claude");
+  if (existsSync27(localPath)) {
     return localPath;
   }
   if (isWindows3) {
     const windowsPaths = [
-      join28(home, "AppData", "Roaming", "npm", "claude.cmd"),
-      join28(home, ".npm-global", "claude.cmd"),
-      join28(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 path3 of windowsPaths) {
-      if (existsSync28(path3)) {
+      if (existsSync27(path3)) {
         return path3;
       }
     }
@@ -107632,14 +107007,14 @@ async function findClaudeBinary() {
     const commonPaths = [
       "/usr/local/bin/claude",
       "/opt/homebrew/bin/claude",
-      join28(home, ".npm-global/bin/claude"),
-      join28(home, ".local/bin/claude"),
-      join28(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",
-      join28(home, "../usr/bin/claude")
+      join27(home, "../usr/bin/claude")
     ];
     for (const path3 of commonPaths) {
-      if (existsSync28(path3)) {
+      if (existsSync27(path3)) {
         return path3;
       }
     }
@@ -107679,6 +107054,7 @@ async function checkClaudeInstalled() {
 var init_claude_runner = __esm(() => {
   init_config();
   init_model_parser();
+  init_telemetry();
 });
 
 // src/diag-output.ts
@@ -107688,18 +107064,18 @@ __export(exports_diag_output, {
   NullDiagOutput: () => NullDiagOutput,
   LogFileDiagOutput: () => LogFileDiagOutput
 });
-import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync15, writeFileSync as writeFileSync17, unlinkSync as unlinkSync10 } from "fs";
-import { homedir as homedir27 } from "os";
-import { join as join29 } from "path";
+import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync13, writeFileSync as writeFileSync14, unlinkSync as unlinkSync10 } from "fs";
+import { homedir as homedir26 } from "os";
+import { join as join28 } from "path";
 function getClaudishDir() {
-  const dir = join29(homedir27(), ".claudish");
+  const dir = join28(homedir26(), ".claudish");
   try {
-    mkdirSync15(dir, { recursive: true });
+    mkdirSync13(dir, { recursive: true });
   } catch {}
   return dir;
 }
 function getDiagLogPath() {
-  return join29(getClaudishDir(), `diag-${process.pid}.log`);
+  return join28(getClaudishDir(), `diag-${process.pid}.log`);
 }
 
 class LogFileDiagOutput {
@@ -107708,7 +107084,7 @@ class LogFileDiagOutput {
   constructor() {
     this.logPath = getDiagLogPath();
     try {
-      writeFileSync17(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
+      writeFileSync14(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
 `);
     } catch {}
     this.stream = createWriteStream3(this.logPath, { flags: "a" });
@@ -107758,12 +107134,12 @@ __export(exports_team_grid, {
 });
 import { spawn as spawn5 } from "child_process";
 import {
-  existsSync as existsSync29,
-  readFileSync as readFileSync24,
-  writeFileSync as writeFileSync18
+  existsSync as existsSync28,
+  readFileSync as readFileSync23,
+  writeFileSync as writeFileSync15
 } from "fs";
-import { dirname as dirname7, join as join30 } from "path";
-import { fileURLToPath as fileURLToPath6 } from "url";
+import { dirname as dirname6, join as join29 } from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
 import { execSync as execSync2 } from "child_process";
 import { connect as netConnect } from "net";
 import { setTimeout as wait } from "timers/promises";
@@ -107848,22 +107224,22 @@ function buildPaneHeader(model, prompt, bg2) {
   return lines.join(" ");
 }
 function findMagmuxBinary() {
-  const thisFile = fileURLToPath6(import.meta.url);
-  const thisDir = dirname7(thisFile);
-  const pkgRoot = join30(thisDir, "..");
+  const thisFile = fileURLToPath5(import.meta.url);
+  const thisDir = dirname6(thisFile);
+  const pkgRoot = join29(thisDir, "..");
   const platform3 = process.platform;
   const arch = process.arch;
-  const bundledMagmux = join30(pkgRoot, "native", `magmux-${platform3}-${arch}`);
-  if (existsSync29(bundledMagmux))
+  const bundledMagmux = join29(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 = join30(searchDir, "node_modules", pkgName, "bin", "magmux");
-      if (existsSync29(candidate))
+      const candidate = join29(searchDir, "node_modules", pkgName, "bin", "magmux");
+      if (existsSync28(candidate))
         return candidate;
-      const parent = dirname7(searchDir);
+      const parent = dirname6(searchDir);
       if (parent === searchDir)
         break;
       searchDir = parent;
@@ -107880,7 +107256,7 @@ function findMagmuxBinary() {
 async function subscribeToMagmux(sockPath, onEvent) {
   let client = null;
   for (let attempt = 0;attempt < 40; attempt++) {
-    if (existsSync29(sockPath)) {
+    if (existsSync28(sockPath)) {
       try {
         client = await new Promise((resolve4, reject) => {
           const s = netConnect(sockPath);
@@ -107967,9 +107343,9 @@ async function runWithGrid(sessionPath, models, input, opts) {
   const keep = opts?.keep ?? false;
   const manifest = setupSession(sessionPath, models, input);
   const startedAt = new Date().toISOString();
-  const gridfilePath = join30(sessionPath, "gridfile.txt");
-  const prompt = readFileSync24(join30(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
-  const rawPrompt = readFileSync24(join30(sessionPath, "input.md"), "utf-8");
+  const gridfilePath = join29(sessionPath, "gridfile.txt");
+  const prompt = readFileSync23(join29(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
+  const rawPrompt = readFileSync23(join29(sessionPath, "input.md"), "utf-8");
   const usedBannerColors = new Set;
   const gridLines = Object.entries(manifest.models).map(([anonId]) => {
     const model = manifest.models[anonId].model;
@@ -107980,7 +107356,7 @@ async function runWithGrid(sessionPath, models, input, opts) {
     const header = buildPaneHeader(model, rawPrompt, bg2);
     return `${header} claudish --model ${model} -y --quiet '${prompt}'`;
   });
-  writeFileSync18(gridfilePath, gridLines.join(`
+  writeFileSync15(gridfilePath, gridLines.join(`
 `) + `
 `, "utf-8");
   const magmuxPath = findMagmuxBinary();
@@ -108000,8 +107376,8 @@ async function runWithGrid(sessionPath, models, input, opts) {
   });
   const [{ results }] = await Promise.all([subscription, procExit]);
   const status = buildTeamStatus(manifest, startedAt, results?.panes ?? null);
-  const statusPath = join30(sessionPath, "status.json");
-  writeFileSync18(statusPath, JSON.stringify(status, null, 2), "utf-8");
+  const statusPath = join29(sessionPath, "status.json");
+  writeFileSync15(statusPath, JSON.stringify(status, null, 2), "utf-8");
   return status;
 }
 var BANNER_BG_COLORS;
@@ -108023,16 +107399,16 @@ var init_team_grid = __esm(() => {
 
 // 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 join31 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync24 } from "fs";
+import { homedir as homedir27 } from "os";
+import { join as join30 } from "path";
 import_dotenv3.config({ quiet: true });
 function loadStoredApiKeys() {
   try {
-    const configPath = join31(homedir28(), ".claudish", "config.json");
-    if (!existsSync30(configPath))
+    const configPath = join30(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)) {
@@ -108146,14 +107522,14 @@ async function runCli() {
     if (cliConfig.team && cliConfig.team.length > 0) {
       let prompt = cliConfig.claudeArgs.join(" ");
       if (cliConfig.inputFile) {
-        prompt = readFileSync25(cliConfig.inputFile, "utf-8");
+        prompt = readFileSync24(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 = join31(process.cwd(), `.claudish-team-${Date.now()}`);
+      const sessionPath = join30(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);
@@ -108163,9 +107539,9 @@ async function runCli() {
         });
         const result = { ...status2, responses: {} };
         for (const anonId of Object.keys(status2.models)) {
-          const responsePath = join31(sessionPath, `response-${anonId}.md`);
+          const responsePath = join30(sessionPath, `response-${anonId}.md`);
           try {
-            const raw2 = readFileSync25(responsePath, "utf-8").trim();
+            const raw2 = readFileSync24(responsePath, "utf-8").trim();
             try {
               result.responses[anonId] = JSON.parse(raw2);
             } catch {