claudish 9.6.0 → 9.7.0

package/dist/index.js

@@ -715,7 +715,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "9.6.0";
+var VERSION = "9.7.0";
 
 // src/logger.ts
 import { appendFile, existsSync as existsSync2, mkdirSync, readdirSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
@@ -18165,10 +18165,122 @@ var init_stdio2 = __esm(() => {
   init_stdio();
 });
 
-// src/providers/all-models-cache.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
+// src/providers/catalog-compatibility.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir7 } from "os";
 import { dirname as dirname4, join as join7 } from "path";
+function parseContractEnvelope(body) {
+  if (!body || typeof body !== "object")
+    return { contractVersion: null };
+  const data = body;
+  const contractVersion = typeof data.contractVersion === "number" ? data.contractVersion : null;
+  const err = data.error;
+  const minimum = err && typeof err === "object" ? err.minimumContractVersion : undefined;
+  return {
+    contractVersion,
+    ...typeof minimum === "number" ? { minimumContractVersion: minimum } : {}
+  };
+}
+function isIncompatibleContractVersion(version) {
+  return typeof version === "number" && version > SUPPORTED_CONTRACT_VERSION;
+}
+function markCatalogIncompatible(info, path = CATALOG_INCOMPATIBLE_PATH) {
+  const record = {
+    detectedAt: new Date().toISOString(),
+    serverContractVersion: info.serverContractVersion,
+    clientContractVersion: SUPPORTED_CONTRACT_VERSION,
+    ...info.minimumContractVersion !== undefined ? { minimumContractVersion: info.minimumContractVersion } : {}
+  };
+  _memFlag = record;
+  _fileMemo = { path, value: record };
+  try {
+    mkdirSync5(dirname4(path), { recursive: true });
+    writeFileSync5(path, JSON.stringify(record), "utf-8");
+  } catch {}
+}
+function readCatalogIncompatibility(path = CATALOG_INCOMPATIBLE_PATH) {
+  if (_memFlag)
+    return _memFlag;
+  if (_fileMemo && _fileMemo.path === path)
+    return _fileMemo.value;
+  let value = null;
+  try {
+    if (existsSync5(path))
+      value = parseSentinelFile(readFileSync5(path, "utf-8"));
+  } catch {}
+  if (value !== null && isSentinelStale(value)) {
+    clearCatalogIncompatibility(path);
+    return null;
+  }
+  _fileMemo = { path, value };
+  return value;
+}
+function isSentinelStale(record) {
+  if (typeof record.minimumContractVersion === "number" && record.minimumContractVersion > SUPPORTED_CONTRACT_VERSION) {
+    return false;
+  }
+  if (record.serverContractVersion !== null) {
+    return record.serverContractVersion <= SUPPORTED_CONTRACT_VERSION;
+  }
+  if (typeof record.clientContractVersion === "number") {
+    return record.clientContractVersion < SUPPORTED_CONTRACT_VERSION;
+  }
+  return false;
+}
+function parseSentinelFile(raw) {
+  const unspecific = {
+    detectedAt: new Date(0).toISOString(),
+    serverContractVersion: null
+  };
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return unspecific;
+  }
+  if (!parsed || typeof parsed !== "object")
+    return unspecific;
+  const data = parsed;
+  return {
+    detectedAt: typeof data.detectedAt === "string" ? data.detectedAt : unspecific.detectedAt,
+    serverContractVersion: typeof data.serverContractVersion === "number" ? data.serverContractVersion : null,
+    ...typeof data.minimumContractVersion === "number" ? { minimumContractVersion: data.minimumContractVersion } : {},
+    ...typeof data.clientContractVersion === "number" ? { clientContractVersion: data.clientContractVersion } : {}
+  };
+}
+function clearCatalogIncompatibility(path = CATALOG_INCOMPATIBLE_PATH) {
+  _memFlag = null;
+  _fileMemo = { path, value: null };
+  try {
+    rmSync2(path, { force: true });
+  } catch {}
+}
+function catalogIncompatibilityMessage(i) {
+  const serverSays = typeof i.serverContractVersion === "number" ? `catalog contract version ${i.serverContractVersion}` : typeof i.minimumContractVersion === "number" ? `catalog contract version ${i.minimumContractVersion} or newer` : "a newer catalog contract";
+  return [
+    `This claudish build cannot read the model catalog. The catalog server publishes ${serverSays}; this build reads version ${SUPPORTED_CONTRACT_VERSION}.`,
+    "",
+    "Routing cannot tell which models your subscriptions cover, so continuing would send this request to a provider that bills per token without saying so.",
+    "",
+    "Run `claudish update` to get a build that reads the current catalog."
+  ].join(`
+`);
+}
+var SUPPORTED_CONTRACT_VERSION = 2, CATALOG_INCOMPATIBLE_PATH, _memFlag = null, _fileMemo = null, CatalogIncompatibleError;
+var init_catalog_compatibility = __esm(() => {
+  CATALOG_INCOMPATIBLE_PATH = join7(homedir7(), ".claudish", "catalog-incompatible.json");
+  CatalogIncompatibleError = class CatalogIncompatibleError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "CatalogIncompatibleError";
+    }
+  };
+});
+
+// src/providers/all-models-cache.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "fs";
+import { homedir as homedir8 } from "os";
+import { dirname as dirname5, join as join8 } from "path";
 function reasoningStatusOf(entry) {
   if (entry.reasoningStatus === "known" || entry.reasoningStatus === "unknown") {
     return entry.reasoningStatus;
@@ -18176,11 +18288,16 @@ function reasoningStatusOf(entry) {
   return entry.reasoning !== undefined ? "known" : "unknown";
 }
 function readAllModelsCache(path = ALL_MODELS_CACHE_PATH) {
-  if (!existsSync5(path))
+  if (readCatalogIncompatibility())
+    return null;
+  return readCacheFile(path);
+}
+function readCacheFile(path) {
+  if (!existsSync6(path))
     return null;
   let raw;
   try {
-    raw = JSON.parse(readFileSync5(path, "utf-8"));
+    raw = JSON.parse(readFileSync6(path, "utf-8"));
   } catch {
     return null;
   }
@@ -18202,7 +18319,7 @@ function readAllModelsCache(path = ALL_MODELS_CACHE_PATH) {
   };
 }
 function writeAllModelsCache(data, path = ALL_MODELS_CACHE_PATH) {
-  const existing = readAllModelsCache(path);
+  const existing = readCacheFile(path);
   const merged = {
     version: 2,
     lastUpdated: data.lastUpdated ?? new Date().toISOString(),
@@ -18211,12 +18328,13 @@ function writeAllModelsCache(data, path = ALL_MODELS_CACHE_PATH) {
     ...data.plans !== undefined || existing?.plans !== undefined ? { plans: data.plans ?? existing?.plans ?? [] } : {},
     ...data.catalogRevision !== undefined ? { catalogRevision: data.catalogRevision } : {}
   };
-  mkdirSync5(dirname4(path), { recursive: true });
-  writeFileSync5(path, JSON.stringify(merged), "utf-8");
+  mkdirSync6(dirname5(path), { recursive: true });
+  writeFileSync6(path, JSON.stringify(merged), "utf-8");
 }
 var ALL_MODELS_CACHE_PATH;
 var init_all_models_cache = __esm(() => {
-  ALL_MODELS_CACHE_PATH = join7(homedir7(), ".claudish", "all-models.json");
+  init_catalog_compatibility();
+  ALL_MODELS_CACHE_PATH = join8(homedir8(), ".claudish", "all-models.json");
 });
 
 // src/providers/model-ordering.ts
@@ -18370,19 +18488,25 @@ function resolveSubscriptionRouting(modelId, provider, cachePath) {
   if (providerPlans.length === 0)
     return { kind: "unknown" };
   const providerPlanIds = new Set(providerPlans.map((plan) => plan.id));
-  const hasMembership = entry.subscriptionPlans?.some((planId) => providerPlanIds.has(planId));
-  if (hasMembership) {
+  const memberships = entry.subscriptionPlans ?? [];
+  const includingPlans = providerPlans.filter((plan) => memberships.includes(plan.id));
+  if (includingPlans.length > 0) {
+    if (includingPlans.length < providerPlans.length)
+      return { kind: "unknown" };
     const agg = entry.aggregators?.find((a) => a.provider === provider);
     return agg?.externalId ? { kind: "serves", externalId: agg.externalId } : { kind: "unknown" };
   }
-  const hasPublishedProviderRoster = cache.entries.some((candidate) => candidate.subscriptionPlans?.some((planId) => providerPlanIds.has(planId)));
-  if (!hasPublishedProviderRoster)
+  const hasAnyMembershipRow = cache.entries.some((candidate) => candidate.subscriptionPlans?.some((planId) => providerPlanIds.has(planId)));
+  if (!hasAnyMembershipRow)
     return { kind: "unknown" };
   const vendorsInView = new Set(providerPlans.map((plan) => plan.provider).filter((v) => v !== undefined));
   const hasUnroutableSiblingPlan = (cache.plans ?? []).some((plan) => plan.provider !== undefined && vendorsInView.has(plan.provider) && plan.routing?.providerUid === undefined);
   if (hasUnroutableSiblingPlan)
     return { kind: "unknown" };
-  return providerPlans.every(isCatalogDiscoveredPlan) ? { kind: "not-served" } : { kind: "unknown" };
+  const hasCompleteMembershipView = providerPlans.every(isCatalogDiscoveredPlan);
+  if (!hasCompleteMembershipView)
+    return { kind: "unknown" };
+  return { kind: "not-served" };
 }
 function isCatalogDiscoveredPlan(plan) {
   return plan.modelDiscovery === "catalog";
@@ -18570,26 +18694,26 @@ var init_agent_availability = __esm(() => {
 });
 
 // src/profile-config.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "fs";
-import { homedir as homedir8 } from "os";
-import { dirname as dirname5, join as join8, parse as parse6 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "fs";
+import { homedir as homedir9 } from "os";
+import { dirname as dirname6, join as join9, parse as parse6 } from "path";
 function activeConfigFile() {
   return activeGlobalConfigFile(CONFIG_FILE);
 }
 function ensureConfigDir() {
-  if (!existsSync6(CONFIG_DIR)) {
-    mkdirSync6(CONFIG_DIR, { recursive: true });
+  if (!existsSync7(CONFIG_DIR)) {
+    mkdirSync7(CONFIG_DIR, { recursive: true });
   }
 }
 function loadConfig() {
   const activeFile = activeConfigFile();
   if (!getConfigFileOverride())
     ensureConfigDir();
-  if (!existsSync6(activeFile)) {
+  if (!existsSync7(activeFile)) {
     return { ...DEFAULT_CONFIG };
   }
   try {
-    const content = readFileSync6(activeFile, "utf-8");
+    const content = readFileSync7(activeFile, "utf-8");
     const config = JSON.parse(content);
     const merged = {
       version: config.version || DEFAULT_CONFIG.version,
@@ -18659,39 +18783,39 @@ function loadConfig() {
 function saveConfig(config) {
   if (!getConfigFileOverride())
     ensureConfigDir();
-  writeFileSync6(activeConfigFile(), JSON.stringify(config, null, 2), "utf-8");
+  writeFileSync7(activeConfigFile(), JSON.stringify(config, null, 2), "utf-8");
 }
 function configExists() {
-  return existsSync6(CONFIG_FILE);
+  return existsSync7(CONFIG_FILE);
 }
 function getConfigPath() {
   return CONFIG_FILE;
 }
 function getLocalConfigPath() {
-  const home = homedir8();
+  const home = homedir9();
   let dir = process.cwd();
   const root = parse6(dir).root;
   while (dir !== root && dir !== home) {
-    const candidate = join8(dir, LOCAL_CONFIG_FILENAME);
-    if (existsSync6(candidate))
+    const candidate = join9(dir, LOCAL_CONFIG_FILENAME);
+    if (existsSync7(candidate))
       return candidate;
-    if (existsSync6(join8(dir, ".git"))) {
+    if (existsSync7(join9(dir, ".git"))) {
       return candidate;
     }
-    dir = dirname5(dir);
+    dir = dirname6(dir);
   }
-  return join8(process.cwd(), LOCAL_CONFIG_FILENAME);
+  return join9(process.cwd(), LOCAL_CONFIG_FILENAME);
 }
 function localConfigExists() {
-  return existsSync6(getLocalConfigPath());
+  return existsSync7(getLocalConfigPath());
 }
 function readProOnUltracode(paths = defaultScopedConfigPaths) {
   for (const pathFn of [paths.project, paths.global]) {
     try {
       const path = pathFn();
-      if (!existsSync6(path))
+      if (!existsSync7(path))
         continue;
-      const parsed = JSON.parse(readFileSync6(path, "utf-8"));
+      const parsed = JSON.parse(readFileSync7(path, "utf-8"));
       if (typeof parsed?.proOnUltracode === "boolean")
         return parsed.proOnUltracode;
     } catch {}
@@ -18700,17 +18824,17 @@ function readProOnUltracode(paths = defaultScopedConfigPaths) {
 }
 function isProjectDirectory() {
   const cwd = process.cwd();
-  return [".git", "package.json", "Cargo.toml", "go.mod", "pyproject.toml", ".claudish.json"].some((f) => existsSync6(join8(cwd, f)));
+  return [".git", "package.json", "Cargo.toml", "go.mod", "pyproject.toml", ".claudish.json"].some((f) => existsSync7(join9(cwd, f)));
 }
 function loadLocalConfig() {
   if (getConfigFileOverride())
     return null;
   const localPath = getLocalConfigPath();
-  if (!existsSync6(localPath)) {
+  if (!existsSync7(localPath)) {
     return null;
   }
   try {
-    const content = readFileSync6(localPath, "utf-8");
+    const content = readFileSync7(localPath, "utf-8");
     const config = JSON.parse(content);
     return {
       ...config,
@@ -18728,7 +18852,7 @@ function saveLocalConfig(config) {
   if (toWrite.routing !== undefined && Object.keys(toWrite.routing).length === 0) {
     delete toWrite.routing;
   }
-  writeFileSync6(getLocalConfigPath(), JSON.stringify(toWrite, null, 2), "utf-8");
+  writeFileSync7(getLocalConfigPath(), JSON.stringify(toWrite, null, 2), "utf-8");
 }
 function loadConfigForScope(scope) {
   if (scope === "local") {
@@ -18976,8 +19100,8 @@ function disableLocalProvider(providerName) {
 }
 var CONFIG_DIR, CONFIG_FILE, LOCAL_CONFIG_FILENAME = ".claudish.json", DEFAULT_CONFIG, defaultScopedConfigPaths;
 var init_profile_config = __esm(() => {
-  CONFIG_DIR = join8(homedir8(), ".claudish");
-  CONFIG_FILE = join8(CONFIG_DIR, "config.json");
+  CONFIG_DIR = join9(homedir9(), ".claudish");
+  CONFIG_FILE = join9(CONFIG_DIR, "config.json");
   DEFAULT_CONFIG = {
     version: "1.0.0",
     defaultProfile: "default",
@@ -21200,10 +21324,34 @@ function keepOnlyRealTools(extracted, knownToolNames, decodeToolName) {
   }
   return kept;
 }
+function unwrapToolCallTags(body) {
+  if (!body.startsWith("<tool_call>"))
+    return null;
+  const blocks = [];
+  let cursor = 0;
+  while (cursor < body.length) {
+    TOOL_CALL_OPEN_AT_CURSOR.lastIndex = cursor;
+    if (!TOOL_CALL_OPEN_AT_CURSOR.exec(body))
+      return null;
+    cursor = TOOL_CALL_OPEN_AT_CURSOR.lastIndex;
+    const close = body.indexOf(TOOL_CALL_CLOSE_TAG, cursor);
+    const block = (close === -1 ? body.slice(cursor) : body.slice(cursor, close)).trim();
+    if (!block.startsWith("<function="))
+      return null;
+    blocks.push(block);
+    if (close === -1)
+      break;
+    cursor = close + TOOL_CALL_CLOSE_TAG.length;
+    cursor += /^\s*/.exec(body.slice(cursor))?.[0].length ?? 0;
+  }
+  return blocks.length > 0 ? blocks.join(`
+`) : null;
+}
 function parseFunctionTagEnvelope(text) {
-  const body = text.trim();
-  if (body.length === 0)
+  const trimmed = text.trim();
+  if (trimmed.length === 0)
     return null;
+  const body = unwrapToolCallTags(trimmed) ?? trimmed;
   if (!body.startsWith("<function="))
     return null;
   const calls = [];
@@ -21440,7 +21588,7 @@ function validateAndRepairToolCall(toolName, argsStr, toolSchemas, textContent)
   }
   return { valid: false, args, repaired: false, missingParams };
 }
-var FUNCTION_TAG_SOURCE, FUNCTION_TAG_PRESENT, FUNCTION_TAG_AT_CURSOR, PARAMETER_TAG_AT_CURSOR;
+var FUNCTION_TAG_SOURCE, FUNCTION_TAG_PRESENT, FUNCTION_TAG_AT_CURSOR, PARAMETER_TAG_AT_CURSOR, TOOL_CALL_OPEN_AT_CURSOR, TOOL_CALL_CLOSE_TAG = "</tool_call>";
 var init_tool_call_recovery = __esm(() => {
   init_tool_name_utils();
   init_logger();
@@ -21449,6 +21597,7 @@ var init_tool_call_recovery = __esm(() => {
   FUNCTION_TAG_PRESENT = new RegExp(`<function=${TOOL_NAME_SOURCE}>`);
   FUNCTION_TAG_AT_CURSOR = new RegExp(`<function=(${TOOL_NAME_SOURCE})>`, "y");
   PARAMETER_TAG_AT_CURSOR = /<parameter=([^>\s]+)>/y;
+  TOOL_CALL_OPEN_AT_CURSOR = /<tool_call>\s*/y;
 });
 
 // src/handlers/shared/web-search-detector.ts
@@ -22859,9 +23008,9 @@ var init_openai_api_format = __esm(() => {
 
 // src/auth/vertex-auth.ts
 import { exec } from "child_process";
-import { existsSync as existsSync7 } from "fs";
-import { homedir as homedir9 } from "os";
-import { join as join9 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { homedir as homedir10 } from "os";
+import { join as join10 } from "path";
 import { promisify } from "util";
 
 class VertexAuthManager {
@@ -22916,8 +23065,8 @@ class VertexAuthManager {
   }
   async tryADC() {
     try {
-      const adcPath = join9(homedir9(), ".config/gcloud/application_default_credentials.json");
-      if (!existsSync7(adcPath)) {
+      const adcPath = join10(homedir10(), ".config/gcloud/application_default_credentials.json");
+      if (!existsSync8(adcPath)) {
         log("[VertexAuth] ADC credentials file not found");
         return null;
       }
@@ -22941,7 +23090,7 @@ class VertexAuthManager {
     if (!credPath) {
       return null;
     }
-    if (!existsSync7(credPath)) {
+    if (!existsSync8(credPath)) {
       throw new Error(`Service account file not found: ${credPath}
 
 Check GOOGLE_APPLICATION_CREDENTIALS path.`);
@@ -22980,8 +23129,8 @@ function validateVertexOAuthConfig() {
 ` + `  export VERTEX_PROJECT='your-gcp-project-id'
 ` + "  export VERTEX_LOCATION='us-central1'  # optional";
   }
-  const adcPath = join9(homedir9(), ".config/gcloud/application_default_credentials.json");
-  const hasADC = existsSync7(adcPath);
+  const adcPath = join10(homedir10(), ".config/gcloud/application_default_credentials.json");
+  const hasADC = existsSync8(adcPath);
   const hasServiceAccount = !!process.env.GOOGLE_APPLICATION_CREDENTIALS;
   if (!hasADC && !hasServiceAccount) {
     return `No Vertex AI credentials found.
@@ -23591,9 +23740,9 @@ var init_dialect_manager = __esm(() => {
 
 // src/auth/antigravity-token.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync8 } from "fs";
-import { homedir as homedir10 } from "os";
-import { join as join10 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { homedir as homedir11 } from "os";
+import { join as join11 } from "path";
 function invalidateReadStoreMemo() {
   cachedRawStore = null;
 }
@@ -23629,8 +23778,8 @@ function locateAgyBinary() {
     if (p.length > 0)
       return p;
   } catch {}
-  const fallback = join10(homedir10(), ".local", "bin", "agy");
-  return existsSync8(fallback) ? fallback : null;
+  const fallback = join11(homedir11(), ".local", "bin", "agy");
+  return existsSync9(fallback) ? fallback : null;
 }
 function defaultDeleteStore() {
   if (process.platform !== "darwin")
@@ -24117,9 +24266,9 @@ var init_antigravity = __esm(() => {
 });
 
 // src/auth/quota/sources/codex.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
-import { homedir as homedir11 } from "os";
-import { join as join11 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
+import { homedir as homedir12 } from "os";
+import { join as join12 } from "path";
 function formatWindowMinutes(minutes) {
   if (!Number.isFinite(minutes) || minutes <= 0)
     return "";
@@ -24133,7 +24282,7 @@ function formatWindowMinutes(minutes) {
   return `${hours}h${minutes % 60}m`;
 }
 function credentialsPath() {
-  return join11(homedir11(), ".claudish", "codex-oauth.json");
+  return join12(homedir12(), ".claudish", "codex-oauth.json");
 }
 function planLabel(planType) {
   if (!planType)
@@ -24185,10 +24334,10 @@ function scrapeCodexHeaders(headers) {
 }
 function resolveProbeModel() {
   try {
-    const cachePath = join11(homedir11(), ".codex", "models_cache.json");
-    if (!existsSync9(cachePath))
+    const cachePath = join12(homedir12(), ".codex", "models_cache.json");
+    if (!existsSync10(cachePath))
       return;
-    const cache = JSON.parse(readFileSync7(cachePath, "utf-8"));
+    const cache = JSON.parse(readFileSync8(cachePath, "utf-8"));
     for (const m of cache.models ?? []) {
       const slug = m?.slug ?? m?.id;
       if (typeof slug === "string" && slug.length > 0)
@@ -24200,9 +24349,9 @@ function resolveProbeModel() {
 function readCodexCredentials() {
   try {
     const path = credentialsPath();
-    if (!existsSync9(path))
+    if (!existsSync10(path))
       return;
-    return JSON.parse(readFileSync7(path, "utf-8"));
+    return JSON.parse(readFileSync8(path, "utf-8"));
   } catch {
     return;
   }
@@ -24233,7 +24382,7 @@ var init_codex = __esm(() => {
     },
     isAvailable() {
       try {
-        return existsSync9(credentialsPath());
+        return existsSync10(credentialsPath());
       } catch {
         return false;
       }
@@ -24287,15 +24436,15 @@ import { exec as exec2 } from "child_process";
 import { createHash as createHash2, randomBytes } from "crypto";
 import {
   closeSync as closeSync2,
-  existsSync as existsSync10,
-  mkdirSync as mkdirSync7,
+  existsSync as existsSync11,
+  mkdirSync as mkdirSync8,
   openSync as openSync2,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync9,
   unlinkSync as unlinkSync2,
   writeSync as writeSync2
 } from "fs";
-import { homedir as homedir12 } from "os";
-import { join as join12 } from "path";
+import { homedir as homedir13 } from "os";
+import { join as join13 } from "path";
 import { promisify as promisify2 } from "util";
 
 class OAuthManager {
@@ -24303,21 +24452,21 @@ class OAuthManager {
   refreshPromise = null;
   tokenRefreshMargin = 5 * 60 * 1000;
   static ensureClaudishDir() {
-    const dir = join12(homedir12(), ".claudish");
-    if (!existsSync10(dir)) {
-      mkdirSync7(dir, { recursive: true });
+    const dir = join13(homedir13(), ".claudish");
+    if (!existsSync11(dir)) {
+      mkdirSync8(dir, { recursive: true });
     }
     return dir;
   }
   getCredentialsPath() {
-    return join12(homedir12(), ".claudish", this.credentialFile);
+    return join13(homedir13(), ".claudish", this.credentialFile);
   }
   loadCredentials() {
     const credPath = this.getCredentialsPath();
-    if (!existsSync10(credPath))
+    if (!existsSync11(credPath))
       return null;
     try {
-      const data = JSON.parse(readFileSync8(credPath, "utf-8"));
+      const data = JSON.parse(readFileSync9(credPath, "utf-8"));
       if (!this.validateCredentials(data)) {
         log(`[${this.providerName}] Invalid credentials file structure`);
         return null;
@@ -24342,7 +24491,7 @@ class OAuthManager {
   }
   deleteCredentials() {
     const credPath = this.getCredentialsPath();
-    if (existsSync10(credPath)) {
+    if (existsSync11(credPath)) {
       unlinkSync2(credPath);
       log(`[${this.providerName}] Credentials deleted`);
     }
@@ -24649,14 +24798,14 @@ Signed in to Grok. Try it with: claudish --model gk@grok-4.6 "hello"
 });
 
 // src/providers/grok/grok-credentials.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9, renameSync, writeFileSync as writeFileSync7 } from "fs";
-import { homedir as homedir13 } from "os";
-import { join as join13 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync10, renameSync, writeFileSync as writeFileSync8 } from "fs";
+import { homedir as homedir14 } from "os";
+import { join as join14 } from "path";
 function grokHome() {
-  return grokHomeOverride ?? join13(homedir13(), ".grok");
+  return grokHomeOverride ?? join14(homedir14(), ".grok");
 }
 function grokAuthPath() {
-  return join13(grokHome(), "auth.json");
+  return join14(grokHome(), "auth.json");
 }
 function str(value) {
   return typeof value === "string" && value.trim() ? value.trim() : undefined;
@@ -24664,7 +24813,7 @@ function str(value) {
 function readGrokCredential() {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync9(grokAuthPath(), "utf8"));
+    parsed = JSON.parse(readFileSync10(grokAuthPath(), "utf8"));
   } catch {
     return;
   }
@@ -24689,10 +24838,10 @@ function readGrokCredential() {
   };
 }
 function claudishGrokOAuthPath() {
-  return claudishOAuthPathOverride ?? join13(homedir13(), ".claudish", "grok-oauth.json");
+  return claudishOAuthPathOverride ?? join14(homedir14(), ".claudish", "grok-oauth.json");
 }
 function hasClaudishGrokOAuth() {
-  return existsSync11(claudishGrokOAuthPath());
+  return existsSync12(claudishGrokOAuthPath());
 }
 function hasGrokCredentials() {
   return hasClaudishGrokOAuth() || readGrokCredential() !== undefined;
@@ -24714,7 +24863,7 @@ function readLocalGrokVersion() {
     ["models_cache.json", "grok_version"]
   ]) {
     try {
-      const parsed = JSON.parse(readFileSync9(join13(grokHome(), file), "utf8"));
+      const parsed = JSON.parse(readFileSync10(join14(grokHome(), file), "utf8"));
       const version = str(parsed[field]);
       if (version)
         return version;
@@ -24760,7 +24909,7 @@ function persistRefreshedToken(scope, next) {
   const path = grokAuthPath();
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync9(path, "utf8"));
+    parsed = JSON.parse(readFileSync10(path, "utf8"));
   } catch {
     return;
   }
@@ -24773,7 +24922,7 @@ function persistRefreshedToken(scope, next) {
   if (next.expiresAt)
     entry.expires_at = next.expiresAt;
   const tmp = `${path}.claudish.tmp`;
-  writeFileSync7(tmp, `${JSON.stringify(parsed, null, 2)}
+  writeFileSync8(tmp, `${JSON.stringify(parsed, null, 2)}
 `, { mode: 384 });
   renameSync(tmp, path);
 }
@@ -25303,8 +25452,8 @@ var init_harness = __esm(() => {
 
 // src/behavior/journal.ts
 import { appendFile as appendFile2, mkdir, readFile, rename, stat, writeFile } from "fs/promises";
-import { homedir as homedir14 } from "os";
-import { dirname as dirname6, join as join14 } from "path";
+import { homedir as homedir15 } from "os";
+import { dirname as dirname7, join as join15 } from "path";
 function classifyPath(observed, expected) {
   if (!observed)
     return "not_applicable";
@@ -25316,7 +25465,7 @@ function classifyPath(observed, expected) {
   return dirOf(observed) === dirOf(expected) ? "same_dir_wrong_name" : "outside_expected_dir";
 }
 function journalPath() {
-  return join14(homedir14(), ".claudish", "behavior-journal.jsonl");
+  return join15(homedir15(), ".claudish", "behavior-journal.jsonl");
 }
 async function prune(path) {
   const content = await readFile(path, "utf8");
@@ -25343,7 +25492,7 @@ async function recordDecision(entry, path = journalPath()) {
   try {
     const size = await stat(path).then((s) => s.size, () => 0);
     if (size === 0)
-      await mkdir(dirname6(path), { recursive: true }).catch(() => {});
+      await mkdir(dirname7(path), { recursive: true }).catch(() => {});
     if (size > MAX_JOURNAL_BYTES) {
       await prune(path).catch((err) => log(`[behavior:journal] prune failed: ${err}`));
     }
@@ -25362,9 +25511,9 @@ var init_journal = __esm(() => {
 
 // src/behavior/telemetry/aggregate.ts
 import { createHash as createHash3, randomBytes as randomBytes2 } from "crypto";
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync8 } from "fs";
-import { homedir as homedir15 } from "os";
-import { dirname as dirname7, join as join15 } from "path";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync9 } from "fs";
+import { homedir as homedir16 } from "os";
+import { dirname as dirname8, join as join16 } from "path";
 function contextBucket(inputTokens) {
   if (inputTokens < 50000)
     return "0-50k";
@@ -25478,7 +25627,7 @@ function pendingReports() {
   return [...sessions.values()].map(toReport);
 }
 function outboxPath() {
-  return join15(homedir15(), ".claudish", "behavior-outbox.jsonl");
+  return join16(homedir16(), ".claudish", "behavior-outbox.jsonl");
 }
 function spoolPendingSync(path = outboxPath()) {
   if (sessions.size === 0)
@@ -25488,7 +25637,7 @@ function spoolPendingSync(path = outboxPath()) {
   if (reports.length === 0)
     return 0;
   try {
-    mkdirSync8(dirname7(path), { recursive: true });
+    mkdirSync9(dirname8(path), { recursive: true });
     appendFileSync2(path, `${reports.map((r) => JSON.stringify(r)).join(`
 `)}
 `);
@@ -25685,10 +25834,10 @@ var init_client = __esm(() => {
 
 // src/behavior/observer/live-log.ts
 import { appendFile as appendFile3 } from "fs/promises";
-import { homedir as homedir16 } from "os";
-import { join as join16 } from "path";
+import { homedir as homedir17 } from "os";
+import { join as join17 } from "path";
 function defaultPath() {
-  return join16(homedir16(), ".claudish", "behavior-divergences.jsonl");
+  return join17(homedir17(), ".claudish", "behavior-divergences.jsonl");
 }
 async function recordLiveDivergence(entry, path = defaultPath()) {
   try {
@@ -26376,9 +26525,9 @@ var init_hooks = __esm(() => {
 });
 
 // src/behavior/observer/corpus.ts
-import { appendFileSync as appendFileSync3, readFileSync as readFileSync10, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { homedir as homedir17 } from "os";
-import { join as join17 } from "path";
+import { appendFileSync as appendFileSync3, readFileSync as readFileSync11, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { homedir as homedir18 } from "os";
+import { join as join18 } from "path";
 function directoryOf2(filePath) {
   const slash = filePath.lastIndexOf("/");
   return slash > 0 ? filePath.slice(0, slash) : undefined;
@@ -26400,7 +26549,7 @@ function writeTargetsOf(row) {
 function replayTranscript(file) {
   let text;
   try {
-    text = readFileSync10(file, "utf8");
+    text = readFileSync11(file, "utf8");
   } catch {
     return [];
   }
@@ -26457,26 +26606,26 @@ function listTranscripts(root) {
     return files;
   }
   for (const project of projects) {
-    const dir = join17(root, project);
+    const dir = join18(root, project);
     try {
       if (!statSync2(dir).isDirectory())
         continue;
       for (const f of readdirSync2(dir)) {
         if (f.endsWith(".jsonl"))
-          files.push(join17(dir, f));
+          files.push(join18(dir, f));
       }
     } catch {}
   }
   return files;
 }
 function buildCorpus(options = {}) {
-  const root = options.projectsRoot ?? join17(homedir17(), ".claude", "projects");
+  const root = options.projectsRoot ?? join18(homedir18(), ".claude", "projects");
   const files = listTranscripts(root);
   const records = [];
   for (const f of files)
     records.push(...replayTranscript(f));
   if (options.write && records.length > 0) {
-    const outputPath = options.outputPath ?? join17(homedir17(), ".claudish", "behavior-divergences.jsonl");
+    const outputPath = options.outputPath ?? join18(homedir18(), ".claudish", "behavior-divergences.jsonl");
     try {
       appendFileSync3(outputPath, `${records.map((r) => JSON.stringify(r)).join(`
 `)}
@@ -27853,9 +28002,9 @@ var init_keychain_source = __esm(() => {
 });
 
 // src/auth/credentials/api-key-credential.ts
-import { existsSync as existsSync12 } from "fs";
-import { homedir as homedir18 } from "os";
-import { join as join18 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { homedir as homedir19 } from "os";
+import { join as join19 } from "path";
 
 class ApiKeyCredentialProvider {
   catalogName;
@@ -27890,7 +28039,7 @@ class ApiKeyCredentialProvider {
     if (!this.oauthFallback)
       return false;
     try {
-      return existsSync12(join18(homedir18(), ".claudish", this.oauthFallback));
+      return existsSync13(join19(homedir19(), ".claudish", this.oauthFallback));
     } catch {
       return false;
     }
@@ -27981,10 +28130,10 @@ var init_api_key_credential = __esm(() => {
 // src/auth/codex-oauth.ts
 import { exec as exec3 } from "child_process";
 import { createHash as createHash4, randomBytes as randomBytes3 } from "crypto";
-import { closeSync as closeSync3, existsSync as existsSync13, openSync as openSync3, readFileSync as readFileSync11, unlinkSync as unlinkSync3, writeSync as writeSync3 } from "fs";
+import { closeSync as closeSync3, existsSync as existsSync14, openSync as openSync3, readFileSync as readFileSync12, unlinkSync as unlinkSync3, writeSync as writeSync3 } from "fs";
 import { createServer } from "http";
-import { homedir as homedir19 } from "os";
-import { join as join19 } from "path";
+import { homedir as homedir20 } from "os";
+import { join as join20 } from "path";
 import { promisify as promisify3 } from "util";
 
 class CodexOAuth {
@@ -28010,8 +28159,8 @@ class CodexOAuth {
     return this.credentials !== null && !!this.credentials.refresh_token;
   }
   getCredentialsPath() {
-    const claudishDir = join19(homedir19(), ".claudish");
-    return join19(claudishDir, "codex-oauth.json");
+    const claudishDir = join20(homedir20(), ".claudish");
+    return join20(claudishDir, "codex-oauth.json");
   }
   async login() {
     log("[CodexOAuth] Starting OAuth login flow");
@@ -28037,7 +28186,7 @@ class CodexOAuth {
   }
   async logout() {
     const credPath = this.getCredentialsPath();
-    if (existsSync13(credPath)) {
+    if (existsSync14(credPath)) {
       unlinkSync3(credPath);
       log("[CodexOAuth] Credentials deleted");
     }
@@ -28115,11 +28264,11 @@ Details: ${e.message}`);
   }
   loadCredentials() {
     const credPath = this.getCredentialsPath();
-    if (!existsSync13(credPath)) {
+    if (!existsSync14(credPath)) {
       return null;
     }
     try {
-      const data = readFileSync11(credPath, "utf-8");
+      const data = readFileSync12(credPath, "utf-8");
       const credentials = JSON.parse(data);
       if (!credentials.access_token || !credentials.refresh_token || !credentials.expires_at) {
         log("[CodexOAuth] Invalid credentials file structure");
@@ -28134,8 +28283,8 @@ Details: ${e.message}`);
   }
   saveCredentials(credentials) {
     const credPath = this.getCredentialsPath();
-    const claudishDir = join19(homedir19(), ".claudish");
-    if (!existsSync13(claudishDir)) {
+    const claudishDir = join20(homedir20(), ".claudish");
+    if (!existsSync14(claudishDir)) {
       const { mkdirSync } = __require("fs");
       mkdirSync(claudishDir, { recursive: true });
     }
@@ -28472,11 +28621,11 @@ var init_codex_credential = __esm(() => {
 });
 
 // src/providers/devin/devin-credentials.ts
-import { readFileSync as readFileSync12 } from "fs";
-import { homedir as homedir20 } from "os";
-import { join as join20 } from "path";
+import { readFileSync as readFileSync13 } from "fs";
+import { homedir as homedir21 } from "os";
+import { join as join21 } from "path";
 function devinCredentialsPath() {
-  return credentialsPathOverride ?? join20(homedir20(), ".local", "share", "devin", "credentials.toml");
+  return credentialsPathOverride ?? join21(homedir21(), ".local", "share", "devin", "credentials.toml");
 }
 function readTomlString(source, key) {
   const match = source.match(new RegExp(`^\\s*${key}\\s*=\\s*"([^"]*)"`, "m"));
@@ -28489,7 +28638,7 @@ function readCredentialsFile() {
     return fileCache.value;
   let value = {};
   try {
-    const source = readFileSync12(path, "utf8");
+    const source = readFileSync13(path, "utf8");
     value = {
       apiKey: readTomlString(source, "windsurf_api_key"),
       serverUrl: readTomlString(source, "api_server_url")
@@ -28578,9 +28727,9 @@ var init_grok_credential = __esm(() => {
 // src/auth/kimi-oauth.ts
 import { exec as exec4 } from "child_process";
 import { randomBytes as randomBytes4 } from "crypto";
-import { closeSync as closeSync4, existsSync as existsSync14, openSync as openSync4, readFileSync as readFileSync13, unlinkSync as unlinkSync4, writeSync as writeSync4 } from "fs";
-import { homedir as homedir21, hostname, platform, release as release2 } from "os";
-import { join as join21 } from "path";
+import { closeSync as closeSync4, existsSync as existsSync15, openSync as openSync4, readFileSync as readFileSync14, unlinkSync as unlinkSync4, writeSync as writeSync4 } from "fs";
+import { homedir as homedir22, hostname, platform, release as release2 } from "os";
+import { join as join22 } from "path";
 import { promisify as promisify4 } from "util";
 
 class KimiOAuth {
@@ -28608,23 +28757,23 @@ class KimiOAuth {
     return this.credentials !== null && !!this.credentials.refresh_token;
   }
   getCredentialsPath() {
-    const claudishDir = join21(homedir21(), ".claudish");
-    return join21(claudishDir, "kimi-oauth.json");
+    const claudishDir = join22(homedir22(), ".claudish");
+    return join22(claudishDir, "kimi-oauth.json");
   }
   getDeviceIdPath() {
-    const claudishDir = join21(homedir21(), ".claudish");
-    return join21(claudishDir, "kimi-device-id");
+    const claudishDir = join22(homedir22(), ".claudish");
+    return join22(claudishDir, "kimi-device-id");
   }
   loadOrCreateDeviceId() {
     const deviceIdPath = this.getDeviceIdPath();
-    const claudishDir = join21(homedir21(), ".claudish");
-    if (!existsSync14(claudishDir)) {
+    const claudishDir = join22(homedir22(), ".claudish");
+    if (!existsSync15(claudishDir)) {
       const { mkdirSync } = __require("fs");
       mkdirSync(claudishDir, { recursive: true });
     }
-    if (existsSync14(deviceIdPath)) {
+    if (existsSync15(deviceIdPath)) {
       try {
-        const deviceId = readFileSync13(deviceIdPath, "utf-8").trim();
+        const deviceId = readFileSync14(deviceIdPath, "utf-8").trim();
         if (deviceId) {
           return deviceId;
         }
@@ -28795,7 +28944,7 @@ Waiting for authorization...`);
   }
   async logout() {
     const credPath = this.getCredentialsPath();
-    if (existsSync14(credPath)) {
+    if (existsSync15(credPath)) {
       unlinkSync4(credPath);
       log("[KimiOAuth] Credentials deleted");
     }
@@ -28862,7 +29011,7 @@ Waiting for authorization...`);
     } catch (e) {
       log(`[KimiOAuth] Refresh failed: ${e.message}`);
       const credPath = this.getCredentialsPath();
-      if (existsSync14(credPath)) {
+      if (existsSync15(credPath)) {
         unlinkSync4(credPath);
       }
       this.credentials = null;
@@ -28879,11 +29028,11 @@ Details: ${e.message}`);
   }
   loadCredentials() {
     const credPath = this.getCredentialsPath();
-    if (!existsSync14(credPath)) {
+    if (!existsSync15(credPath)) {
       return null;
     }
     try {
-      const data = readFileSync13(credPath, "utf-8");
+      const data = readFileSync14(credPath, "utf-8");
       const credentials = JSON.parse(data);
       if (!credentials.access_token || !credentials.refresh_token || !credentials.expires_at || !credentials.scope || !credentials.token_type) {
         log("[KimiOAuth] Invalid credentials file structure");
@@ -28898,8 +29047,8 @@ Details: ${e.message}`);
   }
   saveCredentials(credentials) {
     const credPath = this.getCredentialsPath();
-    const claudishDir = join21(homedir21(), ".claudish");
-    if (!existsSync14(claudishDir)) {
+    const claudishDir = join22(homedir22(), ".claudish");
+    if (!existsSync15(claudishDir)) {
       const { mkdirSync } = __require("fs");
       mkdirSync(claudishDir, { recursive: true });
     }
@@ -28929,9 +29078,9 @@ var init_kimi_oauth = __esm(() => {
 });
 
 // src/auth/oauth-registry.ts
-import { existsSync as existsSync15, readFileSync as readFileSync14 } from "fs";
-import { homedir as homedir22 } from "os";
-import { join as join22 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync15 } from "fs";
+import { homedir as homedir23 } from "os";
+import { join as join23 } from "path";
 function credentialSatisfies(descriptor, data) {
   if (!data?.access_token)
     return false;
@@ -28944,14 +29093,14 @@ function credentialSatisfies(descriptor, data) {
   return true;
 }
 function hasValidOAuthCredentials(descriptor) {
-  const credPath = join22(homedir22(), ".claudish", descriptor.credentialFile);
-  if (!existsSync15(credPath))
+  const credPath = join23(homedir23(), ".claudish", descriptor.credentialFile);
+  if (!existsSync16(credPath))
     return false;
   if (descriptor.validationMode === "file-exists") {
     return true;
   }
   try {
-    return credentialSatisfies(descriptor, JSON.parse(readFileSync14(credPath, "utf-8")));
+    return credentialSatisfies(descriptor, JSON.parse(readFileSync15(credPath, "utf-8")));
   } catch {
     return false;
   }
@@ -31037,9 +31186,9 @@ var DEFAULT_POLL_INTERVAL_MS = 250;
 var init_transcript_tailer = () => {};
 
 // src/session-events/index.ts
-import { existsSync as existsSync16, readFileSync as readFileSync15, readdirSync as readdirSync3 } from "fs";
-import { homedir as homedir23 } from "os";
-import { join as join23 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync16, readdirSync as readdirSync3 } from "fs";
+import { homedir as homedir24 } from "os";
+import { join as join24 } from "path";
 function extractSessionId2(metadata) {
   const userId = metadata?.user_id;
   if (typeof userId !== "string")
@@ -31064,7 +31213,7 @@ class SessionEventRegistry {
   claudeHome;
   pollIntervalMs;
   constructor(opts = {}) {
-    this.claudeHome = opts.claudeHome ?? join23(homedir23(), ".claude");
+    this.claudeHome = opts.claudeHome ?? join24(homedir24(), ".claude");
     this.pollIntervalMs = opts.pollIntervalMs;
   }
   ensureSession(sessionId) {
@@ -31150,14 +31299,14 @@ class SessionEventRegistry {
     }
   }
   locateTranscript(sessionId) {
-    const projectsDir = join23(this.claudeHome, "projects");
-    const primary = join23(projectsDir, slugFromCwd(process.cwd()), `${sessionId}.jsonl`);
-    if (existsSync16(primary))
+    const projectsDir = join24(this.claudeHome, "projects");
+    const primary = join24(projectsDir, slugFromCwd(process.cwd()), `${sessionId}.jsonl`);
+    if (existsSync17(primary))
       return primary;
     try {
       for (const dir of readdirSync3(projectsDir)) {
-        const candidate = join23(projectsDir, dir, `${sessionId}.jsonl`);
-        if (existsSync16(candidate))
+        const candidate = join24(projectsDir, dir, `${sessionId}.jsonl`);
+        if (existsSync17(candidate))
           return candidate;
       }
     } catch {}
@@ -31165,7 +31314,7 @@ class SessionEventRegistry {
   }
   readSettingsEffortLevel() {
     try {
-      const settings = JSON.parse(readFileSync15(join23(this.claudeHome, "settings.json"), "utf-8"));
+      const settings = JSON.parse(readFileSync16(join24(this.claudeHome, "settings.json"), "utf-8"));
       return typeof settings.effortLevel === "string" ? settings.effortLevel : undefined;
     } catch {
       return;
@@ -31364,25 +31513,25 @@ var init_model_parser = __esm(() => {
 
 // src/stats-buffer.ts
 import {
-  existsSync as existsSync17,
-  mkdirSync as mkdirSync9,
-  readFileSync as readFileSync16,
+  existsSync as existsSync18,
+  mkdirSync as mkdirSync10,
+  readFileSync as readFileSync17,
   renameSync as renameSync2,
   unlinkSync as unlinkSync5,
-  writeFileSync as writeFileSync8
+  writeFileSync as writeFileSync9
 } from "fs";
-import { homedir as homedir24 } from "os";
-import { join as join24 } from "path";
+import { homedir as homedir25 } from "os";
+import { join as join25 } from "path";
 function ensureDir() {
-  if (!existsSync17(CLAUDISH_DIR)) {
-    mkdirSync9(CLAUDISH_DIR, { recursive: true });
+  if (!existsSync18(CLAUDISH_DIR)) {
+    mkdirSync10(CLAUDISH_DIR, { recursive: true });
   }
 }
 function readFromDisk() {
   try {
-    if (!existsSync17(BUFFER_FILE))
+    if (!existsSync18(BUFFER_FILE))
       return [];
-    const raw = readFileSync16(BUFFER_FILE, "utf-8");
+    const raw = readFileSync17(BUFFER_FILE, "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.events))
       return [];
@@ -31407,8 +31556,8 @@ function writeToDisk(events) {
     ensureDir();
     const trimmed = enforceSizeCap([...events]);
     const payload = { version: 1, events: trimmed };
-    const tmpFile = join24(CLAUDISH_DIR, `stats-buffer.tmp.${process.pid}.json`);
-    writeFileSync8(tmpFile, JSON.stringify(payload, null, 2), "utf-8");
+    const tmpFile = join25(CLAUDISH_DIR, `stats-buffer.tmp.${process.pid}.json`);
+    writeFileSync9(tmpFile, JSON.stringify(payload, null, 2), "utf-8");
     renameSync2(tmpFile, BUFFER_FILE);
     memoryCache = trimmed;
   } catch {}
@@ -31451,7 +31600,7 @@ function clearBuffer() {
   try {
     memoryCache = [];
     eventsSinceLastFlush = 0;
-    if (existsSync17(BUFFER_FILE)) {
+    if (existsSync18(BUFFER_FILE)) {
       unlinkSync5(BUFFER_FILE);
     }
   } catch {}
@@ -31480,8 +31629,8 @@ function syncFlushOnExit() {
 var BUFFER_MAX_BYTES, CLAUDISH_DIR, BUFFER_FILE, memoryCache = null, eventsSinceLastFlush = 0, flushScheduled = false, SIGNAL_EXIT_CODE;
 var init_stats_buffer = __esm(() => {
   BUFFER_MAX_BYTES = 64 * 1024;
-  CLAUDISH_DIR = join24(homedir24(), ".claudish");
-  BUFFER_FILE = join24(CLAUDISH_DIR, "stats-buffer.json");
+  CLAUDISH_DIR = join25(homedir25(), ".claudish");
+  BUFFER_FILE = join25(CLAUDISH_DIR, "stats-buffer.json");
   process.on("exit", syncFlushOnExit);
   SIGNAL_EXIT_CODE = { SIGTERM: 143, SIGINT: 130 };
   for (const signal of ["SIGTERM", "SIGINT"]) {
@@ -34600,9 +34749,9 @@ var init_openai_responses_sse = __esm(() => {
 });
 
 // src/handlers/shared/token-tracker.ts
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync9 } from "fs";
-import { homedir as homedir25 } from "os";
-import { dirname as dirname8, join as join25 } from "path";
+import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync10 } from "fs";
+import { homedir as homedir26 } from "os";
+import { dirname as dirname9, join as join26 } from "path";
 function stripProviderPrefix(name) {
   const at = name.indexOf("@");
   return at === -1 ? name : name.slice(at + 1);
@@ -34813,9 +34962,9 @@ class TokenTracker {
         };
       }
       const override = process.env.CLAUDISH_TOKEN_FILE;
-      const outPath = override || join25(homedir25(), ".claudish", `tokens-${this.port}.json`);
-      mkdirSync10(dirname8(outPath), { recursive: true });
-      writeFileSync9(outPath, JSON.stringify(data), "utf-8");
+      const outPath = override || join26(homedir26(), ".claudish", `tokens-${this.port}.json`);
+      mkdirSync11(dirname9(outPath), { recursive: true });
+      writeFileSync10(outPath, JSON.stringify(data), "utf-8");
     } catch (e) {
       log(`[TokenTracker] Error writing token file: ${e}`);
     }
@@ -35856,11 +36005,11 @@ var init_composed_handler = __esm(() => {
 });
 
 // src/providers/api-key-provenance.ts
-import { existsSync as existsSync18, readFileSync as readFileSync17 } from "fs";
-import { homedir as homedir26 } from "os";
-import { join as join26, resolve as resolve2 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync18 } from "fs";
+import { homedir as homedir27 } from "os";
+import { join as join27, resolve as resolve2 } from "path";
 function activeConfigPath() {
-  return activeGlobalConfigFile(join26(homedir26(), ".claudish", "config.json"));
+  return activeGlobalConfigFile(join27(homedir27(), ".claudish", "config.json"));
 }
 function configLayerLabel() {
   return getConfigFileOverride() ? activeConfigPath() : "~/.claudish/config.json";
@@ -35940,9 +36089,9 @@ function formatProvenanceLog(p) {
 function readDotenvKey(envVars) {
   try {
     const dotenvPath = resolve2(".env");
-    if (!existsSync18(dotenvPath))
+    if (!existsSync19(dotenvPath))
       return null;
-    const parsed = import_dotenv.parse(readFileSync17(dotenvPath, "utf-8"));
+    const parsed = import_dotenv.parse(readFileSync18(dotenvPath, "utf-8"));
     for (const v of envVars) {
       if (parsed[v])
         return parsed[v];
@@ -35955,9 +36104,9 @@ function readDotenvKey(envVars) {
 function readConfigKey(envVar) {
   try {
     const configPath = activeConfigPath();
-    if (!existsSync18(configPath))
+    if (!existsSync19(configPath))
       return null;
-    const cfg = JSON.parse(readFileSync17(configPath, "utf-8"));
+    const cfg = JSON.parse(readFileSync18(configPath, "utf-8"));
     return cfg.apiKeys?.[envVar] || null;
   } catch {
     return null;
@@ -37778,6 +37927,8 @@ function derivePlansUrl(catalogUrl) {
 function getCatalogEntries() {
   if (_catalogEntriesForTest !== undefined)
     return _catalogEntriesForTest;
+  if (readCatalogIncompatibility())
+    return null;
   if (_memCache)
     return _memCache;
   const cache = readAllModelsCache();
@@ -37930,14 +38081,32 @@ async function fetchCatalogPage(url, timeoutMs) {
     const reason = name === "TimeoutError" || name === "AbortError" ? "timeout" : "network";
     return { ok: false, reason };
   }
-  if (!response.ok)
+  if (!response.ok) {
+    const verdict = await contractVerdictForError(response);
+    if (verdict) {
+      return {
+        ok: false,
+        reason: "incompatible",
+        serverContractVersion: verdict.serverContractVersion
+      };
+    }
     return { ok: false, reason: "http_error" };
+  }
   let page;
   try {
     page = await response.json();
   } catch {
     return { ok: false, reason: "network" };
   }
+  const bodyEnvelope = parseContractEnvelope(page);
+  if (isIncompatibleContractVersion(bodyEnvelope.contractVersion)) {
+    const verdict = recordIncompatibility(bodyEnvelope);
+    return {
+      ok: false,
+      reason: "incompatible",
+      serverContractVersion: verdict.serverContractVersion
+    };
+  }
   const revision = response.headers.get(CATALOG_REVISION_HEADER) ?? undefined;
   return { ok: true, page, revision };
 }
@@ -37953,6 +38122,12 @@ async function refreshCatalog(timeoutMs, options = {}) {
     const url = buildCatalogPageUrl(catalogUrl(), offset, CATALOG_PAGE_LIMIT, revision);
     const result = await fetchCatalogPage(url, timeoutMs);
     if (!result.ok) {
+      if (result.reason === "incompatible") {
+        return {
+          kind: "incompatible",
+          serverContractVersion: result.serverContractVersion
+        };
+      }
       return {
         kind: "fetch_failed",
         reason: pages === 0 ? result.reason : "incomplete"
@@ -37988,6 +38163,7 @@ async function refreshCatalog(timeoutMs, options = {}) {
     if (id)
       backwardCompatModels.push({ id });
   }
+  clearCatalogIncompatibility();
   _memCache = entries;
   writeAllModelsCache({
     entries,
@@ -37998,6 +38174,20 @@ async function refreshCatalog(timeoutMs, options = {}) {
   _warmPromise = Promise.resolve();
   return { kind: "refreshed", modelCount: entries.length, catalogRevision: revision, pages };
 }
+async function contractVerdictForError(response) {
+  const envelope = parseContractEnvelope(await readJsonBody(response));
+  if (response.status === 426 || isIncompatibleContractVersion(envelope.contractVersion)) {
+    return recordIncompatibility(envelope);
+  }
+  return null;
+}
+async function readJsonBody(response) {
+  try {
+    return await response.json();
+  } catch {
+    return;
+  }
+}
 async function fetchSubscriptionPlans(timeoutMs, revision) {
   try {
     const url = new URL(plansUrl());
@@ -38006,14 +38196,28 @@ async function fetchSubscriptionPlans(timeoutMs, revision) {
     const response = await fetch(url.toString(), {
       signal: AbortSignal.timeout(timeoutMs)
     });
-    if (!response.ok)
+    if (!response.ok) {
+      await contractVerdictForError(response);
       return;
+    }
     const data = await response.json();
+    const envelope = parseContractEnvelope(data);
+    if (isIncompatibleContractVersion(envelope.contractVersion)) {
+      recordIncompatibility(envelope);
+      return;
+    }
     return Array.isArray(data.plans) ? data.plans : undefined;
   } catch {
     return;
   }
 }
+function recordIncompatibility(envelope) {
+  markCatalogIncompatible({
+    serverContractVersion: envelope.contractVersion,
+    ...envelope.minimumContractVersion !== undefined ? { minimumContractVersion: envelope.minimumContractVersion } : {}
+  });
+  return { kind: "incompatible", serverContractVersion: envelope.contractVersion };
+}
 async function warmCatalog() {
   if (!_warmPromise) {
     _warmPromise = refreshCatalog(8000).then(() => {
@@ -38038,6 +38242,7 @@ async function ensureCatalogReady(timeoutMs = 5000) {
 var DEFAULT_CATALOG_URL = "https://us-central1-claudish-6da10.cloudfunctions.net/queryModels?status=active&catalog=slim&limit=1000", _memCache = null, _catalogEntriesForTest, _warmPromise = null, CATALOG_REVISION_HEADER = "x-catalog-revision", MAX_CATALOG_PAGES = 40, CATALOG_PAGE_LIMIT = 1000;
 var init_catalog_client = __esm(() => {
   init_all_models_cache();
+  init_catalog_compatibility();
 });
 
 // src/config-schema.ts
@@ -39306,7 +39511,16 @@ function globMatch(pattern, value) {
 async function hasCredentialsForProvider(provider) {
   return credentials.isAvailable(provider);
 }
+function warnOnceIfCatalogIncompatible() {
+  if (_warnedCatalogIncompatible)
+    return;
+  if (!readCatalogIncompatibility())
+    return;
+  _warnedCatalogIncompatible = true;
+  logStderr("Model catalog is unavailable \u2014 this build cannot read the catalog server's current " + "contract. Explicit provider@model routing still works; bare model names do not. " + "Run `claudish update`.");
+}
 async function routeExplicit(modelSpec, model, provider, cachePath) {
+  warnOnceIfCatalogIncompatible();
   if (!await hasCredentialsForProvider(provider)) {
     return {
       kind: "no-route",
@@ -39331,6 +39545,10 @@ async function routeExplicit(modelSpec, model, provider, cachePath) {
   return { kind: "ok", primary: built, fallbacks: [] };
 }
 async function routeBare(model, nativeProvider, rules, defaultProvider, cachePath) {
+  const incompatible = readCatalogIncompatibility();
+  if (incompatible) {
+    throw new CatalogIncompatibleError(catalogIncompatibilityMessage(incompatible));
+  }
   const matched = matchRoutingRule(model, rules) ?? [];
   const entries = [...matched];
   if (defaultProvider && defaultProvider.length > 0) {
@@ -39412,6 +39630,7 @@ async function route(modelSpec, rulesOverride, defaultProviderOverride, cachePat
   const defaultProvider = defaultProviderOverride !== undefined ? defaultProviderOverride : rulesOverride !== undefined ? undefined : loadConfig().defaultProvider;
   return routeBare(normalizeGlmSlug(parsed.model), parsed.provider, rules, defaultProvider, cachePath);
 }
+var _warnedCatalogIncompatible = false;
 var init_routing_rules = __esm(() => {
   init_model_catalog();
   init_authority();
@@ -39420,6 +39639,7 @@ var init_routing_rules = __esm(() => {
   init_profile_config();
   init_auto_route();
   init_catalog_client();
+  init_catalog_compatibility();
   init_default_routing_rules();
   init_model_availability();
   init_model_parser();
@@ -40524,8 +40744,8 @@ __export(exports_session_discovery, {
 });
 import { execFile, execFileSync as execFileSync2 } from "child_process";
 import { closeSync as closeSync6, openSync as openSync6, readSync as readSync2, readdirSync as readdirSync4, realpathSync, statSync as statSync5 } from "fs";
-import { homedir as homedir27 } from "os";
-import { basename, join as join27 } from "path";
+import { homedir as homedir28 } from "os";
+import { basename, join as join28 } from "path";
 function slugForPath(absPath) {
   return absPath.replace(/[/.]/g, "-");
 }
@@ -40534,7 +40754,7 @@ function transcriptPathFor(cwd, sessionUuid) {
   try {
     real = realpathSync(cwd);
   } catch {}
-  return join27(PROJECTS_DIR, slugForPath(real), `${sessionUuid}.jsonl`);
+  return join28(PROJECTS_DIR, slugForPath(real), `${sessionUuid}.jsonl`);
 }
 function isAgentSession(row) {
   return row.entrypoint !== undefined && row.entrypoint !== "cli";
@@ -40581,7 +40801,7 @@ function projectDirs() {
   }
 }
 function sessionsIn(dirName) {
-  const dir = join27(PROJECTS_DIR, dirName);
+  const dir = join28(PROJECTS_DIR, dirName);
   let names;
   try {
     names = readdirSync4(dir).filter((n) => n.endsWith(".jsonl"));
@@ -40590,7 +40810,7 @@ function sessionsIn(dirName) {
   }
   const rows = [];
   for (const n of names) {
-    const file = join27(dir, n);
+    const file = join28(dir, n);
     try {
       const st = statSync5(file);
       if (st.size === 0)
@@ -40952,7 +41172,7 @@ function findLatestSessionId(cwd = process.cwd(), sinceMs = 0) {
 }
 var ENTRYPOINT_BYTES = 8192, PROJECTS_DIR, ACTIVE_WINDOW_MS = 120000, HEAD_BYTES, TAIL_BYTES, HARNESS_ENVELOPES, DEEP_TAIL_BYTES, RECENT_AI_TURNS = 5, RECENT_USER_TURNS = 1;
 var init_session_discovery = __esm(() => {
-  PROJECTS_DIR = join27(homedir27(), ".claude", "projects");
+  PROJECTS_DIR = join28(homedir28(), ".claude", "projects");
   HEAD_BYTES = 64 * 1024;
   TAIL_BYTES = 128 * 1024;
   HARNESS_ENVELOPES = [
@@ -40987,19 +41207,19 @@ function newStdioDecoder() {
 var init_stdio_decode = () => {};
 
 // src/team-stats.ts
-import { existsSync as existsSync19, readFileSync as readFileSync18, writeFileSync as writeFileSync10 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync19, writeFileSync as writeFileSync11 } from "fs";
+import { join as join29 } from "path";
 function statsDir(sessionPath) {
-  return join28(sessionPath, "stats");
+  return join29(sessionPath, "stats");
 }
 function tokenFileFor(sessionPath, anonId) {
-  return join28(statsDir(sessionPath), `${anonId}.json`);
+  return join29(statsDir(sessionPath), `${anonId}.json`);
 }
 function readTokenStatsAt(path) {
-  if (!existsSync19(path))
+  if (!existsSync20(path))
     return null;
   try {
-    return JSON.parse(readFileSync18(path, "utf-8"));
+    return JSON.parse(readFileSync19(path, "utf-8"));
   } catch {
     return null;
   }
@@ -41150,7 +41370,7 @@ ${segs.join(" \xB7 ")}`;
 }
 function writeStatusFile(sessionPath, manifest, status, opts) {
   try {
-    writeFileSync10(join28(sessionPath, "status.txt"), `${renderTeamStats(sessionPath, manifest, status, opts)}
+    writeFileSync11(join29(sessionPath, "status.txt"), `${renderTeamStats(sessionPath, manifest, status, opts)}
 `, "utf-8");
   } catch {}
 }
@@ -41161,13 +41381,13 @@ var init_team_stats = () => {};
 import { spawn as spawn2 } from "child_process";
 import {
   createWriteStream,
-  existsSync as existsSync20,
-  mkdirSync as mkdirSync11,
-  readFileSync as readFileSync19,
+  existsSync as existsSync21,
+  mkdirSync as mkdirSync12,
+  readFileSync as readFileSync20,
   readdirSync as readdirSync5,
-  writeFileSync as writeFileSync11
+  writeFileSync as writeFileSync12
 } from "fs";
-import { basename as basename2, join as join29, resolve as resolve3 } from "path";
+import { basename as basename2, join as join30, resolve as resolve3 } from "path";
 function resolveCaptureMode(explicit, env = process.env) {
   if (explicit)
     return explicit;
@@ -41315,7 +41535,7 @@ function persistErrorLog(errorLogPath, header, stderr, stdoutTail) {
   parts.push("--- stderr ---", stderr.trim() ? redactSecrets(stderr) : "(empty)", "");
   parts.push("--- stdout (tail) ---", stdoutTail.trim() ? redactSecrets(stdoutTail) : "(empty)", "");
   try {
-    writeFileSync11(errorLogPath, parts.join(`
+    writeFileSync12(errorLogPath, parts.join(`
 `), "utf-8");
   } catch {}
 }
@@ -41333,10 +41553,10 @@ function readTeamInputFile(inputPath) {
   if (!resolved.startsWith(`${cwd}/`) && resolved !== cwd) {
     throw new Error(`Input file must be within current directory: ${inputPath}`);
   }
-  if (!existsSync20(resolved)) {
+  if (!existsSync21(resolved)) {
     throw new Error(`Input file not found: ${resolved}`);
   }
-  const text = readFileSync19(resolved, "utf-8");
+  const text = readFileSync20(resolved, "utf-8");
   if (text.trim().length === 0) {
     throw new Error(`Input file is empty: ${resolved}`);
   }
@@ -41346,14 +41566,14 @@ function setupSession(sessionPath, models, input) {
   if (models.length === 0) {
     throw new Error("At least one model is required");
   }
-  if (existsSync20(join29(sessionPath, "manifest.json"))) {
+  if (existsSync21(join30(sessionPath, "manifest.json"))) {
     throw new Error(`Session already exists at ${sessionPath}. Use a new directory path or delete the existing session first.`);
   }
-  mkdirSync11(join29(sessionPath, "work"), { recursive: true });
-  mkdirSync11(join29(sessionPath, "errors"), { recursive: true });
+  mkdirSync12(join30(sessionPath, "work"), { recursive: true });
+  mkdirSync12(join30(sessionPath, "errors"), { recursive: true });
   if (input !== undefined) {
-    writeFileSync11(join29(sessionPath, "input.md"), input, "utf-8");
-  } else if (!existsSync20(join29(sessionPath, "input.md"))) {
+    writeFileSync12(join30(sessionPath, "input.md"), input, "utf-8");
+  } else if (!existsSync21(join30(sessionPath, "input.md"))) {
     throw new Error(`No input.md found at ${sessionPath} and no input provided`);
   }
   const ids = models.map((_, i) => String(i + 1).padStart(2, "0"));
@@ -41370,9 +41590,9 @@ function setupSession(sessionPath, models, input) {
       model: models[i],
       assignedAt: now
     };
-    mkdirSync11(join29(sessionPath, "work", anonId), { recursive: true });
+    mkdirSync12(join30(sessionPath, "work", anonId), { recursive: true });
   }
-  writeFileSync11(join29(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+  writeFileSync12(join30(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
   const status = {
     startedAt: now,
     models: Object.fromEntries(Object.keys(manifest.models).map((id) => [
@@ -41386,7 +41606,7 @@ function setupSession(sessionPath, models, input) {
       }
     ]))
   };
-  writeFileSync11(join29(sessionPath, "status.json"), JSON.stringify(status, null, 2), "utf-8");
+  writeFileSync12(join30(sessionPath, "status.json"), JSON.stringify(status, null, 2), "utf-8");
   return manifest;
 }
 function assertValidRequirePattern(pattern) {
@@ -41403,22 +41623,22 @@ function readFullOutputIfNeeded(opts) {
   if (crashed || !requirePattern || outputSize <= STDOUT_TAIL_LIMIT)
     return;
   try {
-    return readFileSync19(outputPath, "utf-8");
+    return readFileSync20(outputPath, "utf-8");
   } catch {
     return;
   }
 }
 async function startModels(sessionPath, opts = {}) {
   assertValidRequirePattern(opts.requirePattern);
-  const manifest = JSON.parse(readFileSync19(join29(sessionPath, "manifest.json"), "utf-8"));
-  const statusPath = join29(sessionPath, "status.json");
-  const inputPath = join29(sessionPath, "input.md");
-  const inputContent = readFileSync19(inputPath, "utf-8");
+  const manifest = JSON.parse(readFileSync20(join30(sessionPath, "manifest.json"), "utf-8"));
+  const statusPath = join30(sessionPath, "status.json");
+  const inputPath = join30(sessionPath, "input.md");
+  const inputContent = readFileSync20(inputPath, "utf-8");
   const spawnPlan = await (opts.spawnPlanner ?? prehydrateCredentialsForSpawn)(Object.values(manifest.models).map((m) => m.model));
-  const statusCache = JSON.parse(readFileSync19(statusPath, "utf-8"));
+  const statusCache = JSON.parse(readFileSync20(statusPath, "utf-8"));
   function updateModelStatus(id, update) {
     statusCache.models[id] = { ...statusCache.models[id], ...update };
-    writeFileSync11(statusPath, JSON.stringify(statusCache, null, 2), "utf-8");
+    writeFileSync12(statusPath, JSON.stringify(statusCache, null, 2), "utf-8");
   }
   const minOutputBytes = opts.minOutputBytes ?? DEFAULT_MIN_OUTPUT_BYTES;
   const requirePattern = opts.requirePattern;
@@ -41451,7 +41671,7 @@ async function startModels(sessionPath, opts = {}) {
       persistErrorLog(rt.errorLogPath, `RECOVERED: ${note}`, stderr, stdoutTail);
     opts.onStatusChange?.(id, statusCache.models[id]);
   }
-  mkdirSync11(statsDir(sessionPath), { recursive: true });
+  mkdirSync12(statsDir(sessionPath), { recursive: true });
   const processes = new Map;
   const runtimes = new Map;
   const cancelledSlots = new Set;
@@ -41464,9 +41684,9 @@ async function startModels(sessionPath, opts = {}) {
   process.on("SIGINT", sigintHandler);
   const completionPromises = [];
   for (const [anonId, entry] of Object.entries(manifest.models)) {
-    const outputPath = join29(sessionPath, `response-${anonId}.md`);
-    const errorLogPath = join29(sessionPath, "errors", `${anonId}.log`);
-    const upstreamErrorLogPath = join29(sessionPath, "errors", `${anonId}-upstream.jsonl`);
+    const outputPath = join30(sessionPath, `response-${anonId}.md`);
+    const errorLogPath = join30(sessionPath, "errors", `${anonId}.log`);
+    const upstreamErrorLogPath = join30(sessionPath, "errors", `${anonId}-upstream.jsonl`);
     const spawnModel = spawnPlan.pinned.get(entry.model) ?? entry.model;
     const args = [
       "--model",
@@ -41620,7 +41840,7 @@ async function startModels(sessionPath, opts = {}) {
               stderrSnippet: stderr ? redactSecrets(stderr).slice(-2000) : undefined,
               stdoutSnippet: stdoutTail ? snippetHeadAndTail(redactSecrets(stdoutTail)) : undefined,
               errorLogPath,
-              upstreamErrorLogPath: existsSync20(upstreamErrorLogPath) ? upstreamErrorLogPath : undefined,
+              upstreamErrorLogPath: existsSync21(upstreamErrorLogPath) ? upstreamErrorLogPath : undefined,
               workDir: sessionPath
             }
           });
@@ -41641,7 +41861,7 @@ async function startModels(sessionPath, opts = {}) {
       proc.on("exit", (code) => {
         const timedOut = statusCache.models[anonId]?.state === "TIMEOUT";
         if (!timedOut && meaningfulStderr(stderr)) {
-          writeFileSync11(errorLogPath, redactSecrets(stderr), "utf-8");
+          writeFileSync12(errorLogPath, redactSecrets(stderr), "utf-8");
         }
         exitCode = code;
         if (outputStream.destroyed) {
@@ -41723,23 +41943,23 @@ async function judgeResponses(sessionPath, opts = {}) {
   const responses = {};
   for (const file of responseFiles) {
     const id = file.replace(/^response-/, "").replace(/\.md$/, "");
-    responses[id] = readFileSync19(join29(sessionPath, file), "utf-8");
+    responses[id] = readFileSync20(join30(sessionPath, file), "utf-8");
   }
-  const input = readFileSync19(join29(sessionPath, "input.md"), "utf-8");
+  const input = readFileSync20(join30(sessionPath, "input.md"), "utf-8");
   const judgePrompt = buildJudgePrompt(input, responses);
-  writeFileSync11(join29(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
+  writeFileSync12(join30(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
   const judgeModels = opts.judges ?? getDefaultJudgeModels(sessionPath);
-  const judgePath = join29(sessionPath, "judging");
-  mkdirSync11(judgePath, { recursive: true });
+  const judgePath = join30(sessionPath, "judging");
+  mkdirSync12(judgePath, { recursive: true });
   setupSession(judgePath, judgeModels, judgePrompt);
   await runModels(judgePath, { claudeFlags: opts.claudeFlags });
   const votes = parseJudgeVotes(judgePath, Object.keys(responses));
   const verdict = aggregateVerdict(votes, Object.keys(responses));
-  writeFileSync11(join29(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
+  writeFileSync12(join30(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
   return verdict;
 }
 function getStatus(sessionPath) {
-  return JSON.parse(readFileSync19(join29(sessionPath, "status.json"), "utf-8"));
+  return JSON.parse(readFileSync20(join30(sessionPath, "status.json"), "utf-8"));
 }
 function fisherYatesShuffle(arr) {
   for (let i = arr.length - 1;i > 0; i--) {
@@ -41749,7 +41969,7 @@ function fisherYatesShuffle(arr) {
   return arr;
 }
 function getDefaultJudgeModels(sessionPath) {
-  const manifest = JSON.parse(readFileSync19(join29(sessionPath, "manifest.json"), "utf-8"));
+  const manifest = JSON.parse(readFileSync20(join30(sessionPath, "manifest.json"), "utf-8"));
   return Object.values(manifest.models).map((e) => e.model);
 }
 function buildJudgePrompt(input, responses) {
@@ -41812,7 +42032,7 @@ function parseJudgeVotes(judgePath, responseIds) {
     const judgeId = file.replace(/^response-/, "").replace(/\.md$/, "");
     let content;
     try {
-      content = readFileSync19(join29(judgePath, file), "utf-8");
+      content = readFileSync20(join30(judgePath, file), "utf-8");
     } catch {
       continue;
     }
@@ -41864,7 +42084,7 @@ function aggregateVerdict(votes, responseIds) {
 function formatVerdict(verdict, sessionPath) {
   let manifest = null;
   try {
-    manifest = JSON.parse(readFileSync19(join29(sessionPath, "manifest.json"), "utf-8"));
+    manifest = JSON.parse(readFileSync20(join30(sessionPath, "manifest.json"), "utf-8"));
   } catch {}
   let output = `# Team Verdict
 
@@ -41918,15 +42138,15 @@ import {
   appendFileSync as appendFileSync6,
   closeSync as closeSync7,
   createWriteStream as createWriteStream2,
-  mkdirSync as mkdirSync12,
+  mkdirSync as mkdirSync13,
   openSync as openSync7,
-  readFileSync as readFileSync20,
+  readFileSync as readFileSync21,
   readSync as readSync3,
   statSync as statSync6,
-  writeFileSync as writeFileSync12
+  writeFileSync as writeFileSync13
 } from "fs";
-import { homedir as homedir28 } from "os";
-import { join as join30, resolve as resolve4, sep } from "path";
+import { homedir as homedir29 } from "os";
+import { join as join31, resolve as resolve4, sep } from "path";
 import { StringDecoder as StringDecoder2 } from "string_decoder";
 function buildChannelSpawnArgs(opts) {
   return [
@@ -42001,7 +42221,7 @@ function readJsonObject(path, maxBytes) {
   try {
     if (fileSize(path) > maxBytes)
       return null;
-    const parsed = JSON.parse(readFileSync20(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync21(path, "utf-8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
       return null;
     return parsed;
@@ -42017,7 +42237,7 @@ function dropLeadingFragment(tail) {
   return firstBreak === -1 ? tail.text : tail.text.slice(firstBreak + 1);
 }
 function diskAccounting(sessionDir) {
-  const stats = readTokenStatsAt(join30(sessionDir, "tokens.json"));
+  const stats = readTokenStatsAt(join31(sessionDir, "tokens.json"));
   return {
     tokensUsed: (stats?.total_tokens ?? 0) || (stats?.input_tokens ?? 0) + (stats?.output_tokens ?? 0),
     costUsd: stats?.total_cost ?? 0,
@@ -42057,7 +42277,7 @@ class SessionManager {
     this.maxSessions = options?.maxSessions ?? DEFAULT_MAX_SESSIONS;
     this.scrollbackCapacity = options?.scrollbackCapacity ?? DEFAULT_SCROLLBACK;
     this.terminalRetentionMs = options?.terminalRetentionMs ?? TERMINAL_RETENTION_MS;
-    this.sessionsDir = options?.sessionsDir ?? process.env.CLAUDISH_SESSIONS_DIR ?? join30(homedir28(), ".claudish", "sessions");
+    this.sessionsDir = options?.sessionsDir ?? process.env.CLAUDISH_SESSIONS_DIR ?? join31(homedir29(), ".claudish", "sessions");
     this.stallSeconds = options?.stallSeconds;
     this.onStateChange = options?.onStateChange;
   }
@@ -42073,19 +42293,19 @@ class SessionManager {
     const claudeSessionId = randomUUID4();
     const timeout = Math.min(opts.timeoutSeconds ?? DEFAULT_TIMEOUT, MAX_TIMEOUT);
     const startedAt = new Date().toISOString();
-    const sessionDir = opts.sessionDir ?? join30(this.sessionsDir, sessionId);
-    mkdirSync12(sessionDir, { recursive: true });
+    const sessionDir = opts.sessionDir ?? join31(this.sessionsDir, sessionId);
+    mkdirSync13(sessionDir, { recursive: true });
     if (opts.prompt) {
-      writeFileSync12(join30(sessionDir, "prompt.md"), opts.prompt, "utf-8");
+      writeFileSync13(join31(sessionDir, "prompt.md"), opts.prompt, "utf-8");
     }
     const args = buildChannelSpawnArgs({
       model: opts.spawnModel ?? opts.model,
       claudeSessionId,
       claudishFlags: opts.claudishFlags
     });
-    const tokenFile = opts.tokenFile ?? join30(sessionDir, "tokens.json");
-    const eventLogPath = join30(sessionDir, "events.jsonl");
-    const upstreamErrorLogPath = join30(sessionDir, "upstream-errors.jsonl");
+    const tokenFile = opts.tokenFile ?? join31(sessionDir, "tokens.json");
+    const eventLogPath = join31(sessionDir, "events.jsonl");
+    const upstreamErrorLogPath = join31(sessionDir, "upstream-errors.jsonl");
     const cwd = opts.cwd ?? process.cwd();
     const spawnTarget = resolveClaudishSpawn();
     const proc = spawn3(spawnTarget.command, [...spawnTarget.prefixArgs, ...args], {
@@ -42100,7 +42320,7 @@ class SessionManager {
       }
     });
     const scrollback = new ScrollbackBuffer(this.scrollbackCapacity);
-    const outputLogStream = createWriteStream2(join30(sessionDir, "output.log"));
+    const outputLogStream = createWriteStream2(join31(sessionDir, "output.log"));
     const entry = {
       info: {
         sessionId,
@@ -42392,7 +42612,7 @@ class SessionManager {
       return null;
     const root = resolve4(this.sessionsDir);
     const dir = resolve4(root, sessionId);
-    if (dir !== join30(root, sessionId))
+    if (dir !== join31(root, sessionId))
       return null;
     if (!dir.startsWith(root + sep))
       return null;
@@ -42411,7 +42631,7 @@ class SessionManager {
     } catch {
       return null;
     }
-    const meta = readJsonObject(join30(sessionDir, "meta.json"), META_READ_LIMIT);
+    const meta = readJsonObject(join31(sessionDir, "meta.json"), META_READ_LIMIT);
     const partial = meta === null;
     const measured = diskAccounting(sessionDir);
     const startedAt = metaString(meta?.startedAt) ?? new Date(dirMtimeMs).toISOString();
@@ -42441,7 +42661,7 @@ class SessionManager {
     };
   }
   diskOutput(record, tailLines) {
-    const tail = readTailText(join30(record.sessionDir, "output.log"), OUTPUT_TAIL_BYTES);
+    const tail = readTailText(join31(record.sessionDir, "output.log"), OUTPUT_TAIL_BYTES);
     const buffer = new ScrollbackBuffer(this.scrollbackCapacity);
     if (tail?.text)
       buffer.append(dropLeadingFragment(tail));
@@ -42460,9 +42680,9 @@ class SessionManager {
   }
   diskDiagnostics(record, limit) {
     const { sessionDir, info } = record;
-    const eventLogPath = join30(sessionDir, "events.jsonl");
-    const upstreamErrorLogPath = join30(sessionDir, "upstream-errors.jsonl");
-    const outputLogPath = join30(sessionDir, "output.log");
+    const eventLogPath = join31(sessionDir, "events.jsonl");
+    const upstreamErrorLogPath = join31(sessionDir, "upstream-errors.jsonl");
+    const outputLogPath = join31(sessionDir, "output.log");
     const events = readTailLines(eventLogPath, EVENT_TAIL_BYTES);
     const outputTail = readTailText(outputLogPath, OUTPUT_TAIL_BYTES);
     return {
@@ -42504,7 +42724,7 @@ class SessionManager {
     };
   }
   diskStderrForDiagnostics(record) {
-    const tail = readTailText(join30(record.sessionDir, "stderr.log"), STDERR_READ_BYTES);
+    const tail = readTailText(join31(record.sessionDir, "stderr.log"), STDERR_READ_BYTES);
     const raw = tail?.text ?? "";
     const filtered = record.info.status === "completed";
     const source = filtered ? meaningfulStderr(raw) : raw;
@@ -42680,11 +42900,11 @@ ${STDERR_TRUNCATION_MARKER} ${STDERR_SIDE_LIMIT} bytes per end \u2026
     entry.outputLogStream?.end();
     entry.outputLogStream = null;
     if (entry.stderr) {
-      writeFileSync12(join30(entry.sessionDir, "stderr.log"), redactSecrets(entry.stderr), "utf-8");
+      writeFileSync13(join31(entry.sessionDir, "stderr.log"), redactSecrets(entry.stderr), "utf-8");
     }
     this.refreshAccounting(entry);
     entry.info.claudeSessionId = entry.reducer.claudeSessionId ?? entry.info.claudeSessionId;
-    writeFileSync12(join30(entry.sessionDir, "meta.json"), JSON.stringify(entry.info, null, 2), "utf-8");
+    writeFileSync13(join31(entry.sessionDir, "meta.json"), JSON.stringify(entry.info, null, 2), "utf-8");
   }
   scheduleEviction(entry) {
     if (entry.evictHandle)
@@ -42744,7 +42964,7 @@ ${STDERR_TRUNCATION_MARKER} ${STDERR_SIDE_LIMIT} bytes per end \u2026
     return { state: "completed", content: "" };
   }
   refreshAccounting(entry) {
-    const stats = readTokenStatsAt(join30(entry.sessionDir, "tokens.json"));
+    const stats = readTokenStatsAt(join31(entry.sessionDir, "tokens.json"));
     const fileTokens = (stats?.total_tokens ?? 0) || (stats?.input_tokens ?? 0) + (stats?.output_tokens ?? 0);
     entry.info.tokensUsed = fileTokens || entry.reducer.tokens;
     entry.info.costUsd = stats?.total_cost ?? 0;
@@ -42942,9 +43162,9 @@ var init_cache_ttl = __esm(() => {
 });
 
 // src/model-loader.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync13, readFileSync as readFileSync21, writeFileSync as writeFileSync13 } from "fs";
-import { homedir as homedir29 } from "os";
-import { join as join31 } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync14, readFileSync as readFileSync22, writeFileSync as writeFileSync14 } from "fs";
+import { homedir as homedir30 } from "os";
+import { join as join32 } from "path";
 function groupRecommendedModels(entries) {
   const byId = new Map;
   const categoryOrder = new Map;
@@ -43072,9 +43292,9 @@ async function getRecommendedModels(opts = {}) {
   if (!forceRefresh && _cachedRecommendedModels) {
     return _cachedRecommendedModels;
   }
-  if (!forceRefresh && existsSync21(RECOMMENDED_MODELS_CACHE_PATH)) {
+  if (!forceRefresh && existsSync22(RECOMMENDED_MODELS_CACHE_PATH)) {
     try {
-      const cacheData = JSON.parse(readFileSync21(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
+      const cacheData = JSON.parse(readFileSync22(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
       if (cacheData.models && cacheData.models.length > 0 && isFreshEnough(cacheData)) {
         _cachedRecommendedModels = cacheData;
         return cacheData;
@@ -43090,9 +43310,9 @@ async function getRecommendedModels(opts = {}) {
       if (data.models && data.models.length > 0) {
         _cachedRecommendedModels = data;
         try {
-          const cacheDir = join31(homedir29(), ".claudish");
-          mkdirSync13(cacheDir, { recursive: true });
-          writeFileSync13(RECOMMENDED_MODELS_CACHE_PATH, JSON.stringify(data), "utf-8");
+          const cacheDir = join32(homedir30(), ".claudish");
+          mkdirSync14(cacheDir, { recursive: true });
+          writeFileSync14(RECOMMENDED_MODELS_CACHE_PATH, JSON.stringify(data), "utf-8");
         } catch {}
         return data;
       }
@@ -43103,9 +43323,9 @@ async function getRecommendedModels(opts = {}) {
 function getRecommendedModelsSync() {
   if (_cachedRecommendedModels)
     return _cachedRecommendedModels;
-  if (existsSync21(RECOMMENDED_MODELS_CACHE_PATH)) {
+  if (existsSync22(RECOMMENDED_MODELS_CACHE_PATH)) {
     try {
-      const cacheData = JSON.parse(readFileSync21(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
+      const cacheData = JSON.parse(readFileSync22(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
       if (cacheData.models && cacheData.models.length > 0 && isFreshEnough(cacheData)) {
         _cachedRecommendedModels = cacheData;
         return cacheData;
@@ -43229,7 +43449,7 @@ var _cachedModelInfo = null, _cachedModelIds = null, _cachedRecommendedModels =
 var init_model_loader = __esm(() => {
   init_cache_ttl();
   FIREBASE_RECOMMENDED_URL = `${FIREBASE_BASE_URL}?catalog=recommended`;
-  RECOMMENDED_MODELS_CACHE_PATH = join31(homedir29(), ".claudish", "recommended-models-cache.json");
+  RECOMMENDED_MODELS_CACHE_PATH = join32(homedir30(), ".claudish", "recommended-models-cache.json");
   FIREBASE_SLUG_TO_PROVIDER_NAME = {
     openai: "openai",
     google: "google",
@@ -48239,9 +48459,9 @@ var init_poe = __esm(() => {
 });
 
 // src/services/pricing-cache.ts
-import { existsSync as existsSync22, readFileSync as readFileSync22, statSync as statSync7 } from "fs";
-import { homedir as homedir30 } from "os";
-import { join as join32 } from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync23, statSync as statSync7 } from "fs";
+import { homedir as homedir31 } from "os";
+import { join as join33 } from "path";
 function prefixMatch(modelName) {
   for (const [key, pricing] of pricingMap) {
     if (modelName.startsWith(key))
@@ -48279,12 +48499,12 @@ async function warmPricingCache() {
 }
 function loadDiskCache() {
   try {
-    if (!existsSync22(CACHE_FILE))
+    if (!existsSync23(CACHE_FILE))
       return false;
     const stat = statSync7(CACHE_FILE);
     const age = Date.now() - stat.mtimeMs;
     const isFresh = age < CACHE_TTL_MS3;
-    const raw = readFileSync22(CACHE_FILE, "utf-8");
+    const raw = readFileSync23(CACHE_FILE, "utf-8");
     const data = JSON.parse(raw);
     for (const [key, pricing] of Object.entries(data)) {
       pricingMap.set(key, pricing);
@@ -48300,21 +48520,24 @@ var init_pricing_cache = __esm(() => {
   init_logger();
   init_catalog_query();
   pricingMap = new Map;
-  CACHE_DIR = join32(homedir30(), ".claudish");
-  CACHE_FILE = join32(CACHE_DIR, "pricing-cache.json");
+  CACHE_DIR = join33(homedir31(), ".claudish");
+  CACHE_FILE = join33(CACHE_DIR, "pricing-cache.json");
   CACHE_TTL_MS3 = 24 * 60 * 60 * 1000;
 });
 
 // src/proxy-server.ts
-import { appendFileSync as appendFileSync8, mkdirSync as mkdirSync14 } from "fs";
-import { join as join33 } from "path";
+import { appendFileSync as appendFileSync8, mkdirSync as mkdirSync15 } from "fs";
+import { join as join34 } from "path";
+function isTerminalRoutingFailure(e) {
+  return e instanceof RoutingError || e instanceof CatalogIncompatibleError;
+}
 function maybeCaptureClassifierRequest(c, body) {
   if (!process.env.CLAUDISH_CLASSIFIER_DEBUG)
     return;
   try {
-    const dir = join33(process.cwd(), "logs");
+    const dir = join34(process.cwd(), "logs");
     if (!classifierCaptureDirReady) {
-      mkdirSync14(dir, { recursive: true });
+      mkdirSync15(dir, { recursive: true });
       classifierCaptureDirReady = true;
     }
     const record = {
@@ -48337,7 +48560,7 @@ function maybeCaptureClassifierRequest(c, body) {
         "x-api-key": c.req.header("x-api-key") ? "<present>" : null
       }
     };
-    appendFileSync8(join33(dir, "classifier-capture.jsonl"), `${JSON.stringify(record)}
+    appendFileSync8(join34(dir, "classifier-capture.jsonl"), `${JSON.stringify(record)}
 `);
   } catch {}
 }
@@ -48759,7 +48982,7 @@ ${plan.hint}` : `[Route] ${plan.reason}`;
       const txt = JSON.stringify(body);
       return c.json({ input_tokens: Math.ceil(txt.length / 4) });
     } catch (e) {
-      if (e instanceof RoutingError) {
+      if (isTerminalRoutingFailure(e)) {
         return c.json(wrapAnthropicError(400, e.message, "invalid_request_error"), 400);
       }
       return c.json(wrapAnthropicError(500, String(e)), 500);
@@ -48779,7 +49002,7 @@ ${plan.hint}` : `[Route] ${plan.reason}`;
       return await handler.handle(c, body);
     } catch (e) {
       log(`[Proxy] Error: ${e}`);
-      if (e instanceof RoutingError) {
+      if (isTerminalRoutingFailure(e)) {
         return c.json(wrapAnthropicError(400, e.message, "invalid_request_error"), 400);
       }
       return c.json(wrapAnthropicError(500, String(e)), 500);
@@ -48842,6 +49065,7 @@ var init_proxy_server = __esm(() => {
   init_profile_config();
   init_auto_route();
   init_catalog_client();
+  init_catalog_compatibility();
   init_endpoint_diagnostics();
   init_endpoint_registration();
   init_model_parser();
@@ -48864,14 +49088,14 @@ var init_proxy_server = __esm(() => {
 });
 
 // src/mcp-server.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync15, readFileSync as readFileSync23, readdirSync as readdirSync6, writeFileSync as writeFileSync14 } from "fs";
-import { homedir as homedir31 } from "os";
-import { dirname as dirname9, join as join34, resolve as resolve5 } from "path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync16, readFileSync as readFileSync24, readdirSync as readdirSync6, writeFileSync as writeFileSync15 } from "fs";
+import { homedir as homedir32 } from "os";
+import { dirname as dirname10, join as join35, resolve as resolve5 } from "path";
 import { fileURLToPath } from "url";
 async function loadAllModels(forceRefresh = false) {
-  if (!forceRefresh && existsSync23(ALL_MODELS_CACHE_PATH2)) {
+  if (!forceRefresh && existsSync24(ALL_MODELS_CACHE_PATH2)) {
     try {
-      const cacheData = JSON.parse(readFileSync23(ALL_MODELS_CACHE_PATH2, "utf-8"));
+      const cacheData = JSON.parse(readFileSync24(ALL_MODELS_CACHE_PATH2, "utf-8"));
       const lastUpdated = new Date(cacheData.lastUpdated);
       const ageInDays = (Date.now() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24);
       if (ageInDays <= CACHE_MAX_AGE_DAYS) {
@@ -48885,12 +49109,12 @@ async function loadAllModels(forceRefresh = false) {
       throw new Error(`API returned ${response.status}`);
     const data = await response.json();
     const models = data.data || [];
-    mkdirSync15(CLAUDISH_CACHE_DIR, { recursive: true });
-    writeFileSync14(ALL_MODELS_CACHE_PATH2, JSON.stringify({ lastUpdated: new Date().toISOString(), models }), "utf-8");
+    mkdirSync16(CLAUDISH_CACHE_DIR, { recursive: true });
+    writeFileSync15(ALL_MODELS_CACHE_PATH2, JSON.stringify({ lastUpdated: new Date().toISOString(), models }), "utf-8");
     return models;
   } catch {
-    if (existsSync23(ALL_MODELS_CACHE_PATH2)) {
-      const cacheData = JSON.parse(readFileSync23(ALL_MODELS_CACHE_PATH2, "utf-8"));
+    if (existsSync24(ALL_MODELS_CACHE_PATH2)) {
+      const cacheData = JSON.parse(readFileSync24(ALL_MODELS_CACHE_PATH2, "utf-8"));
       return cacheData.models || [];
     }
     return [];
@@ -49753,7 +49977,7 @@ Use with: run_prompt(model="${suggested}", prompt="your prompt")`;
       let stderrFull = stderr_snippet || "";
       if (error_log_path) {
         try {
-          stderrFull = readFileSync23(error_log_path, "utf-8");
+          stderrFull = readFileSync24(error_log_path, "utf-8");
         } catch {}
       }
       const sessionData = {};
@@ -49761,16 +49985,16 @@ Use with: run_prompt(model="${suggested}", prompt="your prompt")`;
         const sp = session_path;
         for (const file of ["status.json", "manifest.json", "input.md"]) {
           try {
-            sessionData[file] = readFileSync23(join34(sp, file), "utf-8");
+            sessionData[file] = readFileSync24(join35(sp, file), "utf-8");
           } catch {}
         }
         try {
-          const errorDir = join34(sp, "errors");
-          if (existsSync23(errorDir)) {
+          const errorDir = join35(sp, "errors");
+          if (existsSync24(errorDir)) {
             for (const f of readdirSync6(errorDir)) {
               if (f.endsWith(".log")) {
                 try {
-                  sessionData[`errors/${f}`] = readFileSync23(join34(errorDir, f), "utf-8");
+                  sessionData[`errors/${f}`] = readFileSync24(join35(errorDir, f), "utf-8");
                 } catch {}
               }
             }
@@ -49780,7 +50004,7 @@ Use with: run_prompt(model="${suggested}", prompt="your prompt")`;
           for (const f of readdirSync6(sp)) {
             if (f.startsWith("response-") && f.endsWith(".md")) {
               try {
-                const content = readFileSync23(join34(sp, f), "utf-8");
+                const content = readFileSync24(join35(sp, f), "utf-8");
                 sessionData[f] = content.slice(0, 200) + (content.length > 200 ? "... (truncated)" : "");
               } catch {}
             }
@@ -49789,9 +50013,9 @@ Use with: run_prompt(model="${suggested}", prompt="your prompt")`;
       }
       let version = "unknown";
       try {
-        const pkgPath = join34(__dirname2, "../package.json");
-        if (existsSync23(pkgPath)) {
-          version = JSON.parse(readFileSync23(pkgPath, "utf-8")).version;
+        const pkgPath = join35(__dirname2, "../package.json");
+        if (existsSync24(pkgPath)) {
+          version = JSON.parse(readFileSync24(pkgPath, "utf-8")).version;
         }
       } catch {}
       const report = {
@@ -50258,9 +50482,9 @@ var init_mcp_server = __esm(() => {
   import_dotenv2 = __toESM(require_main(), 1);
   import_dotenv2.config({ quiet: true });
   __filename2 = fileURLToPath(import.meta.url);
-  __dirname2 = dirname9(__filename2);
-  CLAUDISH_CACHE_DIR = join34(homedir31(), ".claudish");
-  ALL_MODELS_CACHE_PATH2 = join34(CLAUDISH_CACHE_DIR, "all-models.json");
+  __dirname2 = dirname10(__filename2);
+  CLAUDISH_CACHE_DIR = join35(homedir32(), ".claudish");
+  ALL_MODELS_CACHE_PATH2 = join35(CLAUDISH_CACHE_DIR, "all-models.json");
   NEXT_STEP = {
     nonzero_exit: "read the evidence log, then retry or drop the model",
     cancelled: "you stopped this slot; nothing is wrong with it. Re-run it if you still want its vote",
@@ -50284,7 +50508,7 @@ var init_mcp_server = __esm(() => {
 });
 
 // src/serve-command.ts
-import { existsSync as existsSync24, readFileSync as readFileSync24 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync25 } from "fs";
 function parseServeArgs(args) {
   const out = {};
   for (let i = 0;i < args.length; i++) {
@@ -50303,12 +50527,12 @@ function parseServeArgs(args) {
   return out;
 }
 function loadModelMap(path) {
-  if (!existsSync24(path)) {
+  if (!existsSync25(path)) {
     throw new Error(`--models file not found: ${path}`);
   }
   let raw;
   try {
-    raw = readFileSync24(path, "utf-8");
+    raw = readFileSync25(path, "utf-8");
   } catch (e) {
     throw new Error(`failed to read --models file ${path}: ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -50588,7 +50812,7 @@ var init_ansi = __esm(() => {
 });
 
 // src/behavior-command.ts
-import { existsSync as existsSync25, readFileSync as readFileSync25, writeFileSync as writeFileSync15 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync26, writeFileSync as writeFileSync16 } from "fs";
 function severityColor(sev) {
   if (sev === "fix")
     return green(sev);
@@ -50686,8 +50910,8 @@ function setTelemetryEnabled(value) {
   const path = getConfigPath();
   let cfg = {};
   try {
-    if (existsSync25(path)) {
-      const parsed = JSON.parse(readFileSync25(path, "utf-8"));
+    if (existsSync26(path)) {
+      const parsed = JSON.parse(readFileSync26(path, "utf-8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         cfg = parsed;
       }
@@ -50696,7 +50920,7 @@ function setTelemetryEnabled(value) {
   const behavior = cfg.behavior && typeof cfg.behavior === "object" && !Array.isArray(cfg.behavior) ? { ...cfg.behavior } : {};
   behavior.telemetry = { enabled: value };
   cfg.behavior = behavior;
-  writeFileSync15(path, `${JSON.stringify(cfg, null, 2)}
+  writeFileSync16(path, `${JSON.stringify(cfg, null, 2)}
 `, "utf-8");
 }
 function showTelemetry(action, json) {
@@ -50708,8 +50932,8 @@ function showTelemetry(action, json) {
   let pending = 0;
   try {
     const path = outboxPath();
-    if (existsSync25(path)) {
-      pending = readFileSync25(path, "utf8").split(`
+    if (existsSync26(path)) {
+      pending = readFileSync26(path, "utf8").split(`
 `).filter(Boolean).length;
     }
   } catch {}
@@ -50790,9 +51014,9 @@ var init_behavior_command = __esm(() => {
 // src/team-grid.ts
 import { spawn as spawn4 } from "child_process";
 import { execSync } from "child_process";
-import { existsSync as existsSync26, readFileSync as readFileSync26, writeFileSync as writeFileSync16 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync27, writeFileSync as writeFileSync17 } from "fs";
 import { connect as netConnect } from "net";
-import { dirname as dirname10, join as join35 } from "path";
+import { dirname as dirname11, join as join36 } from "path";
 import { setTimeout as wait } from "timers/promises";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveRouteInfo(modelId) {
@@ -50885,21 +51109,21 @@ function buildPaneHeader(model, prompt, bg) {
 }
 function findMagmuxBinary() {
   const thisFile = fileURLToPath2(import.meta.url);
-  const thisDir = dirname10(thisFile);
-  const pkgRoot = join35(thisDir, "..");
+  const thisDir = dirname11(thisFile);
+  const pkgRoot = join36(thisDir, "..");
   const platform = process.platform;
   const arch = process.arch;
-  const bundledMagmux = join35(pkgRoot, "native", `magmux-${platform}-${arch}`);
-  if (existsSync26(bundledMagmux))
+  const bundledMagmux = join36(pkgRoot, "native", `magmux-${platform}-${arch}`);
+  if (existsSync27(bundledMagmux))
     return bundledMagmux;
   try {
     const pkgName = `@claudish/magmux-${platform}-${arch}`;
     let searchDir = pkgRoot;
     for (let i = 0;i < 5; i++) {
-      const candidate = join35(searchDir, "node_modules", pkgName, "bin", "magmux");
-      if (existsSync26(candidate))
+      const candidate = join36(searchDir, "node_modules", pkgName, "bin", "magmux");
+      if (existsSync27(candidate))
         return candidate;
-      const parent = dirname10(searchDir);
+      const parent = dirname11(searchDir);
       if (parent === searchDir)
         break;
       searchDir = parent;
@@ -50921,7 +51145,7 @@ function withoutControlPanes(evt) {
 async function subscribeToMagmux(sockPath, onEvent) {
   let client = null;
   for (let attempt = 0;attempt < 40; attempt++) {
-    if (existsSync26(sockPath)) {
+    if (existsSync27(sockPath)) {
       try {
         client = await new Promise((resolve, reject) => {
           const s = netConnect(sockPath);
@@ -51008,9 +51232,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 = join35(sessionPath, "gridfile.txt");
-  const prompt = readFileSync26(join35(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
-  const rawPrompt = readFileSync26(join35(sessionPath, "input.md"), "utf-8");
+  const gridfilePath = join36(sessionPath, "gridfile.txt");
+  const prompt = readFileSync27(join36(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
+  const rawPrompt = readFileSync27(join36(sessionPath, "input.md"), "utf-8");
   const usedBannerColors = new Set;
   const gridLines = Object.entries(manifest.models).map(([anonId]) => {
     const model = manifest.models[anonId].model;
@@ -51021,7 +51245,7 @@ async function runWithGrid(sessionPath, models, input, opts) {
     const header = buildPaneHeader(model, rawPrompt, bg);
     return `${header} claudish --model ${model} -y --quiet '${prompt}'`;
   });
-  writeFileSync16(gridfilePath, `${gridLines.join(`
+  writeFileSync17(gridfilePath, `${gridLines.join(`
 `)}
 `, "utf-8");
   const magmuxPath = findMagmuxBinary();
@@ -51041,8 +51265,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 = join35(sessionPath, "status.json");
-  writeFileSync16(statusPath, JSON.stringify(status, null, 2), "utf-8");
+  const statusPath = join36(sessionPath, "status.json");
+  writeFileSync17(statusPath, JSON.stringify(status, null, 2), "utf-8");
   return status;
 }
 var BANNER_BG_COLORS;
@@ -51062,8 +51286,8 @@ var init_team_grid = __esm(() => {
 });
 
 // src/team-cli.ts
-import { readFileSync as readFileSync27 } from "fs";
-import { join as join36 } from "path";
+import { readFileSync as readFileSync28 } from "fs";
+import { join as join37 } from "path";
 function getFlag(args, flag) {
   const idx = args.indexOf(flag);
   if (idx === -1 || idx + 1 >= args.length)
@@ -51186,7 +51410,7 @@ async function teamCommand(args) {
     }
     case "judge": {
       await judgeResponses(sessionPath, { judges });
-      console.log(readFileSync27(join36(sessionPath, "verdict.md"), "utf-8"));
+      console.log(readFileSync28(join37(sessionPath, "verdict.md"), "utf-8"));
       break;
     }
     case "run-and-judge": {
@@ -51203,7 +51427,7 @@ async function teamCommand(args) {
       });
       printStatus(status);
       await judgeResponses(sessionPath, { judges });
-      console.log(readFileSync27(join36(sessionPath, "verdict.md"), "utf-8"));
+      console.log(readFileSync28(join37(sessionPath, "verdict.md"), "utf-8"));
       break;
     }
     case "status": {
@@ -54027,9 +54251,9 @@ var init_keychain_command = __esm(() => {
 
 // src/auth/antigravity-oauth.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync27, unlinkSync as unlinkSync6 } from "fs";
-import { homedir as homedir32 } from "os";
-import { join as join37 } from "path";
+import { existsSync as existsSync28, unlinkSync as unlinkSync6 } from "fs";
+import { homedir as homedir33 } from "os";
+import { join as join38 } from "path";
 async function defaultSuggestModel() {
   try {
     const tok = readSharedAntigravityToken();
@@ -54150,8 +54374,8 @@ No session detected yet. Starting the Antigravity CLI interactively \u2014
   async logout(deps) {
     deleteSharedAntigravityToken(deps);
     try {
-      const tokenFile = join37(homedir32(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
-      if (existsSync27(tokenFile))
+      const tokenFile = join38(homedir33(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
+      if (existsSync28(tokenFile))
         unlinkSync6(tokenFile);
     } catch {}
     log("[AntigravityOAuth] Antigravity session cleared (keychain + agy token file)");
@@ -57942,6 +58166,51 @@ var init_api_key_map = __esm(() => {
   };
 });
 
+// src/providers/provider-slug-resolve.ts
+function sharedPrefixLength(a, b) {
+  let n = 0;
+  while (n < a.length && n < b.length && a[n] === b[n])
+    n++;
+  return n;
+}
+function rankSuggestions(typed, providers) {
+  const needle = typed.toLowerCase();
+  const scored = [];
+  for (const provider of providers) {
+    const slug = provider.slug.toLowerCase();
+    let score = 0;
+    if (slug.includes(needle) || needle.includes(slug)) {
+      score = 2;
+    } else if (sharedPrefixLength(slug, needle) >= MIN_PREFIX_OVERLAP) {
+      score = 1;
+    }
+    if (score > 0)
+      scored.push({ provider, score });
+  }
+  scored.sort((a, b) => b.score - a.score || b.provider.count - a.provider.count);
+  return scored.slice(0, SUGGESTION_LIMIT).map((s) => s.provider);
+}
+function resolveProviderSlug(typed, providers) {
+  const routingOwner = reservedNamespaceOwner(typed) ?? null;
+  if (providers.length === 0) {
+    return { kind: "match", canonical: typed, suggestions: [], routingOwner };
+  }
+  const exact = providers.find((p) => p.slug.toLowerCase() === typed.toLowerCase());
+  if (exact) {
+    return { kind: "match", canonical: exact.slug, suggestions: [], routingOwner };
+  }
+  return {
+    kind: "unknown",
+    canonical: null,
+    suggestions: rankSuggestions(typed, providers),
+    routingOwner
+  };
+}
+var SUGGESTION_LIMIT = 5, MIN_PREFIX_OVERLAP = 3;
+var init_provider_slug_resolve = __esm(() => {
+  init_reserved_namespace();
+});
+
 // src/branding.ts
 function paint(line) {
   const { RESET, BOLD, CYAN, BLUE, DIM } = cliAnsi();
@@ -58000,33 +58269,33 @@ var init_branding = __esm(() => {
 });
 
 // src/update-checker.ts
-import { existsSync as existsSync28, mkdirSync as mkdirSync16, readFileSync as readFileSync28, unlinkSync as unlinkSync7, writeFileSync as writeFileSync17 } from "fs";
-import { homedir as homedir33, platform as platform2, tmpdir } from "os";
-import { join as join38 } from "path";
+import { existsSync as existsSync29, mkdirSync as mkdirSync17, readFileSync as readFileSync29, unlinkSync as unlinkSync7, writeFileSync as writeFileSync18 } from "fs";
+import { homedir as homedir34, platform as platform2, tmpdir } from "os";
+import { join as join39 } from "path";
 function getCacheFilePath() {
   let cacheDir;
   if (isWindows) {
-    const localAppData = process.env.LOCALAPPDATA || join38(homedir33(), "AppData", "Local");
-    cacheDir = join38(localAppData, "claudish");
+    const localAppData = process.env.LOCALAPPDATA || join39(homedir34(), "AppData", "Local");
+    cacheDir = join39(localAppData, "claudish");
   } else {
-    cacheDir = join38(homedir33(), ".cache", "claudish");
+    cacheDir = join39(homedir34(), ".cache", "claudish");
   }
   try {
-    if (!existsSync28(cacheDir)) {
-      mkdirSync16(cacheDir, { recursive: true });
+    if (!existsSync29(cacheDir)) {
+      mkdirSync17(cacheDir, { recursive: true });
     }
-    return join38(cacheDir, "update-check.json");
+    return join39(cacheDir, "update-check.json");
   } catch {
-    return join38(tmpdir(), "claudish-update-check.json");
+    return join39(tmpdir(), "claudish-update-check.json");
   }
 }
 function readCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (!existsSync28(cachePath)) {
+    if (!existsSync29(cachePath)) {
       return null;
     }
-    const data = JSON.parse(readFileSync28(cachePath, "utf-8"));
+    const data = JSON.parse(readFileSync29(cachePath, "utf-8"));
     return data;
   } catch {
     return null;
@@ -58039,7 +58308,7 @@ function writeCache(latestVersion) {
       lastCheck: Date.now(),
       latestVersion
     };
-    writeFileSync17(cachePath, JSON.stringify(data), "utf-8");
+    writeFileSync18(cachePath, JSON.stringify(data), "utf-8");
   } catch {}
 }
 function isCacheValid(cache) {
@@ -58049,7 +58318,7 @@ function isCacheValid(cache) {
 function clearCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (existsSync28(cachePath)) {
+    if (existsSync29(cachePath)) {
       unlinkSync7(cachePath);
     }
   } catch {}
@@ -58134,22 +58403,22 @@ var init_update_checker = __esm(() => {
 // src/cli.ts
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync29,
-  mkdirSync as mkdirSync17,
-  readFileSync as readFileSync29,
+  existsSync as existsSync30,
+  mkdirSync as mkdirSync18,
+  readFileSync as readFileSync30,
   readdirSync as readdirSync7,
   unlinkSync as unlinkSync8,
-  writeFileSync as writeFileSync18
+  writeFileSync as writeFileSync19
 } from "fs";
-import { homedir as homedir34 } from "os";
-import { dirname as dirname11, join as join39 } from "path";
+import { homedir as homedir35 } from "os";
+import { dirname as dirname12, join as join40 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function getVersion3() {
   return VERSION;
 }
 function clearAllModelCaches() {
-  const cacheDir = join39(homedir34(), ".claudish");
-  if (!existsSync29(cacheDir))
+  const cacheDir = join40(homedir35(), ".claudish");
+  if (!existsSync30(cacheDir))
     return;
   const cachePatterns = ["pricing-cache.json", "recommended-models-cache.json"];
   let cleared = 0;
@@ -58157,7 +58426,7 @@ function clearAllModelCaches() {
     const files = readdirSync7(cacheDir);
     for (const file of files) {
       if (cachePatterns.includes(file)) {
-        unlinkSync8(join39(cacheDir, file));
+        unlinkSync8(join40(cacheDir, file));
         cleared++;
       }
     }
@@ -58512,7 +58781,19 @@ Usage:  claudish --models --provider <slug>`);
       const hasJsonFlag = args.includes("--json");
       const forceUpdate = config.forceUpdate || args.includes("--models-refresh");
       const providerIdx = args.indexOf("--provider");
-      const providerSlug = providerIdx !== -1 && providerIdx + 1 < args.length ? args[providerIdx + 1] : null;
+      const inlineProvider = args.find((a) => a.startsWith("--provider="));
+      let providerSlug = null;
+      if (inlineProvider) {
+        providerSlug = inlineProvider.slice("--provider=".length);
+      } else if (providerIdx !== -1) {
+        const next = args[providerIdx + 1];
+        providerSlug = next && !next.startsWith("--") ? next : "";
+      }
+      if (providerSlug === "") {
+        console.error("--provider needs a slug: claudish --models --provider <slug>");
+        console.error("Run `claudish --providers` for the full list.");
+        process.exit(1);
+      }
       if (forceUpdate)
         clearAllModelCaches();
       if (query && providerSlug) {
@@ -58619,15 +58900,15 @@ Usage:  claudish --models --provider <slug>`);
     });
     config.resolvedDefaultProvider = resolved;
     if (resolved.legacyAutoPromoted && !config.quiet) {
-      const markerFile = join39(homedir34(), ".claudish", ".legacy-litellm-hint-shown");
-      if (!existsSync29(markerFile)) {
+      const markerFile = join40(homedir35(), ".claudish", ".legacy-litellm-hint-shown");
+      if (!existsSync30(markerFile)) {
         const hint = buildLegacyHint(resolved);
         if (hint) {
           console.error(hint);
         }
         try {
-          mkdirSync17(dirname11(markerFile), { recursive: true });
-          writeFileSync18(markerFile, new Date().toISOString(), "utf-8");
+          mkdirSync18(dirname12(markerFile), { recursive: true });
+          writeFileSync19(markerFile, new Date().toISOString(), "utf-8");
         } catch {}
       }
     }
@@ -58787,7 +59068,46 @@ Top ${response.total} models from Firebase (pool: ${response.poolSize} eligible)
   console.log("Top recommended:    claudish --models-top");
   console.log("");
 }
-async function printByProvider(providerSlug, jsonOutput) {
+function printUnknownProviderSlug(typedSlug, resolved, catalogSize, jsonOutput) {
+  if (jsonOutput) {
+    console.log(JSON.stringify({
+      error: `"${typedSlug}" is not a provider slug in the model catalog`,
+      provider: typedSlug,
+      suggestions: resolved.suggestions.map((s) => s.slug),
+      routingPrefixOwner: resolved.routingOwner,
+      validSlugs: catalogSize
+    }, null, 2));
+    return;
+  }
+  console.error(`
+\u274C "${typedSlug}" is not a provider slug in the model catalog.`);
+  if (resolved.suggestions.length > 0) {
+    const list = resolved.suggestions.map((s) => `${s.slug} (${s.count} active model${s.count === 1 ? "" : "s"})`).join(", ");
+    console.error(`
+   Did you mean: ${list}`);
+  }
+  if (resolved.routingOwner) {
+    console.error(`
+   "${typedSlug}" IS a claudish routing prefix for the "${resolved.routingOwner}" provider \u2014` + `
+   use it with --model: claudish --model ${typedSlug}@<model-id>` + `
+   Routing prefixes and catalog vendor slugs are different vocabularies.`);
+  }
+  console.error(`
+   claudish --providers    lists all ${catalogSize} catalog slugs`);
+  console.error(`   claudish -s ${typedSlug}${" ".repeat(Math.max(1, 12 - typedSlug.length))}searches model ids instead
+`);
+}
+async function printByProvider(typedSlug, jsonOutput) {
+  let catalogProviders = [];
+  try {
+    catalogProviders = await getProviderList();
+  } catch {}
+  const resolved = resolveProviderSlug(typedSlug, catalogProviders);
+  if (resolved.kind === "unknown") {
+    printUnknownProviderSlug(typedSlug, resolved, catalogProviders.length, jsonOutput);
+    process.exit(1);
+  }
+  const providerSlug = resolved.canonical ?? typedSlug;
   let models;
   try {
     models = await getModelsByProvider(providerSlug, 200);
@@ -58802,8 +59122,8 @@ async function printByProvider(providerSlug, jsonOutput) {
   }
   if (models.length === 0) {
     console.log(`
-No active models found for provider "${providerSlug}". Try \`claudish -s <query>\` to search the full catalog.
-`);
+Provider "${providerSlug}" is in the catalog but has no active models right now.`);
+    console.log("Try `claudish -s <query>` to search the full catalog.\n");
     return;
   }
   console.log(`
@@ -59764,8 +60084,8 @@ ${h("MORE INFO")}
 }
 function printAIAgentGuide() {
   try {
-    const guidePath = join39(__dirname3, "../AI_AGENT_GUIDE.md");
-    const guideContent = readFileSync29(guidePath, "utf-8");
+    const guidePath = join40(__dirname3, "../AI_AGENT_GUIDE.md");
+    const guideContent = readFileSync30(guidePath, "utf-8");
     console.log(guideContent);
   } catch (error) {
     console.error("Error reading AI Agent Guide:");
@@ -59781,19 +60101,19 @@ async function initializeClaudishSkill() {
   console.log(`\uD83D\uDD27 Initializing Claudish skill in current project...
 `);
   const cwd = process.cwd();
-  const claudeDir = join39(cwd, ".claude");
-  const skillsDir = join39(claudeDir, "skills");
-  const claudishSkillDir = join39(skillsDir, "claudish-usage");
-  const skillFile = join39(claudishSkillDir, "SKILL.md");
-  if (existsSync29(skillFile)) {
+  const claudeDir = join40(cwd, ".claude");
+  const skillsDir = join40(claudeDir, "skills");
+  const claudishSkillDir = join40(skillsDir, "claudish-usage");
+  const skillFile = join40(claudishSkillDir, "SKILL.md");
+  if (existsSync30(skillFile)) {
     console.log("\u2705 Claudish skill already installed at:");
     console.log(`   ${skillFile}
 `);
     console.log("\uD83D\uDCA1 To reinstall, delete the file and run 'claudish --init' again.");
     return;
   }
-  const sourceSkillPath = join39(__dirname3, "../skills/claudish-usage/SKILL.md");
-  if (!existsSync29(sourceSkillPath)) {
+  const sourceSkillPath = join40(__dirname3, "../skills/claudish-usage/SKILL.md");
+  if (!existsSync30(sourceSkillPath)) {
     console.error("\u274C Error: Claudish skill file not found in installation.");
     console.error(`   Expected at: ${sourceSkillPath}`);
     console.error(`
@@ -59802,16 +60122,16 @@ async function initializeClaudishSkill() {
     process.exit(1);
   }
   try {
-    if (!existsSync29(claudeDir)) {
-      mkdirSync17(claudeDir, { recursive: true });
+    if (!existsSync30(claudeDir)) {
+      mkdirSync18(claudeDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/ directory");
     }
-    if (!existsSync29(skillsDir)) {
-      mkdirSync17(skillsDir, { recursive: true });
+    if (!existsSync30(skillsDir)) {
+      mkdirSync18(skillsDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/ directory");
     }
-    if (!existsSync29(claudishSkillDir)) {
-      mkdirSync17(claudishSkillDir, { recursive: true });
+    if (!existsSync30(claudishSkillDir)) {
+      mkdirSync18(claudishSkillDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/claudish-usage/ directory");
     }
     copyFileSync2(sourceSkillPath, skillFile);
@@ -59884,11 +60204,12 @@ var init_cli = __esm(() => {
   init_probe_live();
   init_probe_runner();
   init_provider_definitions();
+  init_provider_slug_resolve();
   init_routing_rules();
   init_ansi();
   init_provider_resolver();
   __filename3 = fileURLToPath3(import.meta.url);
-  __dirname3 = dirname11(__filename3);
+  __dirname3 = dirname12(__filename3);
 });
 
 // src/update-command.ts
@@ -60707,15 +61028,15 @@ var init_local_liveness = __esm(() => {
 });
 
 // src/providers/probe-catalog.ts
-import { existsSync as existsSync30, mkdirSync as mkdirSync18, readFileSync as readFileSync30, writeFileSync as writeFileSync19 } from "fs";
-import { homedir as homedir35 } from "os";
-import { dirname as dirname12, join as join40 } from "path";
+import { existsSync as existsSync31, mkdirSync as mkdirSync19, readFileSync as readFileSync31, writeFileSync as writeFileSync20 } from "fs";
+import { homedir as homedir36 } from "os";
+import { dirname as dirname13, join as join41 } from "path";
 function readProbeModelsCache(path = PROBE_MODELS_CACHE_PATH) {
-  if (!existsSync30(path))
+  if (!existsSync31(path))
     return null;
   let raw;
   try {
-    raw = JSON.parse(readFileSync30(path, "utf-8"));
+    raw = JSON.parse(readFileSync31(path, "utf-8"));
   } catch {
     return null;
   }
@@ -60724,8 +61045,8 @@ function readProbeModelsCache(path = PROBE_MODELS_CACHE_PATH) {
   return raw;
 }
 function writeProbeModelsCache(data, path = PROBE_MODELS_CACHE_PATH) {
-  mkdirSync18(dirname12(path), { recursive: true });
-  writeFileSync19(path, JSON.stringify(data), "utf-8");
+  mkdirSync19(dirname13(path), { recursive: true });
+  writeFileSync20(path, JSON.stringify(data), "utf-8");
 }
 function isCacheFresh(data, ttlMs = CACHE_TTL_MS4) {
   if (!data?.generatedAt)
@@ -60844,7 +61165,7 @@ function isValidResponse(raw) {
 var PROBE_MODELS_URL = "https://us-central1-claudish-6da10.cloudfunctions.net/probeModels", CACHE_TTL_MS4, FETCH_TIMEOUT_MS3 = 15000, PROBE_MODELS_CACHE_PATH, _inFlight = null;
 var init_probe_catalog = __esm(() => {
   CACHE_TTL_MS4 = 60 * 60 * 1000;
-  PROBE_MODELS_CACHE_PATH = join40(homedir35(), ".claudish", "probe-models.json");
+  PROBE_MODELS_CACHE_PATH = join41(homedir36(), ".claudish", "probe-models.json");
 });
 
 // src/tui/constants.ts
@@ -65312,6 +65633,13 @@ var probeProxy = null, probeProxyStarting = null;
 
 // src/tui/hooks/useRouteProbe.ts
 import { useCallback as useCallback2, useState as useState4 } from "react";
+async function routeForProbe(model) {
+  try {
+    return await route(model);
+  } catch (err) {
+    return { kind: "no-route", reason: err instanceof Error ? err.message : String(err) };
+  }
+}
 function useRouteProbe(config) {
   const [probeMode, setProbeMode] = useState4("idle");
   const [probeModel, setProbeModel] = useState4("");
@@ -65350,7 +65678,7 @@ function useRouteProbe(config) {
       if (native) {
         chain = [native];
       } else {
-        const plan = await route(model);
+        const plan = await routeForProbe(model);
         if (plan.kind !== "ok") {
           setProbeResults([
             {
@@ -67462,17 +67790,17 @@ var init_terminal_isolation = __esm(() => {
 import { spawn as spawn5, spawnSync as spawnSync4 } from "child_process";
 import {
   closeSync as closeSync8,
-  existsSync as existsSync31,
-  mkdirSync as mkdirSync19,
+  existsSync as existsSync32,
+  mkdirSync as mkdirSync20,
   openSync as openSync8,
-  readFileSync as readFileSync31,
+  readFileSync as readFileSync32,
   readdirSync as readdirSync8,
   statSync as statSync8,
   unlinkSync as unlinkSync9,
-  writeFileSync as writeFileSync20
+  writeFileSync as writeFileSync21
 } from "fs";
-import { homedir as homedir36, tmpdir as tmpdir2 } from "os";
-import { dirname as dirname13, join as join41 } from "path";
+import { homedir as homedir37, tmpdir as tmpdir2 } from "os";
+import { dirname as dirname14, join as join42 } from "path";
 import { isatty } from "tty";
 function releaseTerminalIsolation() {
   if (!restoreTerminal)
@@ -67532,12 +67860,12 @@ function isRealAnthropicEnvCredential(env, name) {
 }
 function hasResolvableAnthropicAuth(deps = {}) {
   const env = deps.env ?? process.env;
-  const fileExists = deps.fileExists ?? existsSync31;
+  const fileExists = deps.fileExists ?? existsSync32;
   const keychainProbe = deps.keychainProbe ?? defaultKeychainAnthropicProbe;
   if (isRealAnthropicEnvCredential(env, "ANTHROPIC_API_KEY") || isRealAnthropicEnvCredential(env, "ANTHROPIC_AUTH_TOKEN")) {
     return true;
   }
-  if (fileExists(join41(homedir36(), ".claude", ".credentials.json")))
+  if (fileExists(join42(homedir37(), ".claude", ".credentials.json")))
     return true;
   return keychainProbe();
 }
@@ -67552,14 +67880,14 @@ function isProxyAuthMode(config) {
 }
 function managedSettingsPath() {
   if (isWindows2()) {
-    return join41(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
+    return join42(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
   }
   if (process.platform === "darwin") {
     return "/Library/Application Support/ClaudeCode/managed-settings.json";
   }
   return "/etc/claude-code/managed-settings.json";
 }
-function managedSettingsForcesClaudeAi(readFile = readFileSync31) {
+function managedSettingsForcesClaudeAi(readFile = readFileSync32) {
   try {
     const raw = readFile(managedSettingsPath(), "utf-8");
     const parsed = JSON.parse(raw);
@@ -67573,9 +67901,9 @@ function isWindows2() {
 }
 function createStatusLineScript(tokenFilePath) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join41(homeDir, ".claudish");
+  const claudishDir = join42(homeDir, ".claudish");
   const timestamp = Date.now();
-  const scriptPath = join41(claudishDir, `status-${timestamp}.js`);
+  const scriptPath = join42(claudishDir, `status-${timestamp}.js`);
   const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
   const light = getThemeMode() === "light";
   const cyanCode = light ? "38;2;14;116;144" : "96";
@@ -67708,13 +68036,13 @@ process.stdin.on('end', () => {
   }
 });
 `;
-  writeFileSync20(scriptPath, script, "utf-8");
+  writeFileSync21(scriptPath, script, "utf-8");
   return scriptPath;
 }
 function initializeTokenFile(tokenFilePath) {
   try {
-    mkdirSync19(dirname13(tokenFilePath), { recursive: true });
-    writeFileSync20(tokenFilePath, JSON.stringify({
+    mkdirSync20(dirname14(tokenFilePath), { recursive: true });
+    writeFileSync21(tokenFilePath, JSON.stringify({
       input_tokens: 0,
       output_tokens: 0,
       total_tokens: 0,
@@ -67745,7 +68073,7 @@ function cleanupStaleTokenFiles(dir, now = Date.now(), maxAgeMs = STALE_TOKEN_FI
     if (!name.startsWith("tokens-") || !name.endsWith(".json"))
       continue;
     scanned++;
-    const full = join41(dir, name);
+    const full = join42(dir, name);
     try {
       if (statSync8(full).mtimeMs >= cutoff)
         continue;
@@ -67762,7 +68090,7 @@ function parseSettingsArg(value) {
   if (value.trimStart().startsWith("{")) {
     return JSON.parse(value);
   }
-  return JSON.parse(readFileSync31(value, "utf-8"));
+  return JSON.parse(readFileSync32(value, "utf-8"));
 }
 function parseSettingsArgSafe(value) {
   try {
@@ -67774,13 +68102,13 @@ function parseSettingsArgSafe(value) {
 }
 function userSettingsFileCandidates(cwd) {
   return [
-    join41(homedir36(), ".claude", "settings.json"),
-    join41(cwd, ".claude", "settings.json"),
-    join41(cwd, ".claude", "settings.local.json")
+    join42(homedir37(), ".claude", "settings.json"),
+    join42(cwd, ".claude", "settings.json"),
+    join42(cwd, ".claude", "settings.local.json")
   ];
 }
 function discoverUserStatusLineCommand(claudeArgs = [], cwd = process.cwd()) {
-  const sources = userSettingsFileCandidates(cwd).filter((file) => existsSync31(file));
+  const sources = userSettingsFileCandidates(cwd).filter((file) => existsSync32(file));
   const idx = claudeArgs.indexOf("--settings");
   const settingsArg = idx === -1 ? undefined : claudeArgs[idx + 1];
   if (settingsArg)
@@ -67817,13 +68145,13 @@ function buildChainedStatusCommand(userCommand, claudishBody, claudishSegment) {
 }
 function createTempSettingsFile(_modelDisplay, port, proxyAuthMode, userStatusLineCommand) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join41(homeDir, ".claudish");
+  const claudishDir = join42(homeDir, ".claudish");
   try {
-    mkdirSync19(claudishDir, { recursive: true });
+    mkdirSync20(claudishDir, { recursive: true });
   } catch {}
   const timestamp = Date.now();
-  const tempPath = join41(claudishDir, `settings-${timestamp}.json`);
-  const tokenFilePath = join41(claudishDir, `tokens-${port}.json`);
+  const tempPath = join42(claudishDir, `settings-${timestamp}.json`);
+  const tokenFilePath = join42(claudishDir, `tokens-${port}.json`);
   cleanupStaleTokenFiles(claudishDir);
   initializeTokenFile(tokenFilePath);
   let statusCommand;
@@ -67857,7 +68185,7 @@ function createTempSettingsFile(_modelDisplay, port, proxyAuthMode, userStatusLi
     padding: 0
   };
   const settings = buildClaudishSettingsOverlay(statusLine, proxyAuthMode);
-  writeFileSync20(tempPath, JSON.stringify(settings, null, 2), "utf-8");
+  writeFileSync21(tempPath, JSON.stringify(settings, null, 2), "utf-8");
   return { path: tempPath, statusLine, tokenFilePath };
 }
 function buildClaudishSettingsOverlay(statusLine, proxyAuthMode) {
@@ -67882,7 +68210,7 @@ function mergeUserSettingsIfPresent(config, tempSettingsPath, statusLine, proxyA
     if (proxyAuthMode && !("forceLoginMethod" in userSettings)) {
       userSettings.forceLoginMethod = "console";
     }
-    writeFileSync20(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
+    writeFileSync21(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
   } catch {
     if (!config.quiet) {
       console.warn(`[claudish] Warning: could not merge user settings: ${userSettingsValue}`);
@@ -67953,13 +68281,13 @@ function resolveAdvisorToolEnv(config, processEnv = process.env) {
   return { vars: { [ADVISOR_TOOL_ENV_VAR]: "1" }, source: "claudish" };
 }
 function discoverUserAdvisorModel(claudeArgs = [], cwd = process.cwd()) {
-  const sources = userSettingsFileCandidates(cwd).filter((file) => existsSync31(file));
+  const sources = userSettingsFileCandidates(cwd).filter((file) => existsSync32(file));
   const idx = claudeArgs.indexOf("--settings");
   const settingsArg = idx === -1 ? undefined : claudeArgs[idx + 1];
   if (settingsArg)
     sources.push(settingsArg);
   const managed = managedSettingsPath();
-  if (existsSync31(managed))
+  if (existsSync32(managed))
     sources.push(managed);
   let effective;
   for (const source of sources) {
@@ -68173,8 +68501,8 @@ async function runClaudeWithProxy(config, proxyUrl, onCleanup) {
     console.error("Install it from: https://claude.com/claude-code");
     console.error(`
 Or set CLAUDE_PATH to your custom installation:`);
-    const home = homedir36();
-    const localPath = isWindows2() ? join41(home, ".claude", "local", "claude.exe") : join41(home, ".claude", "local", "claude");
+    const home = homedir37();
+    const localPath = isWindows2() ? join42(home, ".claude", "local", "claude.exe") : join42(home, ".claude", "local", "claude");
     console.error(`  export CLAUDE_PATH=${localPath}`);
     process.exit(1);
   }
@@ -68262,23 +68590,23 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet, onCleanup) {
 async function findClaudeBinary() {
   const isWindows = process.platform === "win32";
   if (process.env.CLAUDE_PATH) {
-    if (existsSync31(process.env.CLAUDE_PATH)) {
+    if (existsSync32(process.env.CLAUDE_PATH)) {
       return process.env.CLAUDE_PATH;
     }
   }
-  const home = homedir36();
-  const localPath = isWindows ? join41(home, ".claude", "local", "claude.exe") : join41(home, ".claude", "local", "claude");
-  if (existsSync31(localPath)) {
+  const home = homedir37();
+  const localPath = isWindows ? join42(home, ".claude", "local", "claude.exe") : join42(home, ".claude", "local", "claude");
+  if (existsSync32(localPath)) {
     return localPath;
   }
   if (isWindows) {
     const windowsPaths = [
-      join41(home, "AppData", "Roaming", "npm", "claude.cmd"),
-      join41(home, ".npm-global", "claude.cmd"),
-      join41(home, "node_modules", ".bin", "claude.cmd")
+      join42(home, "AppData", "Roaming", "npm", "claude.cmd"),
+      join42(home, ".npm-global", "claude.cmd"),
+      join42(home, "node_modules", ".bin", "claude.cmd")
     ];
     for (const path of windowsPaths) {
-      if (existsSync31(path)) {
+      if (existsSync32(path)) {
         return path;
       }
     }
@@ -68286,14 +68614,14 @@ async function findClaudeBinary() {
     const commonPaths = [
       "/usr/local/bin/claude",
       "/opt/homebrew/bin/claude",
-      join41(home, ".npm-global/bin/claude"),
-      join41(home, ".local/bin/claude"),
-      join41(home, "node_modules/.bin/claude"),
+      join42(home, ".npm-global/bin/claude"),
+      join42(home, ".local/bin/claude"),
+      join42(home, "node_modules/.bin/claude"),
       "/data/data/com.termux/files/usr/bin/claude",
-      join41(home, "../usr/bin/claude")
+      join42(home, "../usr/bin/claude")
     ];
     for (const path of commonPaths) {
-      if (existsSync31(path)) {
+      if (existsSync32(path)) {
         return path;
       }
     }
@@ -68368,18 +68696,18 @@ var init_claude_runner = __esm(() => {
 });
 
 // src/diag-output.ts
-import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync20, unlinkSync as unlinkSync10, writeFileSync as writeFileSync21 } from "fs";
-import { homedir as homedir37 } from "os";
-import { join as join42 } from "path";
+import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync21, unlinkSync as unlinkSync10, writeFileSync as writeFileSync22 } from "fs";
+import { homedir as homedir38 } from "os";
+import { join as join43 } from "path";
 function getClaudishDir() {
-  const dir = join42(homedir37(), ".claudish");
+  const dir = join43(homedir38(), ".claudish");
   try {
-    mkdirSync20(dir, { recursive: true });
+    mkdirSync21(dir, { recursive: true });
   } catch {}
   return dir;
 }
 function getDiagLogPath() {
-  return join42(getClaudishDir(), `diag-${process.pid}.log`);
+  return join43(getClaudishDir(), `diag-${process.pid}.log`);
 }
 
 class LogFileDiagOutput {
@@ -68388,7 +68716,7 @@ class LogFileDiagOutput {
   constructor() {
     this.logPath = getDiagLogPath();
     try {
-      writeFileSync21(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
+      writeFileSync22(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
 `);
     } catch {}
     this.stream = createWriteStream3(this.logPath, { flags: "a" });
@@ -68590,13 +68918,33 @@ async function warmCatalogIfNeeded(config, opts) {
     }
     return "ok";
   }
+  return reportUnusableCatalog(outcome, state, cache, now, config.quiet === true);
+}
+function reportUnusableCatalog(outcome, state, cache, now, quiet) {
+  if (outcome.kind === "incompatible") {
+    return reportIncompatibleCatalog(readCatalogIncompatibility() ?? {
+      detectedAt: new Date().toISOString(),
+      serverContractVersion: outcome.serverContractVersion
+    });
+  }
   if (outcome.reason === "disabled") {
-    if (!config.quiet) {
+    if (!quiet) {
       process.stderr.write(`  Catalog refresh disabled (CLAUDISH_DISABLE_CATALOG_WARM=1).
 `);
     }
     return "skipped";
   }
+  const recorded = readCatalogIncompatibility();
+  if (recorded !== null)
+    return reportIncompatibleCatalog(recorded);
+  return reportFetchFailure(state, cache, now);
+}
+function reportIncompatibleCatalog(recorded) {
+  process.stderr.write(`${catalogIncompatibilityMessage(recorded)}
+`);
+  return "warned";
+}
+function reportFetchFailure(state, cache, now) {
   if (state === "stale") {
     const ageMs = now.getTime() - Date.parse(cache.lastUpdated);
     const ageStr = humanizeAge(ageMs);
@@ -68618,6 +68966,7 @@ var HARD_FAIL_MESSAGE, LOCAL_MODEL_PREFIXES;
 var init_catalog_warm = __esm(() => {
   init_all_models_cache();
   init_catalog_client();
+  init_catalog_compatibility();
   HARD_FAIL_MESSAGE = `Error: cannot reach model catalog and no cached copy found.
 ` + `
 ` + `To proceed:
@@ -70984,16 +71333,16 @@ var exports_session_stats = {};
 __export(exports_session_stats, {
   readSessionStats: () => readSessionStats
 });
-import { readFileSync as readFileSync32 } from "fs";
-import { homedir as homedir38 } from "os";
-import { join as join43 } from "path";
+import { readFileSync as readFileSync33 } from "fs";
+import { homedir as homedir39 } from "os";
+import { join as join44 } from "path";
 function tokenFilePath(port) {
-  return process.env.CLAUDISH_TOKEN_FILE || join43(homedir38(), ".claudish", `tokens-${port}.json`);
+  return process.env.CLAUDISH_TOKEN_FILE || join44(homedir39(), ".claudish", `tokens-${port}.json`);
 }
 function readSessionStats(port, opts) {
   let raw;
   try {
-    raw = JSON.parse(readFileSync32(tokenFilePath(port), "utf-8"));
+    raw = JSON.parse(readFileSync33(tokenFilePath(port), "utf-8"));
   } catch {
     return null;
   }
@@ -71350,8 +71699,8 @@ var init_session_summary = __esm(() => {
 init_op_source();
 init_startup_trace();
 var import_dotenv3 = __toESM(require_main(), 1);
-import { existsSync as existsSync32, readFileSync as readFileSync33 } from "fs";
-import { join as join44, resolve as resolve6 } from "path";
+import { existsSync as existsSync33, readFileSync as readFileSync34 } from "fs";
+import { join as join45, resolve as resolve6 } from "path";
 import_dotenv3.config({ quiet: true });
 function classifyStartupKind() {
   const argv = process.argv.slice(2);
@@ -71451,7 +71800,7 @@ async function applyConfigOverride() {
   await Promise.resolve();
   const plan = planConfigOverride(process.argv.slice(2), process.env, {
     resolve: resolve6,
-    exists: existsSync32
+    exists: existsSync33
   });
   if (plan.kind === "none")
     return;
@@ -71620,14 +71969,14 @@ async function runCli() {
     if (cliConfig.team && cliConfig.team.length > 0) {
       let prompt = cliConfig.claudeArgs.join(" ");
       if (cliConfig.inputFile) {
-        prompt = readFileSync33(cliConfig.inputFile, "utf-8");
+        prompt = readFileSync34(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 = join44(process.cwd(), `.claudish-team-${Date.now()}`);
+      const sessionPath = join45(process.cwd(), `.claudish-team-${Date.now()}`);
       if (mode === "json") {
         await Promise.resolve().then(() => init_team_orchestrator());
         setupSession(sessionPath, cliConfig.team, prompt);
@@ -71636,9 +71985,9 @@ async function runCli() {
         });
         const result = { ...status, responses: {} };
         for (const anonId of Object.keys(status.models)) {
-          const responsePath = join44(sessionPath, `response-${anonId}.md`);
+          const responsePath = join45(sessionPath, `response-${anonId}.md`);
           try {
-            const raw = readFileSync33(responsePath, "utf-8").trim();
+            const raw = readFileSync34(responsePath, "utf-8").trim();
             try {
               result.responses[anonId] = JSON.parse(raw);
             } catch {