claudish 10.2.0 → 10.3.0

package/dist/index.js

@@ -715,7 +715,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "10.2.0";
+var VERSION = "10.3.0";
 
 // src/logger.ts
 import { appendFile, existsSync as existsSync2, mkdirSync, readdirSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
@@ -5328,6 +5328,56 @@ var init_onepassword_command = __esm(() => {
 ` + "    claudish --op 'op://Jack/My Item/*/*_API_KEY' --model gpt-4o 'task'";
 });
 
+// src/default-provider.ts
+function resolveDefaultProvider(opts) {
+  const env = opts.env ?? process.env;
+  if (opts.cliFlag && opts.cliFlag.length > 0) {
+    return { provider: opts.cliFlag, source: "cli-flag", legacyAutoPromoted: false };
+  }
+  const envVal = env.CLAUDISH_DEFAULT_PROVIDER;
+  if (envVal !== undefined) {
+    return { provider: envVal, source: "env-var", legacyAutoPromoted: false };
+  }
+  const configured = opts.config.defaultProvider;
+  if (typeof configured === "string") {
+    return { provider: configured, source: "config-file", legacyAutoPromoted: false };
+  }
+  if (env.OPENROUTER_API_KEY) {
+    return { provider: "openrouter", source: "openrouter-key", legacyAutoPromoted: false };
+  }
+  return { provider: "openrouter", source: "hardcoded", legacyAutoPromoted: false };
+}
+function planDefaultProviderFlag(argv) {
+  const rest = [];
+  let value;
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--") {
+      rest.push(...argv.slice(i));
+      break;
+    }
+    if (arg === DEFAULT_PROVIDER_FLAG) {
+      const next = argv[i + 1];
+      if (next === undefined || next.startsWith("-")) {
+        return {
+          kind: "error",
+          message: `${DEFAULT_PROVIDER_FLAG} requires a provider name ("" for no fallback provider)`
+        };
+      }
+      value = next;
+      i++;
+      continue;
+    }
+    if (arg.startsWith(`${DEFAULT_PROVIDER_FLAG}=`)) {
+      value = arg.slice(DEFAULT_PROVIDER_FLAG.length + 1);
+      continue;
+    }
+    rest.push(arg);
+  }
+  return value === undefined ? { kind: "none" } : { kind: "apply", value, argv: rest };
+}
+var DEFAULT_PROVIDER_FLAG = "--default-provider";
+
 // ../../node_modules/.bun/zod@4.1.13/node_modules/zod/v4/core/core.js
 function $constructor(name, initializer, params) {
   function init(inst, def) {
@@ -18304,30 +18354,37 @@ var init_all_models_cache = __esm(() => {
 
 // src/providers/catalog-route-bindings.ts
 function catalogRouteForProvider(provider) {
-  return CATALOG_ROUTE_BINDINGS[provider];
-}
-function providerForCatalogRoute(route) {
-  return providersForCatalogRoute(route)[0];
+  return CATALOG_ROUTE_BINDINGS[provider] ?? LOOKUP_ONLY_ROUTE_BINDINGS[provider];
 }
-function providersForCatalogRoute(route) {
+function namesBoundTo(table, route) {
   if (!route)
     return [];
-  return Object.entries(CATALOG_ROUTE_BINDINGS).filter(([, binding]) => binding.routeId === route.routeId && binding.routeProfileId === route.routeProfileId).map(([provider]) => provider);
+  return Object.entries(table).filter(([, binding]) => binding.routeId === route.routeId && binding.routeProfileId === route.routeProfileId).map(([name]) => name);
+}
+function routingProvidersForRoute(route) {
+  return namesBoundTo(CATALOG_ROUTE_BINDINGS, route);
+}
+function catalogReadProvidersForRoute(route) {
+  return [
+    ...namesBoundTo(CATALOG_ROUTE_BINDINGS, route),
+    ...namesBoundTo(LOOKUP_ONLY_ROUTE_BINDINGS, route)
+  ];
+}
+function providerForCatalogRoute(route) {
+  return catalogReadProvidersForRoute(route)[0];
 }
 function catalogRouteMatchesProvider(route, provider) {
   const binding = catalogRouteForProvider(provider);
   return route !== undefined && binding !== undefined && route.routeId === binding.routeId && route.routeProfileId === binding.routeProfileId;
 }
-var CATALOG_ROUTE_BINDINGS;
+var CATALOG_ROUTE_BINDINGS, LOOKUP_ONLY_ROUTE_BINDINGS;
 var init_catalog_route_bindings = __esm(() => {
   CATALOG_ROUTE_BINDINGS = {
     "native-anthropic": { routeId: "anthropic", routeProfileId: "claude-code-subscription" },
-    anthropic: { routeId: "anthropic", routeProfileId: "direct-api" },
     "openai-codex": { routeId: "openai", routeProfileId: "codex-subscription" },
     openai: { routeId: "openai", routeProfileId: "direct-api" },
     "kimi-coding": { routeId: "moonshotai", routeProfileId: "kimi-code-subscription" },
     kimi: { routeId: "moonshotai", routeProfileId: "direct-api" },
-    moonshotai: { routeId: "moonshotai", routeProfileId: "direct-api" },
     "glm-coding": { routeId: "z-ai", routeProfileId: "glm-coding-subscription" },
     "z-ai": { routeId: "z-ai", routeProfileId: "direct-api" },
     glm: { routeId: "z-ai", routeProfileId: "direct-api" },
@@ -18345,7 +18402,6 @@ var init_catalog_route_bindings = __esm(() => {
     "qwen-payg": { routeId: "qwen", routeProfileId: "dashscope-direct" },
     "opencode-zen-go": { routeId: "opencode", routeProfileId: "go-subscription" },
     "opencode-zen": { routeId: "opencode", routeProfileId: "zen" },
-    zen: { routeId: "opencode", routeProfileId: "zen" },
     ollamacloud: { routeId: "ollama", routeProfileId: "cloud" },
     openrouter: { routeId: "openrouter", routeProfileId: "gateway" },
     together: { routeId: "together-ai", routeProfileId: "gateway" },
@@ -18355,6 +18411,11 @@ var init_catalog_route_bindings = __esm(() => {
     deepseek: { routeId: "deepseek", routeProfileId: "direct-api" },
     mistralai: { routeId: "mistralai", routeProfileId: "direct-api" }
   };
+  LOOKUP_ONLY_ROUTE_BINDINGS = {
+    anthropic: { routeId: "anthropic", routeProfileId: "direct-api" },
+    moonshotai: { routeId: "moonshotai", routeProfileId: "direct-api" },
+    zen: { routeId: "opencode", routeProfileId: "zen" }
+  };
 });
 
 // src/providers/model-ordering.ts
@@ -28360,7 +28421,7 @@ class AntigravityProviderTransport {
   rewriteModelNotFound(response, capacityFallbacksExhausted = false) {
     const served = this.servedModels;
     if (!capacityFallbacksExhausted && served.includes(this.servedModelName)) {
-      log(`[Antigravity] 404 for ${this.servedModelName}, which IS in the served set \u2014 passing through unmodified`);
+      log(`[Antigravity] 404 for ${this.servedModelName}, which IS in the dynamic models catalog \u2014 passing through unmodified`);
       return response;
     }
     response.text().catch(() => {});
@@ -32662,6 +32723,40 @@ var init_pro_injection = __esm(() => {
   init_session_events();
 });
 
+// src/providers/claude-code-aliases.ts
+function claudeCodeTierAlias(model) {
+  return TIER_ALIASES[model.trim().toLowerCase()] ?? null;
+}
+function isClaudeCodeModelName(name) {
+  const normalized = name.trim().toLowerCase();
+  if (normalized.startsWith("claude-"))
+    return true;
+  const alias = normalized.endsWith(ONE_MILLION_CONTEXT_SUFFIX) ? normalized.slice(0, -ONE_MILLION_CONTEXT_SUFFIX.length) : normalized;
+  return CLAUDE_CODE_MODEL_ALIASES.includes(alias);
+}
+function normalizeNativeModelSpec(spec) {
+  return claudeCodeTierAlias(spec) ?? spec;
+}
+var TIER_ALIASES, CLAUDE_CODE_MODEL_ALIASES, ONE_MILLION_CONTEXT_SUFFIX = "[1m]";
+var init_claude_code_aliases = __esm(() => {
+  TIER_ALIASES = {
+    opus: "opus",
+    sonnet: "sonnet",
+    haiku: "haiku",
+    internal: "opus",
+    default: "opus"
+  };
+  CLAUDE_CODE_MODEL_ALIASES = [
+    "opus",
+    "sonnet",
+    "haiku",
+    "internal",
+    "default",
+    "opusplan",
+    "best"
+  ];
+});
+
 // src/providers/model-parser.ts
 function parseModelChain(modelSpec) {
   const parts = modelSpec.split(MODEL_CHAIN_SEPARATOR).map((s) => s.trim()).filter(Boolean);
@@ -32744,13 +32839,18 @@ function parseModelSpec(modelSpec) {
     };
   }
   return {
-    provider: "native-anthropic",
+    provider: lastResortProvider(modelSpec),
     model: modelSpec,
     original,
     isLegacySyntax: false,
     isExplicitProvider: false
   };
 }
+function lastResortProvider(modelSpec) {
+  const name = modelSpec.trim();
+  const isNative = name === "" || name.startsWith("@") || isClaudeCodeModelName(name);
+  return isNative ? "native-anthropic" : AUTO_ROUTE_PROVIDER;
+}
 function isLocalProviderName(provider) {
   return LOCAL_PROVIDERS.has(provider.toLowerCase());
 }
@@ -32762,8 +32862,9 @@ function getLegacySyntaxWarning(parsed) {
   return `Deprecation warning: "${parsed.original}" uses legacy prefix syntax.
 ` + `  Consider using: ${newSyntax}`;
 }
-var PROVIDER_SHORTCUTS, LOCAL_PROVIDERS, NATIVE_MODEL_PATTERNS, LEGACY_PREFIX_PATTERNS, MODEL_CHAIN_SEPARATOR = "+";
+var AUTO_ROUTE_PROVIDER = "auto-route", PROVIDER_SHORTCUTS, LOCAL_PROVIDERS, NATIVE_MODEL_PATTERNS, LEGACY_PREFIX_PATTERNS, MODEL_CHAIN_SEPARATOR = "+";
 var init_model_parser = __esm(() => {
+  init_claude_code_aliases();
   init_provider_definitions();
   PROVIDER_SHORTCUTS = getShortcuts();
   LOCAL_PROVIDERS = {
@@ -37129,7 +37230,7 @@ class ComposedHandler {
             ...this.recoveryStats(recoveryTally)
           });
         } catch {}
-        return c.json(wrapAnthropicError(503, surfaced, "overloaded_error", undefined, settled.message), 503);
+        return c.json(wrapAnthropicError(503, surfaced, "overloaded_error", undefined, settled.message), 503, settled.unreachable ? connectionFaultHeaders() : undefined);
       }
       response = settled.response;
     }
@@ -37172,7 +37273,7 @@ class ComposedHandler {
             ...this.recoveryStats(recoveryTally)
           });
         } catch {}
-        return isTerminal ? c.json(wrapAnthropicError(400, surfaced, "invalid_request_error", undefined, settled.message), 400) : c.json(wrapAnthropicError(503, surfaced, "overloaded_error", undefined, settled.message), 503);
+        return isTerminal ? c.json(wrapAnthropicError(400, surfaced, "invalid_request_error", undefined, settled.message), 400) : c.json(wrapAnthropicError(503, surfaced, "overloaded_error", undefined, settled.message), 503, settled.kind === "exhausted" && settled.unreachable ? connectionFaultHeaders() : undefined);
       }
       response = settled.response;
     }
@@ -37242,7 +37343,8 @@ class ComposedHandler {
           kind: "exhausted",
           code: verdict.code,
           message: `${verdict.message} (retry could not reach the provider: ${error})`,
-          attempts: attempt + 1
+          attempts: attempt + 1,
+          unreachable: true
         };
       }
       if (!next.ok) {
@@ -37291,7 +37393,8 @@ class ComposedHandler {
           kind: "exhausted",
           code: verdict.code,
           message: `${verdict.message} (retry could not reach the provider: ${error})`,
-          attempts: attempt + 1
+          attempts: attempt + 1,
+          unreachable: true
         };
       }
       if (!next.ok) {
@@ -40116,16 +40219,9 @@ function requireKeyUnlessNoAuth(ep, ctx) {
     });
   }
 }
-var BuiltinDefaultProviderSchema, CustomEndpointAuthSchemeSchema, CustomEndpointSimpleSchema, CustomEndpointComplexSchema, CustomEndpointSchema, PredefinedEndpointsConfigSchema, DefaultProviderSchema;
+var CustomEndpointAuthSchemeSchema, CustomEndpointSimpleSchema, CustomEndpointComplexSchema, CustomEndpointSchema, PredefinedEndpointsConfigSchema;
 var init_config_schema = __esm(() => {
   init_zod();
-  BuiltinDefaultProviderSchema = _enum([
-    "openrouter",
-    "litellm",
-    "openai",
-    "anthropic",
-    "google"
-  ]);
   CustomEndpointAuthSchemeSchema = _enum(["bearer", "x-api-key", "none"]);
   CustomEndpointSimpleSchema = object2({
     kind: literal("simple"),
@@ -40158,7 +40254,6 @@ var init_config_schema = __esm(() => {
     disable: array(string2()).optional(),
     enable: array(string2()).optional()
   });
-  DefaultProviderSchema = union([BuiltinDefaultProviderSchema, string2().min(1)]);
 });
 
 // src/providers/endpoint-diagnostics.ts
@@ -40991,6 +41086,54 @@ var init_endpoint_registration = __esm(() => {
   warnedMessages4 = new Set;
 });
 
+// src/providers/native-route.ts
+function proxyRouteDecision(target) {
+  const parsed = parseModelSpec(target);
+  if (parsed.isExplicitProvider) {
+    return {
+      type: "explicit",
+      provider: parsed.provider,
+      model: parsed.model,
+      spec: target,
+      via: "model-spec"
+    };
+  }
+  if (target.startsWith(POE_PREFIX)) {
+    return { type: "poe", model: target.slice(POE_PREFIX.length) };
+  }
+  if (parsed.provider === "native-anthropic") {
+    if (target.includes("/")) {
+      return {
+        type: "explicit",
+        provider: "openrouter",
+        model: target,
+        spec: target,
+        via: "vendor-qualified-id"
+      };
+    }
+    return { type: "native", route: nativeRouteOf(target) };
+  }
+  return { type: "bare", model: parsed.model };
+}
+function nativeRouteOf(model) {
+  return {
+    provider: "native-anthropic",
+    modelSpec: normalizeNativeModelSpec(model),
+    displayName: getProviderByName("native-anthropic")?.displayName ?? "Anthropic (Native)",
+    isTierAlias: claudeCodeTierAlias(model) !== null
+  };
+}
+function nativeRouteFor(model) {
+  const decision = proxyRouteDecision(model);
+  return decision.type === "native" ? decision.route : null;
+}
+var NATIVE_NOT_PROBED = "not probed \u2014 served on Claude Code's own auth, which this process cannot forward", POE_PREFIX = "poe:";
+var init_native_route = __esm(() => {
+  init_claude_code_aliases();
+  init_model_parser();
+  init_provider_definitions();
+});
+
 // src/providers/provider-registry.ts
 function resolveBaseUrl2(envVar, fallbackEnvVars, staticDefault) {
   for (const v of [envVar, ...fallbackEnvVars]) {
@@ -41158,7 +41301,7 @@ var init_remote_provider_registry = __esm(() => {
 });
 
 // src/providers/routing-hints.ts
-function buildCredentialHint(modelName, providers) {
+function buildCredentialHint(modelName, providers, options = {}) {
   const seen = new Set;
   const lines = [`No credentials found for "${modelName}". Options:`];
   let hasOption = false;
@@ -41182,7 +41325,7 @@ function buildCredentialHint(modelName, providers) {
       hasOption = true;
     }
   }
-  if (!seen.has("openrouter")) {
+  if (!seen.has("openrouter") && options.suggestOpenRouter !== false) {
     lines.push(`  Use:  claudish --model or@${modelName}  (route via OpenRouter)`);
     hasOption = true;
   }
@@ -41415,17 +41558,17 @@ async function fetchProbeModels(url = PROBE_MODELS_URL, timeoutMs = FETCH_TIMEOU
   for (const route of Object.values(envelope.data.routes)) {
     if (!route || typeof route !== "object" || typeof route.externalModelId !== "string")
       continue;
-    const provider = providerForCatalogRoute(route.route);
-    if (provider)
+    for (const provider of catalogReadProvidersForRoute(route.route)) {
       providers[provider] = route.externalModelId;
+    }
   }
   const unavailable = {};
   for (const route of Object.values(envelope.data.unavailableRoutes)) {
     if (!route || typeof route !== "object" || typeof route.reason !== "string")
       continue;
-    const provider = providerForCatalogRoute(route.route);
-    if (provider)
+    for (const provider of catalogReadProvidersForRoute(route.route)) {
       unavailable[provider] = route.reason;
+    }
   }
   if (Object.keys(providers).length + Object.keys(unavailable).length === 0) {
     return { kind: "invalid", reason: "no supported probe routes" };
@@ -41518,6 +41661,9 @@ var init_probe_catalog = __esm(() => {
 });
 
 // src/providers/route-candidates.ts
+function bandRank(tier) {
+  return tier === "dynamic-subscription" ? TIER_RANK.subscription : TIER_RANK[tier];
+}
 function routeLabel(route) {
   return route ? `${route.routeId}/${route.routeProfileId}` : "(no route)";
 }
@@ -41538,7 +41684,7 @@ function gatherFromConnections(entry, candidates, unmappedRoutes) {
   for (const connection of entry.aggregators ?? []) {
     if (connection.routeStatus !== "mapped")
       continue;
-    const bound = providersForCatalogRoute(connection.route);
+    const bound = routingProvidersForRoute(connection.route);
     const routable = bound.filter((name) => getProviderByName(name)?.tier !== undefined);
     if (routable.length === 0) {
       unmappedRoutes.add(routeLabel(connection.route));
@@ -41566,6 +41712,15 @@ function gatherFromConnections(entry, candidates, unmappedRoutes) {
 function isVendorOwnRoute(route, entry) {
   return route !== undefined && entry?.provider !== undefined && route.routeId === entry.provider;
 }
+function nativeProviderForVendor(vendorSlug) {
+  for (const [provider, binding] of Object.entries(CATALOG_ROUTE_BINDINGS)) {
+    if (binding.routeId !== vendorSlug)
+      continue;
+    if (getProviderByName(provider)?.tier === "native")
+      return provider;
+  }
+  return;
+}
 function gatherFromNamespaceClaims(model, entry, candidates) {
   for (const def of getAllProviders()) {
     if (def.tier !== "dynamic-subscription")
@@ -41583,11 +41738,14 @@ function gatherFromNamespaceClaims(model, entry, candidates) {
   }
 }
 function compareRouteCandidates(a, b) {
+  const byBand = bandRank(a.tier) - bandRank(b.tier);
+  if (byBand !== 0)
+    return byBand;
+  if (a.isVendorOwn !== b.isVendorOwn)
+    return a.isVendorOwn ? -1 : 1;
   const byTier = TIER_RANK[a.tier] - TIER_RANK[b.tier];
   if (byTier !== 0)
     return byTier;
-  if (a.isVendorOwn !== b.isVendorOwn)
-    return a.isVendorOwn ? -1 : 1;
   const byPrice = compareByConnectionPrice(a.price, b.price);
   if (byPrice !== 0)
     return byPrice;
@@ -41666,44 +41824,79 @@ var init_route_candidates = __esm(() => {
 
 // src/providers/routing-rules.ts
 function loadRoutingRules(sources) {
-  const local = sources ? sources.localRules : loadLocalConfig()?.routing ?? {};
-  const global_ = sources ? sources.globalRules : loadConfig().routing ?? {};
-  validateRoutingRules(local);
-  validateRoutingRules(global_);
+  const { localRules: local, globalRules: global_ } = sources ?? loadRoutingRuleSources();
   return { ...global_, ...local };
 }
-function validateRoutingRules(rules) {
+function loadRoutingRuleSources() {
+  const localRules = loadLocalConfig()?.routing ?? {};
+  const globalRules = loadConfig().routing ?? {};
+  return { globalRules, localRules };
+}
+function routingRuleProblems(sources) {
+  return [
+    ...ruleTableProblems(sources.globalRules, "global"),
+    ...ruleTableProblems(sources.localRules, "project")
+  ];
+}
+function ruleTableProblems(rules, scope) {
+  const problems = [];
   const seenLower = new Map;
   for (const key of Object.keys(rules)) {
     if (key !== "*" && (key.match(/\*/g) || []).length > 1) {
-      console.error(`[claudish] Warning: routing pattern "${key}" has multiple wildcards \u2014 only single * is supported. This pattern may not match as expected.`);
+      problems.push({ scope, pattern: key, problem: "multiple-wildcards" });
     }
     const lower = key.toLowerCase();
     const prior = seenLower.get(lower);
     if (prior !== undefined && prior !== key) {
-      console.error(`[claudish] Warning: routing patterns "${prior}" and "${key}" collide case-insensitively. Matching is case-insensitive, so one will silently shadow the other. Pick one casing and remove the duplicate.`);
+      problems.push({ scope, pattern: key, problem: "case-collision", collidesWith: prior });
     } else {
       seenLower.set(lower, key);
     }
+    for (const entry of rules[key] ?? []) {
+      if (!isKnownProvider(ruleEntryProvider(entry))) {
+        problems.push({ scope, pattern: key, problem: "unknown-provider", entry });
+      }
+    }
+  }
+  return problems;
+}
+function ruleEntryProvider(entry) {
+  const atIdx = entry.indexOf("@");
+  const providerRaw = atIdx === -1 ? entry : entry.slice(0, atIdx);
+  return PROVIDER_SHORTCUTS[providerRaw.toLowerCase()] ?? providerRaw.toLowerCase();
+}
+function isKnownProvider(provider) {
+  return getProviderByName(provider) !== undefined || PREDEFINED_ENDPOINTS.some((row) => row.name.toLowerCase() === provider);
+}
+function describeRoutingRuleProblem(problem) {
+  switch (problem.problem) {
+    case "multiple-wildcards":
+      return `routing pattern "${problem.pattern}" (${problem.scope}) has more than one * \u2014 ` + "only a single * is supported, so it may not match as expected.";
+    case "case-collision":
+      return `routing patterns "${problem.collidesWith}" and "${problem.pattern}" (${problem.scope}) ` + "differ only in case. Matching ignores case, so one silently shadows the other: " + "pick one casing and remove the duplicate.";
+    case "unknown-provider": {
+      const entry = problem.entry ?? "";
+      return `routing rule "${problem.pattern}" (${problem.scope}) names "${entry}", but no ` + `provider "${ruleEntryProvider(entry)}" exists, so that entry never routes.`;
+    }
   }
 }
-function matchRoutingRule(modelName, rules) {
+function matchRoutingRuleKey(modelName, rules) {
   const lowered = modelName.toLowerCase();
-  for (const [key, entries] of Object.entries(rules)) {
+  for (const key of Object.keys(rules)) {
     if (!key.includes("*") && key.toLowerCase() === lowered)
-      return entries;
+      return key;
   }
   const globKeys = Object.keys(rules).filter((k) => k !== "*" && k.includes("*")).sort((a, b) => b.length - a.length);
   for (const pattern of globKeys) {
     if (globMatch(pattern, modelName))
-      return rules[pattern];
+      return pattern;
   }
   if (rules["*"] !== undefined)
-    return rules["*"];
+    return "*";
   return null;
 }
-function buildRoutingChain(entries, originalModelName, cachePath) {
-  const routes = [];
+function resolveRoutingEntries(entries, originalModelName, cachePath) {
+  const resolved = [];
   for (const entry of entries) {
     const atIdx = entry.indexOf("@");
     let providerRaw;
@@ -41719,8 +41912,10 @@ function buildRoutingChain(entries, originalModelName, cachePath) {
     let wireIdResolved = false;
     if (atIdx === -1) {
       const routing = resolveSubscriptionRouting(modelName, provider, cachePath);
-      if (routing.kind === "not-served")
+      if (routing.kind === "not-served") {
+        resolved.push({ route: routeFor(provider, modelName), excludedByMembership: true });
         continue;
+      }
       if (routing.kind === "serves") {
         modelName = routing.externalId;
         wireIdResolved = true;
@@ -41729,9 +41924,9 @@ function buildRoutingChain(entries, originalModelName, cachePath) {
     if (!wireIdResolved) {
       modelName = resolveExternalId(modelName, provider, cachePath) ?? modelName;
     }
-    routes.push(routeFor(provider, modelName));
+    resolved.push({ route: routeFor(provider, modelName), excludedByMembership: false });
   }
-  return routes;
+  return resolved;
 }
 function routeFor(provider, wireId) {
   const modelSpec = provider === "openrouter" ? wireId : `${PROVIDER_TO_PREFIX[provider] ?? provider}@${wireId}`;
@@ -41750,29 +41945,67 @@ function globMatch(pattern, value) {
 async function hasCredentialsForProvider(provider) {
   return credentials.isAvailable(provider);
 }
-async function routeExplicit(modelSpec, model, provider, cachePath) {
-  if (!await hasCredentialsForProvider(provider)) {
-    return {
+function explainCandidate(route, position, outcome, gathered) {
+  const tier = gathered ? gathered.tier : getProviderByName(route.provider)?.tier;
+  return {
+    provider: route.provider,
+    displayName: route.displayName,
+    modelSpec: route.modelSpec,
+    wireId: wireIdOf(route),
+    position,
+    ...tier !== undefined ? { tier } : {},
+    ...gathered ? { isVendorOwn: gathered.isVendorOwn, price: gathered.price } : {},
+    ...gathered?.contextWindow !== undefined ? { contextWindow: gathered.contextWindow } : {},
+    outcome
+  };
+}
+function entryOutcome(resolved) {
+  return resolved.excludedByMembership ? "excluded-by-membership" : "kept";
+}
+async function explainExplicitSpec(requestedModel, modelSpec, model, provider, cachePath) {
+  const credentialed = await hasCredentialsForProvider(provider);
+  const [resolved] = resolveRoutingEntries([modelSpec], model, cachePath);
+  const candidate = explainCandidate(resolved.route, "candidate", entryOutcome(resolved));
+  const explanation = {
+    requestedModel,
+    routedModel: model,
+    source: "explicit",
+    via: "model-spec",
+    candidates: [candidate],
+    outcome: { kind: "ok" },
+    warnings: []
+  };
+  if (!credentialed) {
+    candidate.outcome = "no-credential";
+    explanation.outcome = {
       kind: "no-route",
+      cause: "explicit-no-credential",
       reason: `No credentials configured for "${provider}".`,
       hint: buildCredentialHint(model, [provider]) ?? undefined
     };
+    return explanation;
   }
-  const built = buildRoutingChain([modelSpec], model, cachePath)[0];
-  if (!built) {
-    return {
+  if (resolved.excludedByMembership) {
+    explanation.outcome = {
       kind: "no-route",
+      cause: "explicit-unbuildable",
       reason: `Could not build a route for "${modelSpec}".`
     };
+    return explanation;
   }
-  if (await providerServesModel(built.provider, wireIdOf(built)) === "not-served") {
-    return {
+  const availability = await providerServesModel(candidate.provider, candidate.wireId);
+  if (availability === "not-served") {
+    candidate.outcome = "not-served";
+    explanation.outcome = {
       kind: "no-route",
-      reason: `${built.displayName} does not serve "${model}".`,
+      cause: "explicit-not-served",
+      reason: `${candidate.displayName} does not serve "${model}".`,
       hint: `Check the model id, or use a bare \`${model}\` to let claudish pick a provider ` + "that carries it."
     };
+    return explanation;
   }
-  return { kind: "ok", primary: built, fallbacks: [] };
+  candidate.availability = availability;
+  return explanation;
 }
 function fallbackProviderFor(defaultProvider) {
   if (defaultProvider !== undefined && defaultProvider.length === 0)
@@ -41780,39 +42013,100 @@ function fallbackProviderFor(defaultProvider) {
   const named = defaultProvider ?? DEFAULT_FALLBACK_PROVIDER;
   return PROVIDER_SHORTCUTS[named.toLowerCase()] ?? named.toLowerCase();
 }
-function buildCatalogChain(model, defaultProvider, cachePath) {
+function effectiveDefaultProvider() {
+  return resolveDefaultProvider({ config: loadConfig(), env: process.env }).provider;
+}
+function explainCatalogChain(model, defaultProvider, cachePath) {
   ensureEndpointsRegistered();
   const gathering = gatherRouteCandidates(model, cachePath);
-  const routes = gathering.candidates.map((candidate) => routeFor(candidate.provider, candidate.wireId));
+  const candidates = gathering.candidates.map((candidate) => explainCandidate(routeFor(candidate.provider, candidate.wireId), "candidate", "kept", candidate));
+  const catalog = !gathering.catalogReadable ? "unreadable" : gathering.catalogMiss ? "absent" : "found";
   const fallback = fallbackProviderFor(defaultProvider);
-  if (fallback && gathering.catalogReadable && !routes.some((route) => route.provider === fallback) && !catalogDeniesProvider(fallback, model, cachePath)) {
-    routes.push(...buildRoutingChain([fallback], model, cachePath));
+  let fallbackWithheld;
+  if (!fallback) {
+    fallbackWithheld = "disabled";
+  } else if (!gathering.catalogReadable) {
+    fallbackWithheld = "catalog-unreadable";
+  } else if (candidates.some((candidate) => candidate.provider === fallback)) {
+    fallbackWithheld = "already-gathered";
+  } else if (catalogDeniesProvider(fallback, model, cachePath)) {
+    fallbackWithheld = "catalog-denies";
+  } else {
+    for (const resolved of resolveRoutingEntries([fallback], model, cachePath)) {
+      candidates.push(explainCandidate(resolved.route, "fallback", entryOutcome(resolved)));
+    }
+  }
+  return { candidates, catalog, ...fallbackWithheld ? { fallbackWithheld } : {} };
+}
+function emptyChainOutcome(model, nativeProvider, cause, cachePath) {
+  return {
+    kind: "no-route",
+    cause,
+    reason: cause === "rule-empty" ? `A routing rule matched "${model}" and named no provider.` : `No provider in the catalog serves "${model}".`,
+    hint: emptyChainHint(model, nativeProvider, cause, cachePath)
+  };
+}
+function emptyChainHint(model, nativeProvider, cause, cachePath) {
+  if (nativeProvider !== AUTO_ROUTE_PROVIDER) {
+    return buildCredentialHint(model, [nativeProvider]) ?? undefined;
   }
-  return { routes, catalogReadable: gathering.catalogReadable };
+  const suggestOpenRouter = cause === "rule-empty" || !catalogDeniesProvider("openrouter", model, cachePath);
+  return buildCredentialHint(model, [], { suggestOpenRouter }) ?? undefined;
 }
-async function routeBare(model, nativeProvider, rules, defaultProvider, cachePath) {
-  const matched = matchRoutingRule(model, rules);
-  let candidates;
-  if (matched !== null) {
-    candidates = buildRoutingChain(matched, model, cachePath);
+function ruleProblemWarnings(problems) {
+  return (problems ?? []).map((problem) => ({
+    type: "rule-problem",
+    problem,
+    message: describeRoutingRuleProblem(problem)
+  }));
+}
+async function explainBareName(requestedModel, model, nativeProvider, routing, cachePath) {
+  const matchedKey = matchRoutingRuleKey(model, routing.rules);
+  const matched = matchedKey === null ? null : routing.rules[matchedKey];
+  let explanation;
+  if (matchedKey !== null && matched !== null) {
+    explanation = {
+      requestedModel,
+      routedModel: model,
+      source: "user-rule",
+      matchedPattern: matchedKey,
+      ...routing.scopeOf ? { ruleScope: routing.scopeOf(matchedKey) } : {},
+      candidates: resolveRoutingEntries(matched, model, cachePath).map((resolved) => explainCandidate(resolved.route, "candidate", entryOutcome(resolved))),
+      outcome: { kind: "ok" },
+      warnings: ruleProblemWarnings(routing.ruleProblems)
+    };
   } else {
-    const gathered = buildCatalogChain(model, defaultProvider, cachePath);
-    if (!gathered.catalogReadable && gathered.routes.length === 0) {
-      return {
-        kind: "no-route",
-        reason: `No model catalog available, so "${model}" cannot be routed by name.`,
-        hint: "Run `claudish --models-refresh` to fetch the catalog, or name the provider " + `explicitly (e.g. \`openrouter@${model}\`).`
-      };
-    }
-    candidates = gathered.routes;
+    const chain = explainCatalogChain(model, routing.defaultProvider, cachePath);
+    explanation = {
+      requestedModel,
+      routedModel: model,
+      source: "catalog",
+      catalog: chain.catalog,
+      candidates: chain.candidates,
+      ...chain.fallbackWithheld ? { fallbackWithheld: chain.fallbackWithheld } : {},
+      outcome: { kind: "ok" },
+      warnings: ruleProblemWarnings(routing.ruleProblems)
+    };
   }
-  if (candidates.length === 0) {
-    return {
+  const remaining = explanation.candidates.filter((candidate) => candidate.outcome !== "excluded-by-membership");
+  if (explanation.catalog === "unreadable" && remaining.length === 0) {
+    explanation.outcome = {
       kind: "no-route",
-      reason: matched !== null ? `A routing rule matched "${model}" and named no provider.` : `No provider in the catalog serves "${model}".`,
-      hint: buildCredentialHint(model, [nativeProvider]) ?? undefined
+      cause: "catalog-unreadable",
+      reason: `No model catalog available, so "${model}" cannot be routed by name.`,
+      hint: "Run `claudish --models-refresh` to fetch the catalog, or name the provider " + `explicitly (e.g. \`openrouter@${model}\`).`
     };
+    return explanation;
+  }
+  if (remaining.length === 0) {
+    explanation.outcome = emptyChainOutcome(model, nativeProvider, explanation.source === "user-rule" ? "rule-empty" : "catalog-empty", cachePath);
+    return explanation;
   }
+  await applyCandidateFilters(explanation, remaining);
+  return explanation;
+}
+async function applyCandidateFilters(explanation, candidates) {
+  const model = explanation.routedModel;
   const credentialed = [];
   const skipped = [];
   const skippedFailed = [];
@@ -41830,45 +42124,63 @@ async function routeBare(model, nativeProvider, rules, defaultProvider, cachePat
       return;
     }
     skipped.push(candidate.provider);
-    if (verdict.readiness === "failed")
+    if (verdict.readiness === "failed") {
       skippedFailed.push(candidate.provider);
+      candidate.outcome = "credential-unreadable";
+    } else {
+      candidate.outcome = "no-credential";
+    }
   });
   if (credentialed.length === 0) {
-    return {
+    explanation.outcome = {
       kind: "no-route",
+      cause: "no-credential",
       reason: skipped.length > 0 ? `No credentialed providers in chain for "${model}" (tried: ${skipped.join(", ")}).` : `No providers available for "${model}".`,
       hint: buildCredentialHint(model, skipped) ?? undefined
     };
+    return;
   }
-  const availability = await Promise.all(credentialed.map((candidate) => providerServesModel(candidate.provider, wireIdOf(candidate))));
+  const availability = await Promise.all(credentialed.map((candidate) => providerServesModel(candidate.provider, candidate.wireId)));
   const serving = [];
   const notServing = [];
   credentialed.forEach((candidate, i) => {
-    if (availability[i] === "not-served") {
+    const verdict = availability[i];
+    if (verdict === "not-served") {
       notServing.push(candidate.provider);
+      candidate.outcome = "not-served";
     } else {
       serving.push(candidate);
+      candidate.availability = verdict;
     }
   });
   if (serving.length === 0) {
-    return {
+    explanation.outcome = {
       kind: "no-route",
+      cause: "not-served",
       reason: `No provider serves "${model}" (checked: ${notServing.join(", ")}).`,
       hint: buildCredentialHint(model, notServing) ?? undefined
     };
+    return;
   }
   if (notServing.length > 0) {
-    log(`[routing] ${model}: skipped ${notServing.join(", ")} \u2014 does not serve this model`);
     const droppedSubscription = notServing.filter((p) => isSubscriptionProvider(p));
     if (droppedSubscription.length > 0 && !isSubscriptionProvider(serving[0].provider)) {
-      logStderr(`${droppedSubscription.join(", ")} does not serve ${model} \u2014 ` + `using ${serving[0].displayName}, which bills per token.`);
+      explanation.warnings.push({
+        type: "subscription-not-served",
+        providers: droppedSubscription,
+        usedInstead: serving[0].provider,
+        message: `${droppedSubscription.join(", ")} does not serve ${model} \u2014 ` + `using ${serving[0].displayName}, which bills per token.`
+      });
     }
   }
   if (skippedFailed.length > 0 && !isSubscriptionProvider(serving[0].provider)) {
-    logStderr(`${skippedFailed.join(", ")}: the credential could not be READ (not "no key") \u2014 ` + `using ${serving[0].displayName}, which bills per token.`);
+    explanation.warnings.push({
+      type: "subscription-credential-unreadable",
+      providers: skippedFailed,
+      usedInstead: serving[0].provider,
+      message: `${skippedFailed.join(", ")}: the credential could not be READ (not "no key") \u2014 ` + `using ${serving[0].displayName}, which bills per token.`
+    });
   }
-  const [primary, ...fallbacks] = serving;
-  return { kind: "ok", primary, fallbacks };
 }
 function wireIdOf(route) {
   const at = route.modelSpec.indexOf("@");
@@ -41878,15 +42190,174 @@ function normalizeGlmSlug(model) {
   return model.replace(/^glm-(\d+)-(\d+)(-.*)?$/i, (_m, major, minor, suffix) => `glm-${major}.${minor}${suffix ?? ""}`);
 }
 async function route(modelSpec, rulesOverride, defaultProviderOverride, cachePath) {
+  const explanation = await explainRoutePlan(modelSpec, () => {
+    const rules = rulesOverride ?? loadRoutingRules();
+    const defaultProvider = defaultProviderOverride !== undefined ? defaultProviderOverride : rulesOverride !== undefined ? undefined : effectiveDefaultProvider();
+    return { rules, defaultProvider };
+  }, cachePath);
+  emitRouteNotices(explanation);
+  return toRoutePlan(explanation);
+}
+async function explainRoutePlan(modelSpec, bareRouting, cachePath, requestedModel = modelSpec) {
   const parsed = parseModelSpec(modelSpec);
   if (parsed.isExplicitProvider) {
-    return routeExplicit(modelSpec, parsed.model, parsed.provider, cachePath);
+    return explainExplicitSpec(requestedModel, modelSpec, parsed.model, parsed.provider, cachePath);
+  }
+  return explainBareName(requestedModel, normalizeGlmSlug(parsed.model), parsed.provider, bareRouting(), cachePath);
+}
+async function explainRoute(target, opts = {}) {
+  const decision = proxyRouteDecision(target);
+  if (decision.type === "native") {
+    return {
+      requestedModel: target,
+      routedModel: target,
+      source: "native",
+      candidates: [],
+      outcome: { kind: "ok" },
+      warnings: [],
+      native: decision.route
+    };
+  }
+  if (decision.type === "poe") {
+    return explainUnroutedExplicit(target, "poe", "poe", decision.model);
   }
-  const rules = rulesOverride ?? loadRoutingRules();
-  const defaultProvider = defaultProviderOverride !== undefined ? defaultProviderOverride : rulesOverride !== undefined ? undefined : loadConfig().defaultProvider;
-  return routeBare(normalizeGlmSlug(parsed.model), parsed.provider, rules, defaultProvider, cachePath);
+  if (decision.type === "explicit" && decision.via === "vendor-qualified-id") {
+    return explainUnroutedExplicit(target, "vendor-qualified-id", decision.provider, decision.model);
+  }
+  const routeTarget = decision.type === "explicit" ? decision.spec : decision.model;
+  return explainRoutePlan(routeTarget, () => bareRoutingFor(opts), opts.cachePath, target);
 }
-var DEFAULT_FALLBACK_PROVIDER = "openrouter";
+async function explainUnroutedExplicit(requestedModel, via, provider, wireId) {
+  const credentialed = await hasCredentialsForProvider(provider);
+  const tier = getProviderByName(provider)?.tier;
+  return {
+    requestedModel,
+    routedModel: wireId,
+    source: "explicit",
+    via,
+    candidates: [
+      {
+        provider,
+        displayName: DISPLAY_NAMES[provider] ?? provider,
+        modelSpec: requestedModel,
+        wireId,
+        position: "candidate",
+        ...tier !== undefined ? { tier } : {},
+        outcome: credentialed ? "kept" : "no-credential"
+      }
+    ],
+    outcome: credentialed ? { kind: "ok" } : {
+      kind: "no-route",
+      cause: "explicit-no-credential",
+      reason: `No credentials configured for "${provider}".`,
+      hint: buildCredentialHint(wireId, [provider]) ?? undefined
+    },
+    warnings: []
+  };
+}
+function bareRoutingFor(opts) {
+  if (opts.rules !== undefined) {
+    return { rules: opts.rules, defaultProvider: opts.defaultProvider };
+  }
+  const sources = loadRoutingRuleSources();
+  return {
+    rules: loadRoutingRules(sources),
+    defaultProvider: opts.defaultProvider !== undefined ? opts.defaultProvider : effectiveDefaultProvider(),
+    scopeOf: (ruleKey) => Object.hasOwn(sources.localRules, ruleKey) ? "project" : "global",
+    ruleProblems: ruleProblemsAfterRegistration(sources)
+  };
+}
+function ruleProblemsAfterRegistration(sources) {
+  ensureEndpointsRegistered();
+  return routingRuleProblems(sources);
+}
+function toRoutePlan(explanation) {
+  const { outcome } = explanation;
+  if (outcome.kind === "no-route") {
+    return "hint" in outcome ? { kind: "no-route", reason: outcome.reason, hint: outcome.hint } : { kind: "no-route", reason: outcome.reason };
+  }
+  const [primary, ...fallbacks] = explanation.candidates.filter((candidate) => candidate.outcome === "kept").map(routeOf);
+  if (!primary) {
+    throw new Error(`toRoutePlan: "${explanation.requestedModel}" (${explanation.source}) has no kept candidate, so it has no RoutePlan.`);
+  }
+  return { kind: "ok", primary, fallbacks };
+}
+function routeOf(candidate) {
+  return {
+    provider: candidate.provider,
+    modelSpec: candidate.modelSpec,
+    displayName: candidate.displayName
+  };
+}
+function emitRouteNotices(explanation) {
+  if (explanation.outcome.kind !== "ok")
+    return;
+  const notServing = explanation.candidates.filter((candidate) => candidate.outcome === "not-served").map((candidate) => candidate.provider);
+  if (notServing.length > 0) {
+    log(`[routing] ${explanation.routedModel}: skipped ${notServing.join(", ")} \u2014 does not serve this model`);
+  }
+  for (const warning of explanation.warnings) {
+    if (warning.type === "rule-problem")
+      continue;
+    logStderr(warning.message);
+  }
+}
+function hopLabel(candidate) {
+  if (candidate.position === "fallback")
+    return TIER_LABEL.fallback;
+  return candidate.tier ? TIER_LABEL[candidate.tier] : "unregistered provider";
+}
+function describeRouteExplanation(explanation) {
+  const line = describeOrigin(explanation);
+  const routed = explanation.source === "user-rule" || explanation.source === "catalog";
+  return routed && explanation.requestedModel !== explanation.routedModel ? `${line} \xB7 asked as ${explanation.routedModel}` : line;
+}
+function describeOrigin(explanation) {
+  switch (explanation.source) {
+    case "native":
+      return "native \xB7 Claude Code's own auth \xB7 not probed";
+    case "explicit": {
+      const name = explanation.candidates[0]?.displayName ?? explanation.routedModel;
+      return explanation.via === "vendor-qualified-id" ? `explicit \xB7 ${name} \xB7 vendor-qualified id sent verbatim` : `explicit \xB7 ${name}`;
+    }
+    case "user-rule": {
+      const scope = explanation.ruleScope ? ` (${explanation.ruleScope})` : "";
+      return `user rule "${explanation.matchedPattern}"${scope}`;
+    }
+    case "catalog":
+      return describeCatalogOrigin(explanation);
+  }
+}
+function describeCatalogOrigin(explanation) {
+  if (explanation.catalog === "unreadable") {
+    const refresh = "run claudish --models-refresh";
+    return explanation.candidates.length > 0 ? `no cloud models catalog \xB7 ${firstHopPhrase(explanation)} \xB7 ${refresh}` : `no cloud models catalog \xB7 ${refresh}`;
+  }
+  if (explanation.catalog === "absent")
+    return describeAbsentEntry(explanation);
+  return `catalog \xB7 ${firstHopPhrase(explanation)}`;
+}
+function describeAbsentEntry(explanation) {
+  const head = `catalog has no entry for "${explanation.routedModel}"`;
+  const withheld = explanation.fallbackWithheld;
+  if (explanation.candidates.some((candidate) => candidate.position === "candidate")) {
+    const noFallback = withheld && withheld !== "already-gathered" ? ` \xB7 no fallback (${withheld})` : "";
+    return `${head} \xB7 ${firstHopPhrase(explanation)}${noFallback}`;
+  }
+  if (withheld)
+    return `${head} \xB7 no fallback (${withheld})`;
+  const fallback = explanation.candidates.find((candidate) => candidate.position === "fallback");
+  if (!fallback)
+    return `${head} \xB7 ${firstHopPhrase(explanation)}`;
+  return fallback.outcome === "kept" ? `${head} \xB7 fallback only` : `${head} \xB7 fallback ${fallback.displayName} ${DROPPED_FALLBACK_PHRASE[fallback.outcome]}`;
+}
+function firstHopPhrase(explanation) {
+  if (explanation.outcome.kind === "no-route")
+    return `no route (${explanation.outcome.cause})`;
+  const first = explanation.candidates.find((candidate) => candidate.outcome === "kept");
+  return first ? `${hopLabel(first)} first` : "no route";
+}
+var DEFAULT_FALLBACK_PROVIDER = "openrouter", TIER_LABEL, DROPPED_FALLBACK_PHRASE;
 var init_routing_rules = __esm(() => {
   init_model_catalog();
   init_authority();
@@ -41899,9 +42370,24 @@ var init_routing_rules = __esm(() => {
   init_model_availability();
   init_model_parser();
   init_model_parser();
+  init_native_route();
+  init_predefined_catalog();
   init_provider_definitions();
   init_route_candidates();
   init_routing_hints();
+  TIER_LABEL = {
+    subscription: "subscription",
+    "dynamic-subscription": "subscription \xB7 account decides models",
+    native: "native API",
+    gateway: "gateway",
+    fallback: "fallback"
+  };
+  DROPPED_FALLBACK_PHRASE = {
+    "no-credential": "has no credential",
+    "credential-unreadable": "has a credential that could not be read",
+    "not-served": "does not serve it",
+    "excluded-by-membership": "is outside its plan's membership"
+  };
 });
 
 // src/providers/provider-resolver.ts
@@ -41947,6 +42433,19 @@ function resolveModelProvider(modelId) {
     deprecationWarning: deprecationWarning || undefined,
     concurrency: parsed.concurrency
   });
+  if (parsed.provider === AUTO_ROUTE_PROVIDER) {
+    return addCommonFields({
+      category: "auto-route",
+      catalogName: null,
+      providerName: "unresolved (routed on the first request)",
+      modelName: parsed.model,
+      fullModelId: modelId,
+      requiredApiKeyEnvVar: null,
+      apiKeyAvailable: true,
+      apiKeyDescription: null,
+      apiKeyUrl: null
+    });
+  }
   if (isLocalProviderName(parsed.provider)) {
     const resolved = resolveProvider(modelId);
     const urlParsed = parseUrlModel(modelId);
@@ -42124,7 +42623,7 @@ function getMissingKeyError(resolution) {
   }
   {
     const parsed = resolution.parsed;
-    if (parsed && !parsed.isExplicitProvider && parsed.provider !== "unknown" && parsed.provider !== "native-anthropic") {
+    if (parsed && !parsed.isExplicitProvider && parsed.provider !== "unknown" && parsed.provider !== "native-anthropic" && parsed.provider !== AUTO_ROUTE_PROVIDER) {
       const hint = buildCredentialHint(parsed.model, [parsed.provider]);
       if (hint) {
         lines.push("");
@@ -42233,10 +42732,7 @@ async function pinRoutes(models, into, router) {
   } catch {}
 }
 function isRoutablyPinnable(model) {
-  if (model.startsWith("poe:"))
-    return false;
-  const parsed = parseModelSpec(model);
-  return !parsed.isExplicitProvider && parsed.provider !== "native-anthropic";
+  return proxyRouteDecision(model).type === "bare";
 }
 async function prepareParentRoutingContext() {
   if (!parentRoutingContextReady) {
@@ -42294,6 +42790,7 @@ var init_prehydrate = __esm(() => {
   init_catalog_client();
   init_endpoint_registration();
   init_model_parser();
+  init_native_route();
   init_onepassword();
   init_provider_resolver();
   init_routing_rules();
@@ -45743,7 +46240,7 @@ function getAvailableModels() {
   _cachedModelIds = result;
   return result;
 }
-var _cachedModelInfo = null, _cachedModelIds = null, _cachedRecommendedModels = null, FIREBASE_BASE_URL = "https://us-central1-claudish-6da10.cloudfunctions.net/queryModels", FIREBASE_RECOMMENDED_URL, RECOMMENDED_MODELS_CACHE_PATH, RECOMMENDED_FETCH_TIMEOUT_MS = 5000, SEARCH_FETCH_TIMEOUT_MS = 1e4, FIREBASE_SLUG_TO_PROVIDER_NAME, RECOMMENDED_ROUTE_TIER_ORDER;
+var _cachedModelInfo = null, _cachedModelIds = null, _cachedRecommendedModels = null, FIREBASE_BASE_URL = "https://us-central1-claudish-6da10.cloudfunctions.net/queryModels", FIREBASE_RECOMMENDED_URL, RECOMMENDED_MODELS_CACHE_PATH, RECOMMENDED_FETCH_TIMEOUT_MS = 5000, SEARCH_FETCH_TIMEOUT_MS = 1e4, RECOMMENDED_ROUTE_TIER_ORDER;
 var init_model_loader = __esm(() => {
   init_all_models_cache();
   init_auto_route();
@@ -45752,18 +46249,6 @@ var init_model_loader = __esm(() => {
   init_catalog_route_bindings();
   FIREBASE_RECOMMENDED_URL = `${FIREBASE_BASE_URL}?catalog=recommended`;
   RECOMMENDED_MODELS_CACHE_PATH = join32(homedir30(), ".claudish", "recommended-models-cache.json");
-  FIREBASE_SLUG_TO_PROVIDER_NAME = {
-    openai: "openai",
-    google: "google",
-    "x-ai": "x-ai",
-    "z-ai": "z-ai",
-    moonshotai: "kimi",
-    minimax: "minimax",
-    qwen: "qwen",
-    deepseek: "deepseek",
-    mistralai: "mistralai",
-    sakana: "sakana"
-  };
   RECOMMENDED_ROUTE_TIER_ORDER = {
     native: 0,
     general: 1,
@@ -45801,44 +46286,6 @@ async function isPortAvailable(port) {
 }
 var init_port_manager = () => {};
 
-// src/providers/claude-code-aliases.ts
-function claudeCodeTierAlias(model) {
-  return TIER_ALIASES[model.trim().toLowerCase()] ?? null;
-}
-function normalizeNativeModelSpec(spec) {
-  return claudeCodeTierAlias(spec) ?? spec;
-}
-var TIER_ALIASES;
-var init_claude_code_aliases = __esm(() => {
-  TIER_ALIASES = {
-    opus: "opus",
-    sonnet: "sonnet",
-    haiku: "haiku",
-    internal: "opus",
-    default: "opus"
-  };
-});
-
-// src/providers/native-route.ts
-function nativeRouteFor(model) {
-  if (model.includes("/"))
-    return null;
-  const parsed = parseModelSpec(model);
-  if (parsed.isExplicitProvider || parsed.provider !== "native-anthropic")
-    return null;
-  return {
-    provider: "native-anthropic",
-    modelSpec: normalizeNativeModelSpec(model),
-    displayName: getProviderByName("native-anthropic")?.displayName ?? "Anthropic (Native)",
-    isTierAlias: claudeCodeTierAlias(model) !== null
-  };
-}
-var init_native_route = __esm(() => {
-  init_claude_code_aliases();
-  init_model_parser();
-  init_provider_definitions();
-});
-
 // src/providers/probe-live.ts
 function effortForProvider(provider) {
   if (EFFORT_OMITTED.has(provider))
@@ -48859,7 +49306,7 @@ function prepareAdvisorPanelMessages(messages, toolUseId) {
   });
   return prepared;
 }
-function routeOf(kind, wireModel) {
+function routeOf2(kind, wireModel) {
   const url = ADVISOR_ENDPOINTS[kind];
   return { kind, host: new URL(url).host, url, credential: kind, wireModel };
 }
@@ -48869,21 +49316,21 @@ function advisorRouteFor(modelSpec, role) {
     const model = parsed.model;
     const tier = anthropicTierAlias(model);
     if (!tier)
-      return routeOf("anthropic", model);
+      return routeOf2("anthropic", model);
     const resolved = findEntryByAlias(model)?.modelId ?? latestAnthropicTierModelId(tier);
     if (!resolved)
-      return { ...routeOf("anthropic", model), unresolvedAlias: model };
-    return routeOf("anthropic", resolved);
+      return { ...routeOf2("anthropic", model), unresolvedAlias: model };
+    return routeOf2("anthropic", resolved);
   }
   const provider = parsed.provider;
   if (provider === "google" || provider === "gemini")
-    return routeOf("google", parsed.model);
+    return routeOf2("google", parsed.model);
   if (provider === "openai" || provider === "oai")
-    return routeOf("openai", parsed.model);
+    return routeOf2("openai", parsed.model);
   if (!parsed.isExplicitProvider || provider === "openrouter") {
-    return routeOf("openrouter", openRouterWireModelFor(null, parsed.model));
+    return routeOf2("openrouter", openRouterWireModelFor(null, parsed.model));
   }
-  return routeOf("openrouter", openRouterWireModelFor(provider, parsed.model));
+  return routeOf2("openrouter", openRouterWireModelFor(provider, parsed.model));
 }
 function openRouterIdOf(entry) {
   return entry.aggregators?.find((a) => catalogRouteMatchesProvider(a.route, "openrouter"))?.externalModelId ?? null;
@@ -49858,6 +50305,8 @@ function isRetryableError(status, errorBody, provider, headers) {
     return true;
   if (status === 429)
     return true;
+  if (status === 502 || status === 503 || status === 504)
+    return true;
   const lower = errorBody.toLowerCase();
   if (status === 422) {
     if (lower.includes("not available") || lower.includes("model not found") || lower.includes("not supported")) {
@@ -49885,13 +50334,14 @@ function isRetryableError(status, errorBody, provider, headers) {
 function exhaustedChainStatus(errors) {
   if (errors.length === 0)
     return 400;
+  const TRANSIENT = new Set([429, 502, 503, 504]);
   const isTransient = (e) => {
-    if (e.status === 429 || e.status === 503)
+    if (TRANSIENT.has(e.status))
       return true;
     if (hasQuotaExhaustionWording(e.message))
       return true;
     const upstream = e.status === 400 ? extractUpstreamStatus(e.message) : undefined;
-    return upstream === 429 || upstream === 503;
+    return upstream !== undefined && TRANSIENT.has(upstream);
   };
   return errors.every(isTransient) ? 503 : 400;
 }
@@ -51104,7 +51554,12 @@ async function createProxyServer(port, _openrouterApiKey, model, monitorMode = f
     }
     return null;
   };
-  const effectiveRoutingRules = loadRoutingRules();
+  const routingRuleSources = loadRoutingRuleSources();
+  const effectiveRoutingRules = loadRoutingRules(routingRuleSources);
+  for (const problem of routingRuleProblems(routingRuleSources)) {
+    logStderr(`Warning: ${describeRoutingRuleProblem(problem)}`);
+  }
+  const effectiveFallbackProvider = effectiveDefaultProvider();
   const fallbackHandlerCache = new Map;
   const detectInvocationMode = (target, wasFromModelMap) => {
     if (wasFromModelMap)
@@ -51187,14 +51642,14 @@ async function createProxyServer(port, _openrouterApiKey, model, monitorMode = f
       }
     }
     {
-      const parsedForFallback = parseModelSpec(target);
-      if (!parsedForFallback.isExplicitProvider && parsedForFallback.provider !== "native-anthropic" && !isPoeModel(target)) {
+      const decision = proxyRouteDecision(target);
+      if (decision.type === "bare") {
         const cacheKey = `fallback:${target}`;
         if (fallbackHandlerCache.has(cacheKey)) {
           return fallbackHandlerCache.get(cacheKey);
         }
         await ensureCatalogReady(5000);
-        const plan = await route(parsedForFallback.model, effectiveRoutingRules);
+        const plan = await route(decision.model, effectiveRoutingRules, effectiveFallbackProvider);
         if (plan.kind === "ok") {
           const chain = [plan.primary, ...plan.fallbacks];
           const candidates = [];
@@ -51212,8 +51667,11 @@ async function createProxyServer(port, _openrouterApiKey, model, monitorMode = f
           if (candidates.length > 0) {
             const resultHandler = candidates.length > 1 ? new FallbackHandler(candidates) : candidates[0].handler;
             fallbackHandlerCache.set(cacheKey, resultHandler);
+            const routeLine = `[Route] ${candidates.length} ${candidates.length === 1 ? "provider" : "providers"} for ${decision.model}: ${candidates.map((c) => c.name).join(" \u2192 ")}`;
             if (!options.quiet && candidates.length > 1) {
-              logStderr(`[Route] ${candidates.length} providers for ${parsedForFallback.model}: ${candidates.map((c) => c.name).join(" \u2192 ")}`);
+              logStderr(routeLine);
+            } else {
+              log(routeLine);
             }
             return resultHandler;
           }
@@ -51442,6 +51900,7 @@ var init_proxy_server = __esm(() => {
   init_endpoint_diagnostics();
   init_endpoint_registration();
   init_model_parser();
+  init_native_route();
   init_provider_definitions();
   init_provider_profiles();
   init_provider_registry();
@@ -51762,7 +52221,7 @@ Tokens: ${result.usage.input} input, ${result.usage.output} output`;
       const { flagship, fast } = groupRecommendedModels(doc.models);
       const providerByName = new Map(BUILTIN_PROVIDERS.map((p) => [p.name, p]));
       const getNativePrefix = (firebaseSlug) => {
-        const canonical = FIREBASE_SLUG_TO_PROVIDER_NAME[firebaseSlug];
+        const canonical = nativeProviderForVendor(firebaseSlug);
         if (!canonical)
           return null;
         const def = providerByName.get(canonical);
@@ -52054,7 +52513,7 @@ Use with: run_prompt(model="${suggested}", prompt="your prompt")`;
         const native = nativeRouteFor(model);
         if (native) {
           nativeModels.push(model);
-          rows.push(`| \`${model}\` | ${native.displayName} | native | ${"not probed \u2014 served on Claude Code's own auth, which this process cannot forward"} | \`${native.modelSpec}\` |`);
+          rows.push(`| \`${model}\` | ${native.displayName} | native | ${NATIVE_NOT_PROBED} | \`${native.modelSpec}\` |`);
           continue;
         }
         let plan;
@@ -52849,6 +53308,7 @@ var init_mcp_server = __esm(() => {
   init_onepassword();
   init_probe_live();
   init_provider_definitions();
+  init_route_candidates();
   init_routing_rules();
   init_proxy_server();
   init_redact();
@@ -53436,66 +53896,26 @@ import { existsSync as existsSync28, readFileSync as readFileSync28, writeFileSy
 import { connect as netConnect } from "net";
 import { join as join37 } from "path";
 import { setTimeout as wait } from "timers/promises";
-function resolveRouteInfo(modelId) {
-  const parsed = parseModelSpec(modelId);
-  if (parsed.isExplicitProvider) {
-    return { chain: [parsed.provider], source: "direct" };
-  }
-  const local = loadLocalConfig();
-  if (local?.routing && Object.keys(local.routing).length > 0) {
-    const matched = matchRoutingRule(parsed.model, local.routing);
-    if (matched) {
-      const routes = buildRoutingChain(matched, parsed.model);
-      const pattern = Object.keys(local.routing).find((k) => {
-        if (k === parsed.model)
-          return true;
-        if (k.includes("*")) {
-          const star = k.indexOf("*");
-          return parsed.model.startsWith(k.slice(0, star)) && parsed.model.endsWith(k.slice(star + 1));
-        }
-        return false;
-      });
-      return {
-        chain: routes.map((r) => r.displayName),
-        source: "project routing",
-        sourceDetail: pattern
-      };
-    }
-  }
-  const global_ = loadConfig();
-  if (global_.routing && Object.keys(global_.routing).length > 0) {
-    const matched = matchRoutingRule(parsed.model, global_.routing);
-    if (matched) {
-      const routes = buildRoutingChain(matched, parsed.model);
-      const pattern = Object.keys(global_.routing).find((k) => {
-        if (k === parsed.model)
-          return true;
-        if (k.includes("*")) {
-          const star = k.indexOf("*");
-          return parsed.model.startsWith(k.slice(0, star)) && parsed.model.endsWith(k.slice(star + 1));
-        }
-        return false;
-      });
-      return {
-        chain: routes.map((r) => r.displayName),
-        source: "user routing",
-        sourceDetail: pattern
-      };
+function paneRouteLine(explanation) {
+  const origin = describeRouteExplanation(explanation);
+  if (explanation.outcome.kind === "no-route") {
+    return `no route \u2014 ${explanation.outcome.reason}  (${origin})`;
+  }
+  if (explanation.native)
+    return `${explanation.native.displayName}  (${origin})`;
+  const hops = explanation.candidates.filter((candidate) => candidate.outcome === "kept").map((candidate) => candidate.displayName);
+  return `${hops.join(" \u2192 ")}  (${origin})`;
+}
+async function resolvePaneRouteLines(models) {
+  const unique = [...new Set(models)];
+  const entries = await Promise.all(unique.map(async (model) => {
+    try {
+      return [model, paneRouteLine(await explainRoute(model))];
+    } catch (err) {
+      return [model, `unknown \u2014 ${err instanceof Error ? err.message : String(err)}`];
     }
-  }
-  const merged = loadRoutingRules();
-  const matched = matchRoutingRule(parsed.model, merged);
-  if (matched) {
-    const routes = buildRoutingChain(matched, parsed.model);
-    return {
-      chain: routes.map((r) => r.displayName),
-      source: "auto"
-    };
-  }
-  return {
-    chain: [],
-    source: "auto"
-  };
+  }));
+  return new Map(entries);
 }
 function pickBannerColor(model, used) {
   let hash = 0;
@@ -53510,14 +53930,11 @@ function pickBannerColor(model, used) {
   used.add(idx);
   return BANNER_BG_COLORS[idx];
 }
-function buildPaneHeader(model, prompt, bg) {
-  const route = resolveRouteInfo(model);
+function buildPaneHeader(model, routeLine, prompt, bg) {
   const esc = (s) => s.replace(/'/g, "'\\''");
-  const chainStr = route.chain.join(" \u2192 ");
-  const sourceLabel = route.sourceDetail ? `${route.source}: ${route.sourceDetail}` : route.source;
   const lines = [];
   lines.push(`printf '\\033[1;97;${bg}m  %s  \\033[0m\\n' '${esc(model)}';`);
-  lines.push(`printf '\\033[2m  route: ${esc(chainStr)}  (${esc(sourceLabel)})\\033[0m\\n' ;`);
+  lines.push(`printf '\\033[2m  route: %s\\033[0m\\n' '${esc(routeLine)}';`);
   lines.push(`printf '\\033[2m  %s\\033[0m\\n' '\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500';`);
   const promptForShell = esc(prompt).replace(/\n/g, "\\n");
   lines.push(`printf '%b\\n' '${promptForShell}' | fold -s -w 78 | sed 's/^/  /';`);
@@ -53623,13 +54040,14 @@ async function runWithGrid(sessionPath, models, input, opts) {
   const prompt = readFileSync28(join37(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
   const rawPrompt = readFileSync28(join37(sessionPath, "input.md"), "utf-8");
   const usedBannerColors = new Set;
+  const routeLines = mode === "interactive" ? new Map : await resolvePaneRouteLines(Object.values(manifest.models).map((entry) => entry.model));
   const gridLines = Object.entries(manifest.models).map(([anonId]) => {
     const model = manifest.models[anonId].model;
     if (mode === "interactive") {
       return `claudish --model ${model} -i --dangerously-skip-permissions '${prompt}'`;
     }
     const bg = pickBannerColor(model, usedBannerColors);
-    const header = buildPaneHeader(model, rawPrompt, bg);
+    const header = buildPaneHeader(model, routeLines.get(model) ?? "", rawPrompt, bg);
     return `${header} claudish --model ${model} -y --quiet '${prompt}'`;
   });
   writeFileSync17(gridfilePath, `${gridLines.join(`
@@ -53659,8 +54077,6 @@ async function runWithGrid(sessionPath, models, input, opts) {
 var BANNER_BG_COLORS;
 var init_team_grid = __esm(() => {
   init_magmux_binary();
-  init_profile_config();
-  init_model_parser();
   init_routing_rules();
   init_team_orchestrator();
   BANNER_BG_COLORS = [
@@ -57112,32 +57528,6 @@ var init_quota_command = __esm(() => {
   };
 });
 
-// src/default-provider.ts
-function resolveDefaultProvider(opts) {
-  const env = opts.env ?? process.env;
-  if (opts.cliFlag && opts.cliFlag.length > 0) {
-    return { provider: opts.cliFlag, source: "cli-flag", legacyAutoPromoted: false };
-  }
-  const envVal = env.CLAUDISH_DEFAULT_PROVIDER;
-  if (envVal && envVal.length > 0) {
-    return { provider: envVal, source: "env-var", legacyAutoPromoted: false };
-  }
-  if (opts.config.defaultProvider && opts.config.defaultProvider.length > 0) {
-    return {
-      provider: opts.config.defaultProvider,
-      source: "config-file",
-      legacyAutoPromoted: false
-    };
-  }
-  if (env.OPENROUTER_API_KEY) {
-    return { provider: "openrouter", source: "openrouter-key", legacyAutoPromoted: false };
-  }
-  return { provider: "openrouter", source: "hardcoded", legacyAutoPromoted: false };
-}
-function buildLegacyHint(_resolved) {
-  return null;
-}
-
 // src/providers/model-catalog.ts
 function aggregatorProviderSlugs(readSlimCache) {
   const cache = readSlimCache();
@@ -57293,9 +57683,9 @@ var init_model_catalog2 = __esm(() => {
     "opencode-zen",
     "opencode-zen-go",
     "fireworks",
-    "together-ai"
+    "together"
   ]);
-  NO_CATALOG_VENDOR_SLUGS = new Set(["litellm", "ollama", "lmstudio", "lm-studio"]);
+  NO_CATALOG_VENDOR_SLUGS = new Set(["litellm", "ollama", "lmstudio"]);
 });
 
 // src/theme/renderer-theme.ts
@@ -61275,21 +61665,141 @@ var init_model_selector = __esm(() => {
   _modelsCatalogCollapse = { collapse: collapseModelsCatalog };
 });
 
+// src/probe/probe-chain.ts
+function probeChainFrom(explanation, credentials) {
+  if (explanation.source === "native" && explanation.native) {
+    return { chain: [nativeLinkOf(explanation.native)], dropped: [] };
+  }
+  const chain = [];
+  const dropped = [];
+  for (const candidate of explanation.candidates) {
+    if (candidate.outcome === "kept")
+      chain.push(keptLinkOf(candidate, credentials));
+    else
+      dropped.push(droppedLinkOf(candidate, candidate.outcome, credentials));
+  }
+  return { chain, dropped };
+}
+function nativeLinkOf(native) {
+  return {
+    provider: native.provider,
+    displayName: native.displayName,
+    modelSpec: native.modelSpec,
+    wireId: native.modelSpec,
+    position: "candidate",
+    label: NATIVE_LINK_LABEL,
+    hasCredentials: true,
+    notProbed: "native-auth"
+  };
+}
+function keptLinkOf(candidate, credentials) {
+  const provenance = credentials.provenanceFor(candidate.provider);
+  return {
+    provider: candidate.provider,
+    displayName: candidate.displayName,
+    modelSpec: candidate.modelSpec,
+    wireId: candidate.wireId,
+    position: candidate.position,
+    ...candidate.tier !== undefined ? { tier: candidate.tier } : {},
+    label: hopLabel(candidate),
+    ...candidate.availability ? { availability: candidate.availability } : {},
+    hasCredentials: true,
+    ...provenance ? { provenance } : {}
+  };
+}
+function droppedLinkOf(candidate, outcome, credentials) {
+  const hint = outcome === "no-credential" ? credentials.hintFor(candidate.provider) : undefined;
+  return {
+    provider: candidate.provider,
+    displayName: candidate.displayName,
+    wireId: candidate.wireId,
+    position: candidate.position,
+    ...candidate.tier !== undefined ? { tier: candidate.tier } : {},
+    label: hopLabel(candidate),
+    outcome,
+    ...hint ? { credentialHint: hint } : {}
+  };
+}
+function routingFieldsFrom(explanation) {
+  const { outcome } = explanation;
+  return {
+    routingSource: explanation.source,
+    routingExplanation: describeRouteExplanation(explanation),
+    ...explanation.matchedPattern !== undefined ? { matchedPattern: explanation.matchedPattern } : {},
+    ...explanation.ruleScope ? { ruleScope: explanation.ruleScope } : {},
+    ...outcome.kind === "no-route" ? {
+      noRoute: {
+        reason: outcome.reason,
+        ...outcome.hint !== undefined ? { hint: outcome.hint } : {}
+      }
+    } : {},
+    warnings: explanation.warnings
+  };
+}
+function resultLinksFrom(chain, dropped) {
+  return [
+    ...chain.map((link) => ({
+      provider: link.provider,
+      displayName: link.displayName,
+      modelId: link.wireId,
+      label: link.label,
+      hasCredentials: link.hasCredentials,
+      ...link.credentialHint ? { credentialHint: link.credentialHint } : {},
+      ...link.notProbed ? { notProbed: link.notProbed } : {},
+      ...link.probe ? { probe: link.probe } : {}
+    })),
+    ...dropped.map((entry) => ({
+      provider: entry.provider,
+      displayName: entry.displayName,
+      modelId: entry.wireId,
+      label: entry.label,
+      hasCredentials: entry.outcome === "not-served",
+      ...entry.credentialHint ? { credentialHint: entry.credentialHint } : {},
+      dropped: entry.outcome
+    }))
+  ];
+}
+var NATIVE_LINK_LABEL = "Claude Code's own auth";
+var init_probe_chain = __esm(() => {
+  init_routing_rules();
+});
+
 // src/providers/probe-runner.ts
 function pinProbeModelSpec(link) {
   if (link.provider === "native-anthropic")
     return link.modelSpec;
   return link.modelSpec.includes("@") ? link.modelSpec : `${link.provider}@${link.modelSpec}`;
 }
+function droppedRemedy(credentialHint) {
+  if (!credentialHint)
+    return;
+  return /^[A-Z][A-Z0-9_]*$/.test(credentialHint) ? `set ${credentialHint}` : credentialHint;
+}
+function describeDropped(outcome, credentialHint) {
+  const remedy = droppedRemedy(credentialHint);
+  return remedy ? `${DROPPED_LABEL[outcome]} \xB7 ${remedy}` : DROPPED_LABEL[outcome];
+}
+function probeTargets(explanation) {
+  return explanation.candidates.filter((candidate) => candidate.outcome === "kept").map((candidate) => ({
+    ...candidate,
+    probeSpec: explanation.source === "explicit" ? explanation.requestedModel : pinProbeModelSpec(candidate)
+  }));
+}
 function probeProviderRoute(proxyUrl, link, timeoutMs) {
   return probeLink(proxyUrl, {
     ...link,
     modelSpec: pinProbeModelSpec(link)
   }, timeoutMs);
 }
-var INTERACTIVE_PROBE_TIMEOUT_MS = 60000;
+var INTERACTIVE_PROBE_TIMEOUT_MS = 60000, DROPPED_LABEL;
 var init_probe_runner = __esm(() => {
   init_probe_live();
+  DROPPED_LABEL = {
+    "no-credential": "no credential",
+    "credential-unreadable": "credential could not be read",
+    "not-served": "account does not serve it",
+    "excluded-by-membership": "not in the plan's membership"
+  };
 });
 
 // src/probe/probe-results-printer.ts
@@ -61383,7 +61893,6 @@ function computeBarScales(results) {
       maxTokPerSec = scaledTps;
   };
   for (const r of results) {
-    consider(r.directProbe);
     for (const c of r.chain ?? [])
       consider(c.probe);
   }
@@ -61607,6 +62116,16 @@ function buildRowData(result, isLiveProbe) {
   return result.chain.map((entry, i) => {
     const isFastest = i === fastestIdx;
     const isSlowest = i === slowestIdx;
+    if (entry.notProbed) {
+      return {
+        num: `${i + 1}`,
+        provider: entry.displayName,
+        label: entry.label ?? "",
+        spec: entry.modelSpec,
+        status: `${pc.cyan}\u25D0 native \u2014 not probed${pc.reset}`,
+        note: NATIVE_NOT_PROBED
+      };
+    }
     let status = shortStatusLabel(entry.probe, entry.hasCredentials, entry.credentialHint);
     if (isFastest) {
       status = `${status} ${pc.brightGreen}\u25CF${pc.reset}`;
@@ -61619,6 +62138,7 @@ function buildRowData(result, isLiveProbe) {
     return {
       num: `${i + 1}`,
       provider: entry.displayName,
+      label: entry.label ?? "",
       spec: entry.modelSpec,
       status,
       errorDetail,
@@ -61628,40 +62148,19 @@ function buildRowData(result, isLiveProbe) {
     };
   });
 }
-function buildDirectRowData(result) {
-  const probe = result.directProbe;
-  let status;
-  if (!probe) {
-    status = `${pc.dim}\u2014 no probe \u2014${pc.reset}`;
-  } else {
-    status = shortStatusLabel(probe, true);
-    if (probe.state === "live") {
-      status = `${status} ${pc.brightGreen}\u25CF${pc.reset}`;
-    }
-  }
-  let errorDetail;
-  if (probe && isFailureState(probe.state) && probe.errorMessage) {
-    errorDetail = stripAnsi2(probe.errorMessage).replace(/\s+/g, " ").trim();
-  }
-  const barsTiming = probe?.state === "live" && probe.timing ? probe.timing : undefined;
-  return [
-    {
-      num: "1",
-      provider: result.nativeProvider,
-      spec: pinProbeModelSpec({ provider: result.nativeProvider, modelSpec: result.model }),
-      status,
-      errorDetail,
-      barsTiming
-    }
-  ];
+function buildDroppedRowData(result) {
+  return (result.dropped ?? []).map((entry) => ({
+    num: "\u2013",
+    provider: entry.displayName,
+    label: entry.label ?? "",
+    spec: entry.wireId,
+    status: `${pc.dim}\u2013 ${DROPPED_LABEL[entry.outcome]}${pc.reset}`,
+    note: droppedRemedy(entry.credentialHint)
+  }));
 }
 function computeColumnWidths(rows) {
-  const headers = ["#", "Provider", "Model Spec", "Status"];
-  const wNum = Math.max(headers[0].length, ...rows.map((r) => r.num.length));
-  const wProv = Math.max(headers[1].length, ...rows.map((r) => visibleLength(r.provider)));
-  const wSpec = Math.max(headers[2].length, ...rows.map((r) => visibleLength(r.spec)));
-  const wStatus = Math.max(headers[3].length, ...rows.map((r) => visibleLength(r.status)));
-  return [wNum, wProv, wSpec, wStatus];
+  const cells = (r) => [r.num, r.provider, r.label, r.spec, r.status];
+  return COLUMN_HEADERS.map((header, col) => Math.max(header.length, ...rows.map((r) => visibleLength(cells(r)[col]))));
 }
 function computeCardWidth(_rows, widths, topTitleVis, topSummaryVis, footerVis) {
   const tableRowWidth = 2 + CARD_PADDING_LEFT + widths.reduce((a, b) => a + b, 0) + (widths.length - 1) * 3 + CARD_PADDING_RIGHT;
@@ -61682,6 +62181,9 @@ function formatContextWindow(ctx) {
   return `${Math.round(ctx / 1000)}K`;
 }
 function buildKeyLine(activeEntry, directKeyVar) {
+  if (activeEntry?.notProbed) {
+    return `${pc.bold}Key${pc.reset}  ${pc.dim}Claude Code's own auth (not visible to this process)${pc.reset}`;
+  }
   if (activeEntry?.provenance) {
     const p = activeEntry.provenance;
     const subject = p.effectiveLabel ?? `$${p.envVar}`;
@@ -61702,21 +62204,29 @@ function buildWireLine(wiring, activeProvider) {
   const head = activeProvider ? `${activeProvider} \u2192 ` : "";
   return `${pc.bold}Wire${pc.reset} ${head}${wiring.effectiveStreamFormat} \xB7 ${wiring.modelTranslator} \xB7 ${ctx}`;
 }
+function cardSummary(result) {
+  const first = result.chain[0];
+  if (!first)
+    return { text: result.routingExplanation || "no route", color: pc.red };
+  if (first.notProbed)
+    return { text: `${first.displayName} \xB7 not probed`, color: pc.cyan };
+  const probed = result.chain.filter((c) => !c.notProbed);
+  const live = probed.filter((c) => c.probe?.state === "live").length;
+  return {
+    text: `${first.displayName} \xB7 ${live}/${probed.length} live`,
+    color: summaryColor(live, probed.length)
+  };
+}
 function buildCardLayout(result, isLiveProbe, directKeyVar) {
-  const rows = result.routingSource === "direct" ? buildDirectRowData(result) : buildRowData(result, isLiveProbe);
-  const totalLinks = rows.length;
-  const liveCount = result.chain ? result.chain.filter((c) => c.probe?.state === "live").length : result.directProbe?.state === "live" ? 1 : 0;
-  const effLive = result.routingSource === "direct" ? liveCount : liveCount;
-  const effTotal = result.routingSource === "direct" ? totalLinks : result.chain.length;
-  const titleText = result.model;
-  const sumColor = summaryColor(effLive, effTotal);
-  const summaryPlain = `${result.nativeProvider} \xB7 ${effLive}/${effTotal} live`;
-  const titleStyled = `${pc.bold}${pc.cyan}${titleText}${pc.reset}`;
-  const summaryStyled = `${sumColor}${summaryPlain}${pc.reset}`;
-  const activeEntry = result.chain?.find((c) => c.probe?.state === "live") ?? result.chain?.find((c) => c.hasCredentials);
+  const rows = [...buildRowData(result, isLiveProbe), ...buildDroppedRowData(result)];
+  const summary = cardSummary(result);
+  const titleStyled = `${pc.bold}${pc.cyan}${result.model}${pc.reset}`;
+  const summaryStyled = `${summary.color}${summary.text}${pc.reset}`;
+  const activeEntry = result.chain.find((c) => c.probe?.state === "live") ?? result.chain.find((c) => c.hasCredentials);
   const keyLine = buildKeyLine(activeEntry, directKeyVar);
-  const wireLine = result.wiring ? buildWireLine(result.wiring, activeEntry?.displayName ?? result.nativeProvider) : "";
-  const footerVis = Math.max(visibleLength(keyLine), visibleLength(wireLine));
+  const wireLine = result.wiring && !activeEntry?.notProbed ? buildWireLine(result.wiring, activeEntry?.displayName) : "";
+  const routeLine = result.routingExplanation ? `${pc.bold}Route${pc.reset} ${result.routingExplanation}` : "";
+  const footerVis = Math.max(visibleLength(keyLine), visibleLength(wireLine), visibleLength(routeLine));
   const widths = computeColumnWidths(rows);
   return {
     rows,
@@ -61725,6 +62235,7 @@ function buildCardLayout(result, isLiveProbe, directKeyVar) {
     summaryStyled,
     keyLine,
     wireLine,
+    routeLine,
     footerVis,
     activeEntry
   };
@@ -61736,17 +62247,12 @@ function computeRequiredWidth(result, isLiveProbe, directKeyVar) {
 }
 function renderCard(result, isLiveProbe, w, width, scales, directKeyVar) {
   const layout = buildCardLayout(result, isLiveProbe, directKeyVar);
-  const { rows, widths, titleStyled, summaryStyled, keyLine, wireLine } = layout;
+  const { rows, widths, titleStyled, summaryStyled, keyLine, wireLine, routeLine } = layout;
   w(`${renderBorderTop(titleStyled, summaryStyled, width)}
 `);
   w(`${renderBlankLine(width)}
 `);
-  const headerCells = [
-    `${pc.dim}#${pc.reset}`,
-    `${pc.dim}Provider${pc.reset}`,
-    `${pc.dim}Model Spec${pc.reset}`,
-    `${pc.dim}Status${pc.reset}`
-  ];
+  const headerCells = COLUMN_HEADERS.map((h) => `${pc.dim}${h}${pc.reset}`);
   w(`${renderRow(headerCells, widths, width)}
 `);
   w(`${renderSepRow(widths, width)}
@@ -61754,7 +62260,13 @@ function renderCard(result, isLiveProbe, w, width, scales, directKeyVar) {
   for (let rowIdx = 0;rowIdx < rows.length; rowIdx++) {
     const r = rows[rowIdx];
     const bg = r.fastest ? pc.bgFastest : r.slowest ? pc.bgSlowest : undefined;
-    const cells = [r.num, r.provider, `${pc.dim}${r.spec}${pc.reset}`, r.status];
+    const cells = [
+      r.num,
+      r.provider,
+      `${pc.dim}${r.label}${pc.reset}`,
+      `${pc.dim}${r.spec}${pc.reset}`,
+      r.status
+    ];
     w(`${renderRow(cells, widths, width, bg)}
 `);
     if (r.barsTiming) {
@@ -61768,36 +62280,10 @@ function renderCard(result, isLiveProbe, w, width, scales, directKeyVar) {
 `);
       }
     }
-    if (r.errorDetail) {
-      const innerUsable = width - 2 - CARD_PADDING_LEFT - CARD_PADDING_RIGHT;
-      const errorIndent = 4;
-      const prefixVis = 2;
-      const textWidth = innerUsable - errorIndent - prefixVis;
-      const MAX_ERROR_LINES = 4;
-      if (textWidth > 0) {
-        let wrapped = wordWrap(r.errorDetail, textWidth);
-        let truncated = false;
-        if (wrapped.length > MAX_ERROR_LINES) {
-          wrapped = wrapped.slice(0, MAX_ERROR_LINES);
-          truncated = true;
-        }
-        if (truncated) {
-          const last = wrapped[wrapped.length - 1];
-          if (last.length >= textWidth) {
-            wrapped[wrapped.length - 1] = `${last.slice(0, textWidth - 1)}\u2026`;
-          } else {
-            wrapped[wrapped.length - 1] = `${last}\u2026`;
-          }
-        }
-        const indentStr = " ".repeat(errorIndent);
-        for (let i = 0;i < wrapped.length; i++) {
-          const prefix = i === 0 ? "\u2514 " : "  ";
-          const body = `${indentStr}${pc.dim}${pc.red}${prefix}${wrapped[i]}${pc.reset}`;
-          w(`${renderTextLine(body, width, bg)}
-`);
-        }
-      }
-    }
+    if (r.errorDetail)
+      writeSubRows(w, r.errorDetail, `${pc.dim}${pc.red}`, width, bg);
+    if (r.note)
+      writeSubRows(w, r.note, pc.dim, width, bg);
   }
   w(`${renderBlankLine(width)}
 `);
@@ -61809,14 +62295,61 @@ function renderCard(result, isLiveProbe, w, width, scales, directKeyVar) {
     w(`${renderTextLine(wireLine, width)}
 `);
   }
-  if (result.routingSource === "custom-rules" && result.matchedPattern) {
-    const note = `${pc.dim}Custom rule: ${pc.reset}${pc.cyan}${result.matchedPattern}${pc.reset}`;
-    w(`${renderTextLine(note, width)}
+  if (visibleLength(routeLine) > 0) {
+    w(`${renderTextLine(routeLine, width)}
 `);
   }
+  writeDecisionNotes(w, result, width);
   w(`${renderBorderBottom(width)}
 `);
 }
+function writeDecisionNotes(w, result, width) {
+  const textWidth = cardTextWidth(width);
+  if (result.noRoute) {
+    const head = "No route  ";
+    wordWrap(result.noRoute.reason, textWidth - head.length).forEach((line, i) => {
+      const lead = i === 0 ? `${pc.red}No route${pc.reset}  ` : " ".repeat(head.length);
+      w(`${renderTextLine(`${lead}${line}`, width)}
+`);
+    });
+    const hintLines = (result.noRoute.hint ?? "").split(`
+`).filter((l) => l.trim());
+    const fitted = hintLines.flatMap((l) => l.length <= textWidth ? [l] : wordWrap(l, textWidth));
+    for (const line of fitted) {
+      w(`${renderTextLine(`${pc.dim}${line}${pc.reset}`, width)}
+`);
+    }
+  }
+  const notices = (result.warnings ?? []).filter((warning) => warning.type !== "rule-problem");
+  for (const line of notices.flatMap((warning) => wordWrap(`\u26A0 ${warning.message}`, textWidth))) {
+    w(`${renderTextLine(`${pc.yellow}${line}${pc.reset}`, width)}
+`);
+  }
+}
+function cardTextWidth(width) {
+  return Math.max(10, width - 2 - CARD_PADDING_LEFT - CARD_PADDING_RIGHT);
+}
+function writeSubRows(w, text, color, width, bg) {
+  const indent = 4;
+  const prefixVis = 2;
+  const textWidth = cardTextWidth(width) - indent - prefixVis;
+  const MAX_LINES = 4;
+  if (textWidth <= 0)
+    return;
+  let wrapped = wordWrap(text, textWidth);
+  if (wrapped.length > MAX_LINES) {
+    wrapped = wrapped.slice(0, MAX_LINES);
+    const last = wrapped[wrapped.length - 1];
+    wrapped[wrapped.length - 1] = last.length >= textWidth ? `${last.slice(0, textWidth - 1)}\u2026` : `${last}\u2026`;
+  }
+  const indentStr = " ".repeat(indent);
+  for (let i = 0;i < wrapped.length; i++) {
+    const prefix = i === 0 ? "\u2514 " : "  ";
+    const body = `${indentStr}${color}${prefix}${wrapped[i]}${pc.reset}`;
+    w(`${renderTextLine(body, width, bg)}
+`);
+  }
+}
 function renderLegend(w) {
   const net = STAGE_BG_ANSI.network;
   const srv = STAGE_BG_ANSI.server;
@@ -61837,11 +62370,12 @@ function pickRepresentative(result) {
       return { model: result.model, provider: entry.displayName, timing: entry.probe.timing };
     }
   }
-  const direct = result.directProbe;
-  if (direct?.state === "live" && direct.timing) {
-    return { model: result.model, provider: result.nativeProvider, timing: direct.timing };
-  }
-  return { model: result.model, provider: result.nativeProvider };
+  const first = result.chain?.[0];
+  return {
+    model: result.model,
+    provider: first?.displayName ?? result.routingExplanation,
+    missing: first?.notProbed ? "not probed (native)" : first ? "no live route" : "no route"
+  };
 }
 function renderLeaderboard(results, scales, maxWidth, w) {
   const reps = results.map(pickRepresentative);
@@ -61935,7 +62469,7 @@ function renderLeaderboard(results, scales, maxWidth, w) {
     const rankStr = " ".repeat(rankW);
     const name = padEnd(`${pc.dim}${truncate3(row.model, nameW)}${pc.reset}`, nameW);
     const prov = padEnd(`${pc.dim}${truncate3(row.provider, provW)}${pc.reset}`, provW);
-    w(`${margin}${rankStr}   ${name} ${prov} ${pc.dim}\u2014 no live route${pc.reset}
+    w(`${margin}${rankStr}   ${name} ${prov} ${pc.dim}\u2014 ${row.missing}${pc.reset}
 `);
   }
   const rowVis = leadW - MARGIN + LB_TIMELINE + (showBreakdown ? LB_BREAKDOWN : 0) + (showTokBar ? LB_TOKBAR : 2) + LB_TOK_VALUE;
@@ -61945,13 +62479,24 @@ function renderLeaderboard(results, scales, maxWidth, w) {
   w(`
 `);
 }
+function renderRuleProblems(results, w) {
+  const messages = new Set(results.flatMap((r) => (r.warnings ?? []).filter((x) => x.type === "rule-problem").map((x) => x.message)));
+  for (const message of messages) {
+    w(`  ${pc.yellow}\u26A0 routing rule: ${message}${pc.reset}
+`);
+  }
+  if (messages.size > 0)
+    w(`
+`);
+}
 function printProbeResults(results, isLiveProbe) {
   refreshPc();
   const w = process.stderr.write.bind(process.stderr);
   w(`
 `);
   const scales = computeBarScales(results);
-  const anyTimedLive = results.some((r) => r.directProbe?.state === "live" && r.directProbe.timing !== undefined) || results.some((r) => (r.chain ?? []).some((c) => c.probe?.state === "live" && c.probe.timing !== undefined));
+  const anyTimedLive = results.some((r) => (r.chain ?? []).some((c) => c.probe?.state === "live" && c.probe.timing !== undefined));
+  renderRuleProblems(results, w);
   if (isLiveProbe && anyTimedLive) {
     renderLegend(w);
   }
@@ -61975,13 +62520,16 @@ function printProbeResults(results, isLiveProbe) {
     w(`
 `);
   }
-  w(`  ${pc.dim}Tip: chain order is LiteLLM \u2192 Zen Go \u2192 Subscription \u2192 Native API \u2192 OpenRouter${pc.reset}
+  w(`  ${pc.dim}Tip: a matching user rule is used as written; otherwise the catalog orders hops by tier,${pc.reset}
+`);
+  w(`  ${pc.dim}     subscription first, and the fallback hop comes last. Dropped candidates are never probed.${pc.reset}
 `);
   w(`
 `);
 }
-var pc, ANSI_RE2, PRINTER_BAR_WIDTH = 24, PRINTER_TOK_WIDTH = 14, PRINTER_TRACK = "\xB7", PRINTER_BAR_FILL = "\u2588", STAGE_NUM_W = 6, PRINTER_TOK_VALUE_W = 9, PRINTER_BARS_FULL_WIDTH, PRINTER_BARS_NOTOK_WIDTH, PRINTER_BARS_MIN_WIDTH, MIN_CARD_WIDTH = 60, CARD_PADDING_LEFT = 2, CARD_PADDING_RIGHT = 2;
+var pc, ANSI_RE2, PRINTER_BAR_WIDTH = 24, PRINTER_TOK_WIDTH = 14, PRINTER_TRACK = "\xB7", PRINTER_BAR_FILL = "\u2588", STAGE_NUM_W = 6, PRINTER_TOK_VALUE_W = 9, PRINTER_BARS_FULL_WIDTH, PRINTER_BARS_NOTOK_WIDTH, PRINTER_BARS_MIN_WIDTH, MIN_CARD_WIDTH = 60, CARD_PADDING_LEFT = 2, CARD_PADDING_RIGHT = 2, COLUMN_HEADERS;
 var init_probe_results_printer = __esm(() => {
+  init_native_route();
   init_probe_live();
   init_probe_runner();
   init_ansi();
@@ -61991,6 +62539,7 @@ var init_probe_results_printer = __esm(() => {
   PRINTER_BARS_FULL_WIDTH = 24 + 2 + 7 + 34 + 17 + 9;
   PRINTER_BARS_NOTOK_WIDTH = 24 + 2 + 7 + 34 + 2 + 9;
   PRINTER_BARS_MIN_WIDTH = 24 + 2 + 7 + 2 + 9;
+  COLUMN_HEADERS = ["#", "Provider", "Tier", "Model Spec", "Status"];
 });
 
 // src/probe/probe-tui-app.tsx
@@ -62183,7 +62732,7 @@ function ProgressBar({
   isRunFastest
 }) {
   const elapsedMs = link.status === "waiting" ? 0 : link.startTime ? (link.endTime ?? Date.now()) - link.startTime : 0;
-  const elapsed = formatElapsed(elapsedMs);
+  const elapsed = link.status === "not-probed" ? "  \u2013  " : formatElapsed(elapsedMs);
   const displayName = padEndSafe(link.displayName, maxNameLen);
   const prefix = /* @__PURE__ */ jsxs9(Fragment6, {
     children: [
@@ -62201,6 +62750,19 @@ function ProgressBar({
       })
     ]
   });
+  if (link.status === "not-probed") {
+    const used = ELAPSED_COL + maxNameLen + 2;
+    const fg = link.tone === "native" ? C.cyan : link.tone === "ready" ? C.green : C.dim;
+    return /* @__PURE__ */ jsxs9("text", {
+      children: [
+        prefix,
+        /* @__PURE__ */ jsx12("span", {
+          fg,
+          children: clipReason(stripAnsi3(link.note ?? "not probed"), layout.width - used)
+        })
+      ]
+    });
+  }
   if (layout.pillFallback) {
     if (link.status === "live") {
       const latency = link.timing?.totalMs ?? elapsedMs;
@@ -62562,6 +63124,16 @@ function shortFailureReason(probe, hasCreds) {
     return "key missing";
   return stripAnsi3(describeProbeState(probe));
 }
+function notProbedRow(link) {
+  if (link.notProbed)
+    return { mark: "\u25D0  ", text: `native \u2014 ${NATIVE_NOT_PROBED}`, fg: C.cyan };
+  if (link.dropped) {
+    return { mark: "\u2013  ", text: describeDropped(link.dropped, link.credentialHint), fg: C.dim };
+  }
+  if (!link.probe && link.hasCredentials)
+    return { mark: "\u25CB  ", text: "not probed", fg: C.dim };
+  return null;
+}
 function DetailLinkRow({
   link,
   isWinner,
@@ -62598,8 +63170,24 @@ function DetailLinkRow({
       })
     ]
   });
+  const used = 2 + 1 + 1 + provW + 2 + 3;
+  const idle = notProbedRow(link);
+  if (idle) {
+    return /* @__PURE__ */ jsxs9("text", {
+      children: [
+        lead,
+        /* @__PURE__ */ jsx12("span", {
+          fg: idle.fg,
+          children: idle.mark
+        }),
+        /* @__PURE__ */ jsx12("span", {
+          fg: idle.fg,
+          children: clipReason(idle.text, layout.width - used)
+        })
+      ]
+    });
+  }
   if (!isLive || !probe?.timing) {
-    const used = 2 + 1 + 1 + provW + 2 + 3;
     return /* @__PURE__ */ jsxs9("text", {
       children: [
         lead,
@@ -62732,7 +63320,7 @@ function DetailModel({
   const gap = Math.max(2, headerW - result.model.length - result.routingExplanation.length - 2);
   const wiring = result.wiring;
   const wireLine = winner && wiring ? `wire (${winner.displayName}): ${wiring.effectiveStreamFormat} \xB7 ${wiring.modelTranslator} \xB7 ${formatContextWindow2(wiring.contextWindow)} ctx` : "wire: \u2014";
-  const routeChain = result.links.map((l) => l.displayName).join(" \u2192 ");
+  const routeChain = result.links.filter((l) => !l.dropped).map((l) => l.label ? `${l.displayName} (${l.label})` : l.displayName).join(" \u2192 ");
   const liveLinks = result.links.filter((l) => l.probe?.state === "live" && !!l.probe.timing);
   let fastestByLatency;
   let fastestByTput;
@@ -62791,6 +63379,24 @@ function DetailModel({
           })
         ]
       }),
+      result.noRoute && /* @__PURE__ */ jsxs9("text", {
+        children: [
+          /* @__PURE__ */ jsx12("span", {
+            fg: C.red,
+            children: "  no route  "
+          }),
+          /* @__PURE__ */ jsx12("span", {
+            fg: C.fg,
+            children: clipReason(result.noRoute.reason, layout.width - 12)
+          })
+        ]
+      }),
+      (result.warnings ?? []).filter((w) => w.type !== "rule-problem").map((w) => /* @__PURE__ */ jsx12("text", {
+        children: /* @__PURE__ */ jsx12("span", {
+          fg: C.yellow,
+          children: `  \u26A0 ${clipReason(w.message, layout.width - 4)}`
+        })
+      }, `${result.model}:warn:${w.message}`)),
       result.links.map((link, i) => /* @__PURE__ */ jsx12(DetailLinkRow, {
         link,
         isWinner: i === winnerIdx,
@@ -62874,17 +63480,28 @@ function DetailsView({
 }) {
   const provW = Math.min(22, Math.max(8, ...results.flatMap((r) => r.links.map((l) => l.displayName.length))));
   const headerW = Math.max(24, Math.min(detailRowWidth(provW, layout), (termWidth || 100) - 3));
-  return /* @__PURE__ */ jsx12("box", {
+  const ruleProblems = [
+    ...new Set(results.flatMap((r) => (r.warnings ?? []).filter((w) => w.type === "rule-problem").map((w) => w.message)))
+  ];
+  return /* @__PURE__ */ jsxs9("box", {
     flexDirection: "column",
-    children: results.map((r, idx) => /* @__PURE__ */ jsx12(DetailModel, {
-      result: r,
-      provW,
-      headerW,
-      layout,
-      maxTotalMs,
-      maxTokPerSec,
-      isLast: idx === results.length - 1
-    }, r.model))
+    children: [
+      ruleProblems.map((message) => /* @__PURE__ */ jsx12("text", {
+        children: /* @__PURE__ */ jsx12("span", {
+          fg: C.yellow,
+          children: `  \u26A0 routing rule: ${clipReason(message, (termWidth || 100) - 20)}`
+        })
+      }, `rule-problem:${message}`)),
+      results.map((r, idx) => /* @__PURE__ */ jsx12(DetailModel, {
+        result: r,
+        provW,
+        headerW,
+        layout,
+        maxTotalMs,
+        maxTokPerSec,
+        isLast: idx === results.length - 1
+      }, r.model))
+    ]
   });
 }
 function pickRepresentativeLink(result) {
@@ -62893,7 +63510,12 @@ function pickRepresentativeLink(result) {
       return { model: result.model, provider: link.displayName, timing: link.probe.timing };
     }
   }
-  return { model: result.model, provider: result.nativeProvider };
+  const first = result.links.find((link) => !link.dropped);
+  return {
+    model: result.model,
+    provider: first?.displayName ?? result.routingExplanation,
+    missing: first?.notProbed ? "not probed (native)" : first ? "no live route" : "no route"
+  };
 }
 function LeaderLiveRow({
   row,
@@ -63167,7 +63789,7 @@ function LeaderboardView({
           }),
           /* @__PURE__ */ jsx12("span", {
             fg: C.dim,
-            children: " \u2014 no live route"
+            children: ` \u2014 ${row.missing}`
           })
         ]
       }, `lb-na:${row.model}`))
@@ -63295,7 +63917,7 @@ function ProbeApp({
       isDone ? /* @__PURE__ */ jsx12(TabBar, {
         activeTab: state.activeTab
       }) : null,
-      groups.length > 0 ? /* @__PURE__ */ jsxs9(Fragment6, {
+      groups.length > 0 || state.results.length > 0 ? /* @__PURE__ */ jsxs9(Fragment6, {
         children: [
           showSummary && /* @__PURE__ */ jsx12("box", {
             flexDirection: "column",
@@ -63347,7 +63969,9 @@ function ProbeApp({
 }
 var ANIM_FRAMES2, TIMELINE_BAR_FULL = 24, TIMELINE_BAR_NARROW = 12, TOK_BAR_FULL = 14, TOTAL_COL = 7, ELAPSED_COL = 11, STAGE_NUM_W2 = 6, BREAKDOWN_COL, TOK_VALUE_COL = 7, TRACK_CHAR = "\xB7", BAR_FILL = "\u2588", BANNER_ROWS = 7, SCROLL_HINT_ROWS = 1, LEGEND_ROWS = 2, MIN_LIST_H = 4, TAB_BAR_ROWS = 2;
 var init_probe_tui_app = __esm(() => {
+  init_native_route();
   init_probe_live();
+  init_probe_runner();
   init_theme_mode();
   init_useAnimationFrame();
   init_theme2();
@@ -63677,8 +64301,7 @@ import {
   mkdirSync as mkdirSync19,
   readFileSync as readFileSync32,
   readdirSync as readdirSync7,
-  unlinkSync as unlinkSync8,
-  writeFileSync as writeFileSync20
+  unlinkSync as unlinkSync8
 } from "fs";
 import { homedir as homedir36 } from "os";
 import { dirname as dirname13, join as join42 } from "path";
@@ -63902,13 +64525,10 @@ async function parseArgs(args) {
         process.exit(1);
       }
       config.profile = profileArg;
-    } else if (arg === "--default-provider") {
-      const dpArg = args[++i];
-      if (!dpArg) {
-        console.error("--default-provider requires a provider name");
-        process.exit(1);
+    } else if (arg === "--default-provider" || arg.startsWith("--default-provider=")) {
+      if (arg === "--default-provider" && i + 1 < args.length && !args[i + 1].startsWith("-")) {
+        i++;
       }
-      config.defaultProvider = dpArg;
     } else if (arg === "--anthropic-api-billing") {
       config.anthropicApiBilling = true;
     } else if (arg === "--classifier-model") {
@@ -64165,28 +64785,6 @@ Usage:  claudish --models --provider <slug>`);
       config.modelSubagent = profileModels.subagent;
     }
   }
-  try {
-    const fileConfigForResolver = loadConfig();
-    const resolved = resolveDefaultProvider({
-      cliFlag: config.defaultProvider,
-      config: fileConfigForResolver,
-      env: process.env
-    });
-    config.resolvedDefaultProvider = resolved;
-    if (resolved.legacyAutoPromoted && !config.quiet) {
-      const markerFile = join42(homedir36(), ".claudish", ".legacy-litellm-hint-shown");
-      if (!existsSync32(markerFile)) {
-        const hint = buildLegacyHint(resolved);
-        if (hint) {
-          console.error(hint);
-        }
-        try {
-          mkdirSync19(dirname13(markerFile), { recursive: true });
-          writeFileSync20(markerFile, new Date().toISOString(), "utf-8");
-        } catch {}
-      }
-    }
-  } catch {}
   if (config.proOnUltracode === undefined) {
     const envVal = process.env.CLAUDISH_PRO_ON_ULTRACODE;
     if (envVal !== undefined) {
@@ -64428,7 +65026,7 @@ async function printRecommendedModels(jsonOutput, forceUpdate) {
   const { flagship, fast } = groupRecommendedModels(doc.models);
   const providerByName = new Map(BUILTIN_PROVIDERS.map((p) => [p.name, p]));
   const getNativePrefix = (firebaseSlug) => {
-    const canonical = FIREBASE_SLUG_TO_PROVIDER_NAME[firebaseSlug];
+    const canonical = nativeProviderForVendor(firebaseSlug);
     if (!canonical)
       return null;
     const def = providerByName.get(canonical);
@@ -64530,204 +65128,62 @@ async function printVersion() {
   console.log("");
 }
 async function probeModelRouting(models, jsonOutput, options = { live: true, timeoutMs: 40000 }) {
-  const userRoutingKeys = new Set([
-    ...Object.keys(loadConfig().routing ?? {}),
-    ...Object.keys(loadLocalConfig()?.routing ?? {})
-  ]);
   function credentialHintFrom(provenance, envVar) {
     if (provenance?.effectiveLabel)
       return provenance.effectiveSource;
     return envVar;
   }
-  function credentialHintFor(provider, envVar, aliases) {
-    if (!envVar)
-      return;
-    return credentialHintFrom(resolveCredentialProvenance(provider, envVar, aliases), envVar);
-  }
-  function buildModelChain(modelInput) {
-    const parsed = parseModelSpec(modelInput);
-    const chain = (() => {
-      if (parsed.isExplicitProvider) {
-        return {
-          routes: [],
-          source: "direct",
-          matchedPattern: undefined
-        };
-      }
-      if (parsed.provider === "native-anthropic") {
-        const tier = claudeCodeTierAlias(parsed.model);
-        const tierEnv = {
-          opus: process.env[ENV.CLAUDISH_MODEL_OPUS] || process.env[ENV.ANTHROPIC_DEFAULT_OPUS_MODEL],
-          sonnet: process.env[ENV.CLAUDISH_MODEL_SONNET] || process.env[ENV.ANTHROPIC_DEFAULT_SONNET_MODEL],
-          haiku: process.env[ENV.CLAUDISH_MODEL_HAIKU] || process.env[ENV.ANTHROPIC_DEFAULT_HAIKU_MODEL]
-        };
-        const opusModel = tier ? tierEnv[tier] || latestAnthropicTierModelId(tier) || "claude-opus-5" : parsed.model;
-        return {
-          routes: [
-            {
-              provider: "native-anthropic",
-              modelSpec: opusModel,
-              displayName: tier ? `Claude Code (${tier})` : "Claude Code"
-            }
-          ],
-          source: "auto-chain",
-          matchedPattern: undefined
-        };
-      }
-      const routingRules = loadRoutingRules();
-      const matched = matchRoutingRule(parsed.model, routingRules);
-      if (matched) {
-        const matchedPattern = Object.keys(routingRules).find((k) => {
-          if (k === parsed.model)
-            return true;
-          if (k.includes("*")) {
-            const star = k.indexOf("*");
-            const prefix = k.slice(0, star);
-            const suffix = k.slice(star + 1);
-            return parsed.model.startsWith(prefix) && parsed.model.endsWith(suffix);
-          }
-          return false;
-        });
-        const isUserKey = !!matchedPattern && userRoutingKeys.has(matchedPattern);
-        return {
-          routes: buildRoutingChain(matched, parsed.model),
-          source: isUserKey ? "custom-rules" : "auto-chain",
-          matchedPattern
-        };
-      }
-      return {
-        routes: buildCatalogChain(parsed.model, loadConfig().defaultProvider).routes,
-        source: "auto-chain",
-        matchedPattern: undefined
-      };
-    })();
-    const chainDetails = chain.routes.map((route) => {
-      const keyInfo = API_KEY_MAP[route.provider];
-      const providerDef = getProviderByName(route.provider);
-      let hasCredentials = false;
-      let credentialHint;
-      let provenance;
-      if (route.provider === "native-anthropic") {
-        hasCredentials = !!process.env.ANTHROPIC_API_KEY;
-        if (!hasCredentials) {
-          credentialHint = "ANTHROPIC_API_KEY (required to probe Claude Code)";
-        }
-      } else if (providerDef?.isLocal) {
-        hasCredentials = isLocalProviderEnabled(route.provider);
-        if (!hasCredentials) {
-          credentialHint = "enable local provider in global config";
-        }
-      } else if (!keyInfo) {
-        hasCredentials = true;
-      } else if (!keyInfo.envVar) {
-        hasCredentials = true;
-      } else {
-        provenance = resolveCredentialProvenance(route.provider, keyInfo.envVar, keyInfo.aliases);
-        hasCredentials = provenance.hasValue;
-        if (!hasCredentials && keyInfo.aliases) {
-          hasCredentials = keyInfo.aliases.some((a) => !!process.env[a]);
-        }
-        if (!hasCredentials) {
-          credentialHint = credentialHintFrom(provenance, keyInfo.envVar);
-        }
-      }
-      return {
-        provider: route.provider,
-        displayName: route.displayName,
-        modelSpec: route.modelSpec,
-        hasCredentials,
-        credentialHint,
-        provenance,
-        probe: undefined
-      };
-    });
-    return { parsed, chain, chainDetails };
-  }
-  const probeCredentialReadiness = new Map;
-  async function credentialForProbe(provider) {
-    if (probeCredentialReadiness.has(provider))
-      return probeCredentialReadiness.get(provider);
-    const ready = provider === "native-anthropic" ? !!process.env.ANTHROPIC_API_KEY : await hasCredentialsForProvider(provider);
-    probeCredentialReadiness.set(provider, ready);
-    return ready;
-  }
-  async function prepareModelChain(modelInput) {
-    const result = buildModelChain(modelInput);
-    await Promise.all(result.chainDetails.map(async (link) => {
-      link.hasCredentials = await credentialForProbe(link.provider);
-      const keyInfo = API_KEY_MAP[link.provider];
-      if (keyInfo?.envVar)
-        link.provenance = resolveCredentialProvenance(link.provider, keyInfo.envVar, keyInfo.aliases);
-      link.credentialHint = link.hasCredentials ? undefined : link.provider === "native-anthropic" ? "ANTHROPIC_API_KEY (required to probe Claude Code)" : getProviderByName(link.provider)?.isLocal ? "enable local provider in global config" : credentialHintFrom(link.provenance, keyInfo?.envVar);
-    }));
-    if (result.chain.source === "direct")
-      await credentialForProbe(result.parsed.provider);
-    return result;
-  }
-  function buildRoutingExplanation(parsed, chain) {
-    if (parsed.provider === "native-anthropic") {
-      return "native passthrough \xB7 default Claude Code (Opus)";
-    }
-    if (chain.source === "direct") {
-      return `explicit \xB7 ${parsed.provider} (direct)`;
-    }
-    if (chain.source === "custom-rules" && chain.matchedPattern) {
-      return `custom-rules \xB7 matched \`${chain.matchedPattern}\``;
-    }
-    if (chain.source === "auto-chain") {
-      if (chain.matchedPattern && chain.matchedPattern !== "*") {
-        return `auto-chain \xB7 default rule \`${chain.matchedPattern}\``;
-      }
-      return "auto-chain \xB7 catch-all \u2192 openrouter";
+  const probeCredentials = {
+    hintFor(provider) {
+      if (getProviderByName(provider)?.isLocal)
+        return "enable local provider in global config";
+      const keyInfo = API_KEY_MAP[provider];
+      if (!keyInfo?.envVar)
+        return;
+      return credentialHintFrom(resolveCredentialProvenance(provider, keyInfo.envVar, keyInfo.aliases), keyInfo.envVar);
+    },
+    provenanceFor(provider) {
+      const keyInfo = API_KEY_MAP[provider];
+      return keyInfo?.envVar ? resolveCredentialProvenance(provider, keyInfo.envVar, keyInfo.aliases) : undefined;
     }
-    return chain.source;
-  }
-  function buildDirectChainEntry(parsed, directProbe) {
-    const providerDef = getProviderByName(parsed.provider);
-    const keyInfo = API_KEY_MAP[parsed.provider];
-    if (!providerDef && !keyInfo)
-      return [];
-    const hasCredentials = probeCredentialReadiness.get(parsed.provider) ?? false;
-    const provenance = keyInfo?.envVar ? resolveCredentialProvenance(parsed.provider, keyInfo.envVar, keyInfo.aliases) : undefined;
-    return [
-      {
-        provider: parsed.provider,
-        displayName: providerDef?.displayName ?? parsed.provider,
-        modelSpec: parsed.model,
-        hasCredentials,
-        credentialHint: !hasCredentials ? providerDef?.isLocal ? "enable local provider in global config" : credentialHintFrom(provenance, keyInfo?.envVar) : undefined,
-        provenance,
-        probe: directProbe
-      }
-    ];
+  };
+  async function explainForProbe(modelInput) {
+    const explanation = await explainRoute(modelInput);
+    const { chain, dropped } = probeChainFrom(explanation, probeCredentials);
+    const targets = probeTargets(explanation).map((target, i) => ({ target, link: chain[i] }));
+    return { modelInput, explanation, chain, dropped, targets };
   }
-  function buildResultLinks(parsed, chainDetails, directProbe) {
-    if (chainDetails.length === 0) {
-      const directProviderDef = getProviderByName(parsed.provider);
-      const directKeyInfo = API_KEY_MAP[parsed.provider];
-      const directHasCreds = probeCredentialReadiness.get(parsed.provider) ?? false;
-      return [
-        {
-          provider: parsed.provider,
-          displayName: directProviderDef?.displayName ?? parsed.provider,
-          modelId: parsed.model,
-          hasCredentials: directHasCreds,
-          credentialHint: !directHasCreds ? directProviderDef?.isLocal ? "enable local provider in global config" : credentialHintFor(parsed.provider, directKeyInfo?.envVar, directKeyInfo?.aliases) : undefined,
-          probe: directProbe
-        }
-      ];
-    }
-    return chainDetails.map((c) => ({
-      provider: c.provider,
-      displayName: c.displayName,
-      modelId: c.modelSpec.includes("@") ? c.modelSpec.slice(c.modelSpec.indexOf("@") + 1) : c.modelSpec,
-      hasCredentials: c.hasCredentials,
-      credentialHint: c.credentialHint,
-      probe: c.probe
+  function probeTarget(proxyUrl, target) {
+    return probeLink(proxyUrl, { provider: target.provider, modelSpec: target.probeSpec, hasCredentials: true }, options.timeoutMs).catch((e) => ({
+      state: "error",
+      latencyMs: 0,
+      errorMessage: String(e instanceof Error ? e.message : e)
     }));
   }
-  async function computeWiring(chainDetails, parsedModel) {
-    const firstReadyRoute = chainDetails.find((c) => c.hasCredentials);
+  function chainProbeOf(probe, wiring) {
+    const exp = probe.explanation;
+    const directProbe = exp.source === "explicit" ? probe.chain[0]?.probe : undefined;
+    return {
+      model: probe.modelInput,
+      nativeProvider: parseModelSpec(probe.modelInput).provider,
+      isExplicit: exp.source === "explicit",
+      routingSource: exp.source,
+      routingExplanation: routingFieldsFrom(exp).routingExplanation,
+      ...exp.via ? { via: exp.via } : {},
+      ...exp.matchedPattern !== undefined ? { matchedPattern: exp.matchedPattern } : {},
+      ...exp.ruleScope ? { ruleScope: exp.ruleScope } : {},
+      ...exp.catalog ? { catalog: exp.catalog } : {},
+      ...exp.fallbackWithheld ? { fallbackWithheld: exp.fallbackWithheld } : {},
+      outcome: exp.outcome,
+      warnings: exp.warnings,
+      chain: probe.chain,
+      dropped: probe.dropped,
+      ...directProbe ? { directProbe } : {},
+      ...wiring ? { wiring } : {}
+    };
+  }
+  async function computeWiring(chain, parsedModel) {
+    const firstReadyRoute = chain.find((c) => c.hasCredentials && !c.notProbed);
     if (!firstReadyRoute)
       return;
     const providerName = firstReadyRoute.provider;
@@ -64808,52 +65264,16 @@ async function probeModelRouting(models, jsonOutput, options = { live: true, tim
     try {
       const results = [];
       for (const modelInput of models) {
-        const { parsed, chain, chainDetails } = await prepareModelChain(modelInput);
-        let directProbeResult;
-        if (liveProxy && chain.source === "direct") {
-          const directKeyInfo = API_KEY_MAP[parsed.provider];
-          const directProviderDef = getProviderByName(parsed.provider);
-          const directHasCreds = await credentialForProbe(parsed.provider);
-          const directCredentialHint = directProviderDef?.isLocal && !directHasCreds ? "enable local provider in global config" : credentialHintFor(parsed.provider, directKeyInfo?.envVar, directKeyInfo?.aliases);
-          directProbeResult = await probeProviderRoute(liveProxy.url, {
-            provider: parsed.provider,
-            modelSpec: modelInput,
-            hasCredentials: directHasCreds,
-            credentialHint: directCredentialHint
-          }, options.timeoutMs).catch((e) => ({
-            state: "error",
-            latencyMs: 0,
-            errorMessage: String(e instanceof Error ? e.message : e)
-          }));
-        }
+        const probe = await explainForProbe(modelInput);
         if (liveProxy) {
-          const probes = await Promise.all(chainDetails.map((link) => {
-            return probeProviderRoute(liveProxy.url, {
-              provider: link.provider,
-              modelSpec: link.modelSpec,
-              hasCredentials: link.hasCredentials,
-              credentialHint: link.credentialHint
-            }, options.timeoutMs).catch((e) => ({
-              state: "error",
-              latencyMs: 0,
-              errorMessage: String(e instanceof Error ? e.message : e)
-            }));
-          }));
-          for (let i = 0;i < chainDetails.length; i++) {
-            chainDetails[i].probe = probes[i];
-          }
+          const url = liveProxy.url;
+          const probes = await Promise.all(probe.targets.map(({ target }) => probeTarget(url, target)));
+          probe.targets.forEach(({ link }, i) => {
+            link.probe = probes[i];
+          });
         }
-        const wiring = await computeWiring(chainDetails, parsed.model);
-        results.push({
-          model: modelInput,
-          nativeProvider: parsed.provider,
-          isExplicit: parsed.isExplicitProvider,
-          routingSource: chain.source,
-          matchedPattern: chain.matchedPattern,
-          chain: chainDetails.length > 0 ? chainDetails : buildDirectChainEntry(parsed, directProbeResult),
-          directProbe: directProbeResult,
-          wiring
-        });
+        const wiring = await computeWiring(probe.chain, probe.explanation.routedModel);
+        results.push(chainProbeOf(probe, wiring));
       }
       console.log(JSON.stringify(results, null, 2));
     } finally {
@@ -64897,9 +65317,6 @@ async function probeModelRouting(models, jsonOutput, options = { live: true, tim
   };
   let liveProxy = null;
   try {
-    addStep("Loading routing rules", "running");
-    loadRoutingRules();
-    updateStep("Loading routing rules", "done");
     if (options.live) {
       addStep("Starting probe proxy", "running");
       try {
@@ -64914,122 +65331,99 @@ async function probeModelRouting(models, jsonOutput, options = { live: true, tim
       }
     }
     addStep("Resolving routing chains", "running");
-    const modelChains = [];
+    const modelProbes = [];
     for (const modelInput of models) {
-      const { parsed, chain, chainDetails } = await prepareModelChain(modelInput);
-      modelChains.push({ modelInput, parsed, chain, chainDetails });
+      modelProbes.push(await explainForProbe(modelInput));
     }
     updateStep("Resolving routing chains", "done");
-    const directProbeResults = new Map;
-    if (liveProxy) {
-      const allLinks = [];
-      for (const { modelInput, parsed, chain, chainDetails } of modelChains) {
-        if (chain.source === "direct") {
-          const directKeyInfo = API_KEY_MAP[parsed.provider];
-          const directProviderDef = getProviderByName(parsed.provider);
-          const directHasCreds = await credentialForProbe(parsed.provider);
-          const directCredentialHint = directProviderDef?.isLocal && !directHasCreds ? "enable local provider in global config" : credentialHintFor(parsed.provider, directKeyInfo?.envVar, directKeyInfo?.aliases);
-          allLinks.push({
-            id: `${modelInput}:direct`,
-            displayName: parsed.provider,
-            modelSpec: modelInput,
-            provider: parsed.provider,
-            pinnedSpec: modelInput,
-            hasCredentials: directHasCreds,
-            credentialHint: directCredentialHint,
-            chainDetail: null,
-            isDirect: true,
-            modelInput
+    const liveRows = [];
+    const rows = [];
+    for (const probe of modelProbes) {
+      const model = probe.modelInput;
+      probe.targets.forEach(({ target, link }, i) => {
+        const id = `${model}:${i}:${target.provider}`;
+        if (liveProxy) {
+          liveRows.push({ id, target, link });
+          rows.push({
+            id,
+            model,
+            displayName: target.displayName,
+            modelSpec: target.probeSpec,
+            status: "waiting"
           });
-        }
-        for (const link of chainDetails) {
-          const pinnedSpec = pinProbeModelSpec(link);
-          allLinks.push({
-            id: `${modelInput}:${link.provider}`,
-            displayName: link.displayName,
-            modelSpec: pinnedSpec,
-            provider: link.provider,
-            pinnedSpec,
-            hasCredentials: link.hasCredentials,
-            credentialHint: link.credentialHint,
-            chainDetail: link,
-            isDirect: false,
-            modelInput
+        } else {
+          rows.push({
+            id,
+            model,
+            displayName: target.displayName,
+            modelSpec: target.probeSpec,
+            status: "not-probed",
+            tone: "ready",
+            note: `\u25CB ${link.label} \xB7 not probed (--no-probe)`
           });
         }
-      }
-      setLinks(allLinks.map((l) => ({
-        id: l.id,
-        model: l.modelInput,
-        displayName: l.displayName,
-        modelSpec: l.modelSpec,
-        status: "waiting"
-      })));
-      const probePromises = allLinks.map(async (link) => {
-        updateLink(link.id, { status: "probing", startTime: Date.now() });
-        const result = await probeProviderRoute(liveProxy.url, {
-          provider: link.provider,
+      });
+      for (const link of probe.chain) {
+        if (!link.notProbed)
+          continue;
+        rows.push({
+          id: `${model}:native`,
+          model,
+          displayName: link.displayName,
           modelSpec: link.modelSpec,
-          hasCredentials: link.hasCredentials,
-          credentialHint: link.credentialHint
-        }, options.timeoutMs).catch((e) => ({
-          state: "error",
-          latencyMs: 0,
-          errorMessage: String(e instanceof Error ? e.message : e)
-        }));
+          status: "not-probed",
+          tone: "native",
+          note: `\u25D0 native \u2014 ${NATIVE_NOT_PROBED}`
+        });
+      }
+      probe.dropped.forEach((entry, i) => {
+        rows.push({
+          id: `${model}:dropped:${i}:${entry.provider}`,
+          model,
+          displayName: entry.displayName,
+          modelSpec: entry.wireId,
+          status: "not-probed",
+          tone: "dropped",
+          note: `\u2013 ${describeDropped(entry.outcome, entry.credentialHint)}`
+        });
+      });
+    }
+    setLinks(rows);
+    if (liveProxy) {
+      const url = liveProxy.url;
+      await Promise.all(liveRows.map(async ({ id, target, link }) => {
+        updateLink(id, { status: "probing", startTime: Date.now() });
+        const result = await probeTarget(url, target);
         if (result.state === "live") {
-          updateLink(link.id, {
-            status: "live",
-            endTime: Date.now(),
-            timing: result.timing
-          });
+          updateLink(id, { status: "live", endTime: Date.now(), timing: result.timing });
         } else {
-          updateLink(link.id, {
+          updateLink(id, {
             status: "failed",
             endTime: Date.now(),
             error: describeProbeState(result)
           });
         }
-        if (link.isDirect) {
-          directProbeResults.set(link.modelInput, result);
-        } else if (link.chainDetail) {
-          link.chainDetail.probe = result;
-        }
-      });
-      await Promise.all(probePromises);
+        link.probe = result;
+      }));
     }
     const isLiveProbe = !!liveProxy;
     const printable = [];
     const results = [];
-    for (const { modelInput, parsed, chain, chainDetails } of modelChains) {
-      const wiring = await computeWiring(chainDetails, parsed.model);
-      const directProbe = directProbeResults.get(modelInput);
+    for (const probe of modelProbes) {
+      const wiring = await computeWiring(probe.chain, probe.explanation.routedModel);
+      const fields = routingFieldsFrom(probe.explanation);
       printable.push({
-        model: modelInput,
-        nativeProvider: parsed.provider,
-        isExplicit: parsed.isExplicitProvider,
-        routingSource: chain.source,
-        matchedPattern: chain.matchedPattern,
-        chain: chainDetails.map((c) => ({
-          provider: c.provider,
-          displayName: c.displayName,
-          modelSpec: c.modelSpec,
-          hasCredentials: c.hasCredentials,
-          credentialHint: c.credentialHint,
-          provenance: c.provenance,
-          probe: c.probe
-        })),
-        directProbe,
+        model: probe.modelInput,
+        ...fields,
+        chain: probe.chain,
+        dropped: probe.dropped,
         wiring
       });
       results.push({
-        model: modelInput,
-        nativeProvider: parsed.provider,
-        isExplicit: parsed.isExplicitProvider,
-        routingSource: chain.source,
-        matchedPattern: chain.matchedPattern,
-        routingExplanation: buildRoutingExplanation(parsed, chain),
-        links: buildResultLinks(parsed, chainDetails, directProbe),
+        model: probe.modelInput,
+        isExplicit: probe.explanation.source === "explicit",
+        ...fields,
+        links: resultLinksFrom(probe.chain, probe.dropped),
         wiring
       });
     }
@@ -65064,6 +65458,18 @@ async function probeModelRouting(models, jsonOutput, options = { live: true, tim
     setStderrQuiet(false);
   }
 }
+function providerShortcutRows(providers = BUILTIN_PROVIDERS) {
+  const pickable = providers.filter(isPickableProvider);
+  const ordered = [
+    ...pickable.filter((def) => !def.isLocal),
+    ...pickable.filter((def) => def.isLocal)
+  ];
+  return ordered.map((def) => ({
+    shortcuts: [...def.shortcuts],
+    displayName: def.displayName,
+    kind: def.isLocal ? "local" : def.tier ? TIER_LABEL[def.tier] : ""
+  }));
+}
 function printHelp2() {
   const useColor = !!process.stdout.isTTY && !process.env.NO_COLOR;
   const A = cliAnsi();
@@ -65076,6 +65482,12 @@ function printHelp2() {
   const magenta = c(A.MAGENTA);
   const blue = c(A.BLUE);
   const h = (title) => bold(cyan(`\u258C ${title}`));
+  const shortcutRows = providerShortcutRows();
+  const shortcutsOf = (row) => row.shortcuts.join(", ");
+  const shortcutWidth = Math.max(...shortcutRows.map((row) => shortcutsOf(row).length));
+  const nameWidth = Math.max(...shortcutRows.map((row) => row.displayName.length));
+  const shortcutTable = shortcutRows.map((row) => `    ${magenta(shortcutsOf(row).padEnd(shortcutWidth))} ${dim("->")} ${row.displayName.padEnd(nameWidth)}  ${dim(row.kind)}`).join(`
+`);
   console.log(`
 ${bold("claudish")} ${dim("\xB7")} Run Claude Code with any AI model
 ${dim("OpenRouter \xB7 Gemini \xB7 OpenAI \xB7 xAI \xB7 MiniMax \xB7 Kimi \xB7 GLM \xB7 Z.AI \xB7 Sakana \xB7 Poe \xB7 LiteLLM \xB7 Local")}
@@ -65088,60 +65500,29 @@ ${h("USAGE")}
 
 ${h("MODEL ROUTING")}
   ${bold("New syntax:")} ${yellow("provider@model[:concurrency]")}
-    ${magenta("google@gemini-3-pro")}              ${dim("Direct Google API (explicit)")}
-    ${magenta("openrouter@google/gemini-3-pro")}   ${dim("OpenRouter (explicit)")}
-    ${magenta("oai@gpt-5.3")}                      ${dim("Direct OpenAI API (shortcut)")}
-    ${magenta("ollama@llama3.2:3")}                ${dim("Local Ollama, 3 concurrent requests")}
-    ${magenta("ollama@llama3.2:0")}                ${dim("Local Ollama, no limits")}
-
-  ${bold("Provider shortcuts:")}
-    ${magenta("g, gemini")}      ${dim("->")} Google Gemini       ${dim("google@gemini-3-pro")}
-    ${magenta("oai")}            ${dim("->")} OpenAI Direct       ${dim("oai@gpt-5.3")}
-    ${magenta("cx, codex")}      ${dim("->")} OpenAI Codex        ${dim("cx@gpt-5.3 (Responses API)")}
-    ${magenta("or")}             ${dim("->")} OpenRouter          ${dim("or@openai/gpt-5.3")}
-    ${magenta("x-ai, xai, grok")} ${dim("->")} xAI / Grok         ${dim("x-ai@grok-3")}
-    ${magenta("mm, mmax")}       ${dim("->")} MiniMax Direct      ${dim("mm@MiniMax-M2.1")}
-    ${magenta("mmc")}            ${dim("->")} MiniMax Coding      ${dim("mmc@MiniMax-M2.1")}
-    ${magenta("kimi, moon")}     ${dim("->")} Kimi Direct         ${dim("kimi@kimi-k2-thinking-turbo")}
-    ${magenta("kc")}             ${dim("->")} Kimi Coding         ${dim("kc@kimi-k2-thinking-turbo")}
-    ${magenta("glm, zhipu")}     ${dim("->")} GLM Direct          ${dim("glm@glm-4.7")}
-    ${magenta("gc")}             ${dim("->")} GLM Coding          ${dim("gc@glm-4.7")}
-    ${magenta("z-ai, zai")}      ${dim("->")} Z.AI Direct         ${dim("z-ai@glm-4.7")}
-    ${magenta("oc, llama, lc, meta")} ${dim("->")} OllamaCloud    ${dim("oc@llama-3.1")}
-    ${magenta("zen")}            ${dim("->")} OpenCode Zen        ${dim("zen@grok-code")}
-    ${magenta("zengo, zgo")}     ${dim("->")} OpenCode Zen Go     ${dim("zengo@grok-code")}
-    ${magenta("v, vertex")}      ${dim("->")} Vertex AI           ${dim("v@gemini-2.5-flash")}
-    ${magenta("poe")}            ${dim("->")} Poe                 ${dim("poe@GPT-4o")}
-    ${magenta("litellm, ll")}    ${dim("->")} LiteLLM             ${dim("ll@gpt-4o (needs LITELLM_BASE_URL)")}
-    ${magenta("ds")}             ${dim("->")} DeepSeek            ${dim("ds@deepseek-chat")}
-    ${magenta("sakana, fugu")}   ${dim("->")} Sakana Fugu         ${dim("fugu@fugu-ultra")}
-    ${magenta("sc")}             ${dim("->")} Sakana Subscription ${dim("sc@fugu-ultra")}
-    ${magenta("ollama")}         ${dim("->")} Ollama (local)      ${dim("ollama@llama3.2")}
-    ${magenta("lms, lmstudio")}  ${dim("->")} LM Studio (local)   ${dim("lms@qwen")}
-    ${magenta("vllm")}           ${dim("->")} vLLM (local)        ${dim("vllm@model")}
-    ${magenta("mlx")}            ${dim("->")} MLX (local)         ${dim("mlx@model")}
-
-  ${bold("Native auto-detection")} ${dim("(when no provider specified):")}
-    ${yellow("google/*, gemini-*")}      ${dim("->")} Google API
-    ${yellow("openai/*, gpt-*, o1-*")}   ${dim("->")} OpenAI API
-    ${yellow("x-ai/*, grok-*")}          ${dim("->")} xAI
-    ${yellow("meta-llama/*, llama-*")}   ${dim("->")} OllamaCloud
-    ${yellow("minimax/*, abab-*")}       ${dim("->")} MiniMax API
-    ${yellow("moonshot/*, kimi-*")}      ${dim("->")} Kimi API
-    ${yellow("zhipu/*, glm-*")}          ${dim("->")} GLM API
-    ${yellow("sakana/*, fugu-*")}        ${dim("->")} Sakana Fugu
-    ${yellow("poe:*")}                   ${dim("->")} Poe
-    ${yellow("anthropic/*, claude-*")}   ${dim("->")} Native Anthropic
-    ${yellow("(unknown vendor/)")}       ${dim("->")} Error (use openrouter@vendor/model)
-
-  ${dim("A defaultProvider (config / --default-provider) catches bare names that match no rule.")}
+    ${magenta("google@<model>")}                   ${dim("Direct Google API (explicit)")}
+    ${magenta("openrouter@<vendor>/<model>")}      ${dim("OpenRouter (explicit)")}
+    ${magenta("oai@<model>")}                      ${dim("Direct OpenAI API (shortcut)")}
+    ${magenta("ollama@<model>:3")}                 ${dim("Local Ollama, 3 concurrent requests")}
+    ${magenta("ollama@<model>:0")}                 ${dim("Local Ollama, no limits")}
+
+  ${bold("Provider shortcuts:")} ${dim("(<shortcut>@<model>)")}
+${shortcutTable}
+
+  ${bold("Bare names")} are routed from the cloud models catalog: subscriptions first, then the vendor's own
+  API, then gateways, then the fallback. ${green("claudish --probe")} ${yellow("<model>")} shows the chain a request uses.
+
+  ${dim("A defaultProvider (--default-provider / CLAUDISH_DEFAULT_PROVIDER / config) is the last hop for")}
+  ${dim('bare names that match no rule. "" disables it.')}
+  ${dim("Claude Code's own names (opus, sonnet, claude-*) are served on Claude Code's own auth.")}
 
 ${h("OPTIONS")}
   ${green("-i, --interactive")}        Run in interactive mode (default when no prompt given)
   ${green("-m, --model")} ${yellow("<model>")}      Model to use (required for single-shot mode)
   ${green("--profile")} ${yellow("<name>")}         Use named profile for model mapping (default profile if omitted)
-  ${green("--default-provider")} ${yellow("<name>")} Fallback provider for bare model names (builtin or customEndpoints key)
-                           ${dim("Precedence: this flag > CLAUDISH_DEFAULT_PROVIDER env > config.json")}
+  ${green("--default-provider")} ${yellow("<name>")} Fallback provider for bare model names (claudish provider or customEndpoints key)
+                           ${dim('"" disables it. Precedence: this flag > CLAUDISH_DEFAULT_PROVIDER env > config.json')}
+                           ${dim("(the global config or the --config file; a project .claudish.json is not read)")}
   ${green("--anthropic-api-billing")}  Use your real ANTHROPIC_API_KEY for native Claude models
                            ${dim("(metered API billing). Default: the key is hidden so Claude Code")}
                            ${dim("uses your claude.ai subscription. Env: CLAUDISH_ANTHROPIC_API_BILLING")}
@@ -65192,9 +65573,9 @@ ${h("MODEL DISCOVERY")}
   ${green("-s, --models-search")} ${yellow("<query>")}             Fuzzy search: id, brand synonyms (chatgpt,
                                           ${dim("claude, grok), gateways (zen, oc, codex), caps")}
   ${green("--models-top")}                          Curated recommended models (flagship + fast)
-  ${green("--probe")} ${yellow("<models...>")}                    Probe each provider in the fallback chain with
+  ${green("--probe")} ${yellow("<models...>")}                    Show each model's routing chain and send each hop
                                           ${dim("a real 1-token request (may incur tiny cost)")}
-  ${green("--no-probe")}                            Skip live requests, show static chain only
+  ${green("--no-probe")}                            Show the routing chain without the 1-token requests
   ${green("--probe-timeout")} ${yellow("<secs>")}                 Per-link timeout for live probes (default: 40)
   ${green("--models-refresh")}                      Force refresh the slim model catalog from Firebase
   ${green("--models-skip-update")}                  Skip the launcher catalog warm step (offline)
@@ -65202,7 +65583,7 @@ ${h("MODEL DISCOVERY")}
 
 ${h("TEAM MODE")}
   ${green("--team")} ${yellow("<models>")}           Run multiple models in parallel (comma-separated)
-                           ${dim('Example: --team minimax-m2.5,kimi-k2.5 "prompt"')}
+                           ${dim('Example: --team <model>,<model> "prompt"')}
   ${green("--mode")} ${yellow("<mode>")}             Team mode: default (grid), interactive, json
   ${green("-f, --file")} ${yellow("<path>")}         Read prompt from file (use with --team or single-shot)
 
@@ -65240,7 +65621,7 @@ ${h("1PASSWORD")} ${dim("(SDK-based \u2014 no op CLI needed for secrets)")}
   ${green("--op")} ${yellow("<glob> --list")}        Preview which fields a glob would import (names only)
   ${green("--op")} ${yellow("<glob>")} ${yellow("[...args]")}      Resolve a glob into env vars, then run a session
                            ${dim("Inline op import requires a GLOB (self-names via field labels)")}
-                           ${dim('Example: claudish --op "op://Jack/Keys/**" --model gpt-4o "task"')}
+                           ${dim('Example: claudish --op "op://Jack/Keys/**" --model <model> "task"')}
   ${green("--op-env")} ${yellow("<id>")}             Load a 1Password Environment (highest-priority source)
   ${dim("Persistent setup (single refs, sets, environments, account): claudish config -> 1Password tab")}
 
@@ -65257,17 +65638,17 @@ ${h("MACOS KEYCHAIN")} ${dim("(local, encrypted at rest, no desktop-app handshak
 
 ${h("CLAUDE CODE FLAG PASSTHROUGH")}
   ${dim("Any unrecognized flag is forwarded to Claude Code. Claudish flags can appear in any order.")}
-    ${green("claudish")} --model grok ${yellow("--agent test")} ${yellow('"task"')}        ${dim("# --agent passes through")}
-    ${green("claudish")} --model grok ${yellow("--effort high")} --stdin ${yellow('"task"')}  ${dim("# --effort passes, --stdin stays")}
-    ${green("claudish")} --model grok ${yellow("--permission-mode plan")} -i   ${dim("# works in interactive too")}
+    ${green("claudish")} --model ${yellow("<model>")} ${yellow("--agent test")} ${yellow('"task"')}     ${dim("# --agent passes through")}
+    ${green("claudish")} --model ${yellow("<model>")} ${yellow("--effort high")} --stdin ${yellow('"task"')}  ${dim("# --effort passes, --stdin stays")}
+    ${green("claudish")} --model ${yellow("<model>")} ${yellow("--permission-mode plan")} -i  ${dim("# works in interactive too")}
   ${dim("Use -- when a Claude Code flag value starts with '-':")}
-    ${green("claudish")} --model grok ${green("--")} ${yellow('--system-prompt "-verbose mode" "task"')}
+    ${green("claudish")} --model ${yellow("<model>")} ${green("--")} ${yellow('--system-prompt "-verbose mode" "task"')}
 
 ${h("CUSTOM MODELS & ENDPOINTS")}
-  ${dim("Claudish accepts ANY valid model ID from the Firebase catalog, even if not in --models:")}
-    ${green("claudish")} --model ${yellow("openrouter@your_provider/custom-model-123")} ${yellow('"task"')}
+  ${dim("An explicit provider@ takes any model id, including one --models does not list:")}
+    ${green("claudish")} --model ${yellow("openrouter@<vendor>/<model>")} ${yellow('"task"')}
   ${dim("Named custom endpoints live in ~/.claudish/config.json under 'customEndpoints' and route via @:")}
-    ${green("claudish")} --model ${yellow("my-vllm@llama3.1-70b")} ${yellow('"task"')}
+    ${green("claudish")} --model ${yellow("my-vllm@<model>")} ${yellow('"task"')}
 
 ${h("MODES")}
   ${green("\u2022")} ${bold("Interactive")} ${dim("(default):")} shows model selector, starts a persistent session
@@ -65330,8 +65711,8 @@ ${h("ENVIRONMENT VARIABLES")}
   ${blue("MLX_BASE_URL")}                    MLX server ${dim("(default: http://127.0.0.1:8080)")}
 
   ${bold("Claudish settings:")}
-  ${blue("CLAUDISH_MODEL")}                  Default model ${dim("(default: openai/gpt-5.3)")}
-  ${blue("CLAUDISH_DEFAULT_PROVIDER")}       Fallback provider for bare names ${dim("(see --default-provider)")}
+  ${blue("CLAUDISH_MODEL")}                  Default model ${dim("(--model overrides it; ANTHROPIC_MODEL is read when unset)")}
+  ${blue("CLAUDISH_DEFAULT_PROVIDER")}       Fallback provider for bare names; empty disables it ${dim("(see --default-provider)")}
   ${blue("CLAUDISH_PORT")}                   Default proxy port
   ${blue("CLAUDISH_CONTEXT_WINDOW")}         Override context window size
   ${blue("CLAUDISH_DIAG_MODE")}              Diagnostic output: auto / logfile / off
@@ -65354,24 +65735,24 @@ ${h("EXAMPLES")}
   ${green("claudish")} --free                          ${dim("# only FREE models")}
 
   ${dim("# Explicit provider routing")}
-  ${green("claudish")} --model ${magenta("google@gemini-3-pro")} ${yellow('"implement auth"')}
-  ${green("claudish")} --model ${magenta("oai@gpt-5.3")} ${yellow('"add tests for login"')}
-  ${green("claudish")} --model ${magenta("openrouter@deepseek/deepseek-r1")} ${yellow('"unknown vendor"')}
+  ${green("claudish")} --model ${magenta("google@<model>")} ${yellow('"implement auth"')}
+  ${green("claudish")} --model ${magenta("oai@<model>")} ${yellow('"add tests for login"')}
+  ${green("claudish")} --model ${magenta("openrouter@<vendor>/<model>")} ${yellow('"any vendor via OpenRouter"')}
 
-  ${dim("# Native auto-detection (provider inferred from model name)")}
-  ${green("claudish")} --model ${yellow("gpt-4o")} ${yellow('"routes to OpenAI"')}
-  ${green("claudish")} --model ${yellow("gemini-2.5-pro")} ${yellow('"routes to Google"')}
+  ${dim("# Bare name: routed from the cloud models catalog")}
+  ${green("claudish")} --probe ${yellow("<model>")}                  ${dim("# show the chain it gets")}
+  ${green("claudish")} --model ${yellow("<model>")} ${yellow('"implement auth"')}
 
   ${dim("# Per-role model mapping")}
-  ${green("claudish")} --model-opus ${magenta("oai@gpt-5.3")} --model-sonnet ${magenta("google@gemini-3-pro")}
+  ${green("claudish")} --model-opus ${magenta("oai@<model>")} --model-sonnet ${magenta("google@<model>")}
 
   ${dim("# stdin for large prompts (diffs, code review)")}
-  ${dim("git diff |")} ${green("claudish")} --stdin --model ${magenta("oai@gpt-5.3")} ${yellow('"Review these changes"')}
+  ${dim("git diff |")} ${green("claudish")} --stdin --model ${magenta("oai@<model>")} ${yellow('"Review these changes"')}
 
   ${dim("# Local models with concurrency control")}
-  ${green("claudish")} --model ${magenta("ollama@llama3.2:3")} ${yellow('"3 concurrent requests"')}
-  ${green("claudish")} --model ${magenta("lms@qwen2.5-coder")} ${yellow('"LM Studio shortcut"')}
-  ${green("claudish")} --model ${yellow('"http://localhost:8000/mistral"')} ${yellow('"any OpenAI-compatible URL"')}
+  ${green("claudish")} --model ${magenta("ollama@<model>:3")} ${yellow('"3 concurrent requests"')}
+  ${green("claudish")} --model ${magenta("lms@<model>")} ${yellow('"LM Studio shortcut"')}
+  ${green("claudish")} --model ${yellow('"http://localhost:8000/<model>"')} ${yellow('"any OpenAI-compatible URL"')}
 
   ${dim("# Autonomous (no prompts, no sandbox) \u2014 use with caution")}
   ${green("claudish")} -y --dangerous ${yellow('"refactor entire codebase"')}
@@ -65492,19 +65873,21 @@ var init_cli = __esm(() => {
   init_logger();
   init_model_loader();
   init_model_selector();
+  init_probe_chain();
   init_probe_results_printer();
   init_probe_tui_runtime();
   init_profile_config();
   init_api_key_map();
   init_api_key_provenance();
-  init_catalog_client();
   init_claude_code_aliases();
   init_endpoint_registration();
   init_model_parser();
+  init_native_route();
   init_probe_live();
   init_probe_runner();
   init_provider_definitions();
   init_provider_slug_resolve();
+  init_route_candidates();
   init_routing_rules();
   init_settings();
   init_ansi();
@@ -67929,7 +68312,7 @@ function ProfileDetail({ config, profileIndex }) {
                   }),
                   /* @__PURE__ */ jsx20("span", {
                     fg: C.dim,
-                    children: " \u2014 uses routing table"
+                    children: " \u2014 calculated per model \xB7 Routing \u2192 p shows the chain"
                   }),
                   /* @__PURE__ */ jsx20("span", {
                     fg: C.yellow,
@@ -68396,7 +68779,7 @@ function ProfilesContent({
                   }),
                   /* @__PURE__ */ jsx21("span", {
                     fg: C.fgMuted,
-                    children: "\u2014 uses routing table \xB7 "
+                    children: "\u2014 calculated per model (Routing \u2192 p) \xB7 "
                   }),
                   /* @__PURE__ */ jsxs17("span", {
                     fg: C.green,
@@ -69244,14 +69627,158 @@ function deriveProbeOutcome(mode, results) {
 // src/tui/components/RoutingContent.tsx
 import { useEffect as useEffect10, useRef as useRef7 } from "react";
 import { jsx as jsx24, jsxs as jsxs20, Fragment as Fragment14 } from "@opentui/react/jsx-runtime";
+function rowStatusView(entry) {
+  switch (entry.status) {
+    case "unverified":
+      return { icon: "\u25D0", color: C.cyan, text: "native \u2014 not probed" };
+    case "success":
+      return {
+        icon: "\u25CF",
+        color: C.green,
+        text: entry.ms !== undefined ? `${entry.ms}ms` : "success"
+      };
+    case "failed":
+      return { icon: "\u2717", color: C.red, text: entry.error ?? "failed" };
+    case "testing":
+      return { icon: "\u25CC", color: C.yellow, text: "testing..." };
+    case "dropped":
+      return {
+        icon: "\u25CB",
+        color: entry.outcome === "credential-unreadable" ? C.yellow : C.dim,
+        text: entry.outcome ? `dropped \xB7 ${DROPPED_TEXT[entry.outcome]}` : "dropped"
+      };
+    case "skipped":
+      return { icon: "\xB7", color: C.dim, text: "not reached" };
+    case "no_key":
+      return { icon: "\u25CB", color: C.dim, text: "not configured, skipping" };
+    case "pending":
+      return { icon: "\u25CB", color: C.dim, text: "waiting" };
+  }
+}
+function hintLines(hint) {
+  if (!hint)
+    return [];
+  return hint.split(`
+`).filter((text) => text.trim().length > 0).map((text, n) => ({ id: `hint-${n}`, text }));
+}
 function chainStr(chain) {
   return chain.join(" \u2192 ");
 }
+function ruleChainCell(chain, selected) {
+  if (chain.length === 0)
+    return { text: "no route", fg: C.yellow };
+  return { text: chainStr(chain), fg: selected ? C.cyan : C.fgMuted };
+}
+function routingHeaderLines({
+  globalRules,
+  localRules,
+  resolved
+}) {
+  const catchAll = { ...globalRules, ...localRules }["*"];
+  if (Array.isArray(catchAll)) {
+    const scope = Object.hasOwn(localRules, "*") ? "project" : "global";
+    return [
+      [
+        { text: ' "*" rule:', tone: "title" },
+        { text: "  decides every model no other rule matches", tone: "muted" }
+      ],
+      [
+        { text: "  \u2192 ", tone: "dim" },
+        catchAll.length > 0 ? { text: chainStr(catchAll), tone: "value" } : { text: "no route", tone: "warn" },
+        { text: ` (${scope})`, tone: "muted" }
+      ],
+      [{ text: "  The catalog and the fallback hop are not used.", tone: "dim" }]
+    ];
+  }
+  return fallbackHopLines(resolved);
+}
+function fallbackHopLines(resolved) {
+  const source = ` (${FALLBACK_SOURCE_LABEL[resolved.source]})`;
+  const note = [
+    {
+      text: "  --default-provider overrides this for one run and the sessions it starts.",
+      tone: "dim"
+    }
+  ];
+  if (resolved.provider === "") {
+    return [
+      [
+        { text: " Fallback hop:", tone: "title" },
+        { text: "  (none \u2014 a model the catalog maps to no provider gets no route)", tone: "muted" }
+      ],
+      [
+        { text: "  \u2192 ", tone: "dim" },
+        { text: "disabled", tone: "warn" },
+        { text: `, set to ""${source}`, tone: "muted" }
+      ],
+      note
+    ];
+  }
+  return [
+    [
+      { text: " Fallback hop:", tone: "title" },
+      { text: "  (tried last, after every provider the catalog maps)", tone: "muted" }
+    ],
+    [
+      { text: "  \u2192 ", tone: "dim" },
+      { text: resolved.provider, tone: "value" },
+      { text: source, tone: "muted" }
+    ],
+    note
+  ];
+}
+function resolveFallbackHop(config, env = process.env) {
+  return resolveDefaultProvider({ config, env });
+}
+function toneColor(tone) {
+  switch (tone) {
+    case "title":
+      return C.blue;
+    case "value":
+      return C.cyan;
+    case "warn":
+      return C.yellow;
+    case "muted":
+      return C.fgMuted;
+    case "dim":
+      return C.dim;
+  }
+}
+function rulesOfScope(mergedRules, scope) {
+  return Object.fromEntries(mergedRules.filter((rule) => rule.kind === scope).map((rule) => [rule.pattern, rule.chain]));
+}
+function hopLabel2(entry) {
+  if (entry.status === "unverified")
+    return NATIVE_HOP_LABEL;
+  return hopLabel(entry);
+}
+function hopLabelColor(entry) {
+  if (entry.status === "dropped")
+    return C.dim;
+  if (entry.status === "unverified")
+    return C.cyan;
+  if (entry.position === "fallback")
+    return C.yellow;
+  switch (entry.tier) {
+    case "subscription":
+    case "dynamic-subscription":
+      return C.green;
+    case "native":
+      return C.cyan;
+    case "gateway":
+      return C.blue;
+    case "fallback":
+      return C.yellow;
+    default:
+      return C.dim;
+  }
+}
 function RoutingContent({
   config,
   probeMode,
   probeModel,
   probeResults,
+  probeSummary,
   mode,
   routingPattern,
   chainSelected,
@@ -69347,23 +69874,20 @@ function RoutingContent({
         }),
         /* @__PURE__ */ jsx24("text", {
           children: /* @__PURE__ */ jsx24("span", {
-            fg: C.dim,
-            children: "Examples: kimi-k2  deepseek-r1  gemini-2.0-flash  gpt-4o"
+            fg: C.fgMuted,
+            children: "The probe shows the routing chain a request would use, then tests"
           })
         }),
-        /* @__PURE__ */ jsx24("text", {
-          children: " "
-        }),
         /* @__PURE__ */ jsx24("text", {
           children: /* @__PURE__ */ jsx24("span", {
             fg: C.fgMuted,
-            children: "The probe resolves the fallback chain and tests each provider's"
+            children: "each kept hop in order, stopping at the first success. Dropped"
           })
         }),
         /* @__PURE__ */ jsx24("text", {
           children: /* @__PURE__ */ jsx24("span", {
             fg: C.fgMuted,
-            children: "API key in order, stopping at the first success."
+            children: "candidates are listed with the reason, never tested."
           })
         })
       ]
@@ -69426,21 +69950,30 @@ function RoutingContent({
         /* @__PURE__ */ jsx24("text", {
           children: /* @__PURE__ */ jsx24("span", {
             fg: C.fgMuted,
-            children: probeResults[0]?.reason ?? `Chain (${probeResults.length} providers):`
+            children: probeSummary?.line ?? ""
           })
         }),
+        probeSummary?.warnings.map((warning) => /* @__PURE__ */ jsx24("text", {
+          children: /* @__PURE__ */ jsx24("span", {
+            fg: C.yellow,
+            children: `! ${warning}`
+          })
+        }, `warning:${warning}`)),
+        probeSummary?.notes.map((note) => /* @__PURE__ */ jsx24("text", {
+          children: /* @__PURE__ */ jsx24("span", {
+            fg: C.dim,
+            children: note
+          })
+        }, `note:${note}`)),
         /* @__PURE__ */ jsx24("text", {
           children: " "
         }),
         probeResults.map((entry, idx) => {
-          const isNoKey = entry.status === "no_key";
+          const isDropped = entry.status === "dropped";
           const isNotReached = entry.status === "skipped";
           const isSelected = entry.status === "success" && probeMode === "done";
-          const statusIcon = entry.status === "unverified" ? "\u25D0" : entry.status === "success" ? "\u25CF" : entry.status === "failed" ? "\u2717" : entry.status === "testing" ? "\u25CC" : isNoKey ? "\u25CB" : isNotReached ? "\xB7" : "\u25CB";
-          const statusColor = entry.status === "unverified" ? C.cyan : entry.status === "success" ? C.green : entry.status === "failed" ? C.red : entry.status === "testing" ? C.yellow : C.dim;
+          const status = rowStatusView(entry);
           const nameCol = entry.displayName.padEnd(18).substring(0, 18);
-          const statusText = entry.status === "unverified" ? "native \u2014 not probed" : entry.status === "success" ? entry.ms !== undefined ? `${entry.ms}ms` : "success" : entry.status === "failed" ? entry.error ?? "failed" : entry.status === "testing" ? "testing..." : isNoKey ? "not configured, skipping" : isNotReached ? "not reached" : "waiting";
-          const reason = PROVIDER_REASONS[entry.provider] ?? entry.provider;
           return /* @__PURE__ */ jsxs20("box", {
             flexDirection: "column",
             children: [
@@ -69451,7 +69984,7 @@ function RoutingContent({
                     children: `${idx + 1}. `
                   }),
                   /* @__PURE__ */ jsx24("span", {
-                    fg: isNoKey ? C.dim : isSelected ? C.strong : isNotReached ? C.dim : C.fgMuted,
+                    fg: isDropped || isNotReached ? C.dim : isSelected ? C.strong : C.fgMuted,
                     attributes: A.boldIf(isSelected),
                     children: nameCol
                   }),
@@ -69460,12 +69993,12 @@ function RoutingContent({
                     children: "  "
                   }),
                   /* @__PURE__ */ jsxs20("span", {
-                    fg: statusColor,
+                    fg: status.color,
                     attributes: A.boldIf(entry.status === "success"),
                     children: [
-                      statusIcon,
+                      status.icon,
                       " ",
-                      statusText
+                      status.text
                     ]
                   }),
                   isSelected && /* @__PURE__ */ jsx24("span", {
@@ -69482,13 +70015,21 @@ function RoutingContent({
                     children: "    \u21B3 "
                   }),
                   /* @__PURE__ */ jsx24("span", {
-                    fg: isNoKey ? C.dim : C.fgMuted,
-                    children: reason
+                    fg: isDropped ? C.dim : C.fgMuted,
+                    children: entry.displayName
+                  }),
+                  /* @__PURE__ */ jsx24("span", {
+                    fg: C.dim,
+                    children: " \xB7 "
+                  }),
+                  /* @__PURE__ */ jsx24("span", {
+                    fg: hopLabelColor(entry),
+                    children: hopLabel2(entry)
                   })
                 ]
               })
             ]
-          }, entry.provider);
+          }, `${idx}:${entry.provider}`);
         }),
         probeMode === "done" && /* @__PURE__ */ jsxs20(Fragment14, {
           children: [
@@ -69496,7 +70037,19 @@ function RoutingContent({
               children: " "
             }),
             /* @__PURE__ */ jsx24("text", {
-              children: allFailed ? /* @__PURE__ */ jsxs20(Fragment14, {
+              children: probeSummary?.noRoute ? /* @__PURE__ */ jsxs20(Fragment14, {
+                children: [
+                  /* @__PURE__ */ jsx24("span", {
+                    fg: C.red,
+                    attributes: A.bold,
+                    children: "Result: "
+                  }),
+                  /* @__PURE__ */ jsx24("span", {
+                    fg: C.red,
+                    children: `\u2717 No route \u2014 ${probeSummary.noRoute.reason}`
+                  })
+                ]
+              }) : allFailed ? /* @__PURE__ */ jsxs20(Fragment14, {
                 children: [
                   /* @__PURE__ */ jsx24("span", {
                     fg: C.red,
@@ -69542,7 +70095,13 @@ function RoutingContent({
                   })
                 ]
               })
-            })
+            }),
+            hintLines(probeSummary?.noRoute?.hint).map((line) => /* @__PURE__ */ jsx24("text", {
+              children: /* @__PURE__ */ jsx24("span", {
+                fg: C.dim,
+                children: `  ${line.text}`
+              })
+            }, line.id))
           ]
         })
       ]
@@ -69557,61 +70116,18 @@ function RoutingContent({
     flexDirection: "column",
     paddingX: 1,
     children: [
-      /* @__PURE__ */ jsxs20("text", {
+      routingHeaderLines({
+        globalRules: rulesOfScope(mergedRules, "global"),
+        localRules: rulesOfScope(mergedRules, "project"),
+        resolved: resolveFallbackHop(config)
+      }).map((line) => /* @__PURE__ */ jsx24("text", {
         height: 1,
-        children: [
-          /* @__PURE__ */ jsx24("span", {
-            fg: C.blue,
-            attributes: A.bold,
-            children: " Fallback hop:"
-          }),
-          /* @__PURE__ */ jsx24("span", {
-            fg: C.fgMuted,
-            children: "  (tried last, after every provider the catalog maps)"
-          })
-        ]
-      }),
-      /* @__PURE__ */ jsx24("text", {
-        height: 1,
-        children: (() => {
-          const configured = config.defaultProvider;
-          if (configured !== undefined && configured.length === 0) {
-            return /* @__PURE__ */ jsxs20(Fragment14, {
-              children: [
-                /* @__PURE__ */ jsx24("span", {
-                  fg: C.dim,
-                  children: "  \u2192 "
-                }),
-                /* @__PURE__ */ jsx24("span", {
-                  fg: C.yellow,
-                  children: "disabled"
-                }),
-                /* @__PURE__ */ jsx24("span", {
-                  fg: C.fgMuted,
-                  children: "  (defaultProvider is empty \u2014 an unroutable model errors instead)"
-                })
-              ]
-            });
-          }
-          const hasOverride = configured !== undefined && configured.length > 0;
-          return /* @__PURE__ */ jsxs20(Fragment14, {
-            children: [
-              /* @__PURE__ */ jsx24("span", {
-                fg: C.dim,
-                children: "  \u2192 "
-              }),
-              /* @__PURE__ */ jsx24("span", {
-                fg: C.cyan,
-                children: hasOverride ? configured : DEFAULT_FALLBACK_PROVIDER
-              }),
-              /* @__PURE__ */ jsx24("span", {
-                fg: C.fgMuted,
-                children: hasOverride ? "  (defaultProvider)" : "  (default \u2014 set defaultProvider to change)"
-              })
-            ]
-          });
-        })()
-      }),
+        children: line.map((segment) => /* @__PURE__ */ jsx24("span", {
+          fg: toneColor(segment.tone),
+          attributes: A.boldIf(segment.tone === "title"),
+          children: segment.text
+        }, `${segment.tone}:${segment.text}`))
+      }, line.map((segment) => segment.text).join(""))),
       /* @__PURE__ */ jsx24("text", {
         height: 1,
         children: /* @__PURE__ */ jsx24("span", {
@@ -69726,7 +70242,7 @@ function RoutingContent({
               const scopeText = isProject ? "project " : "global  ";
               const scopeFg = isProject ? C.cyan : C.green;
               const patFg = sel ? C.strong : C.cyan;
-              const chainFg = sel ? C.cyan : C.fgMuted;
+              const chainCell = ruleChainCell(rule.chain, sel);
               return /* @__PURE__ */ jsx24("box", {
                 height: 1,
                 flexDirection: "row",
@@ -69748,8 +70264,8 @@ function RoutingContent({
                       children: scopeText
                     }),
                     /* @__PURE__ */ jsx24("span", {
-                      fg: chainFg,
-                      children: chainStr(rule.chain)
+                      fg: chainCell.fg,
+                      children: chainCell.text
                     })
                   ]
                 })
@@ -70055,32 +70571,24 @@ function RoutingContent({
     ]
   });
 }
-var PROVIDER_REASONS;
+var DROPPED_TEXT, FALLBACK_SOURCE_LABEL, NATIVE_HOP_LABEL = "Claude Code's own auth";
 var init_RoutingContent = __esm(() => {
   init_routing_rules();
   init_constants3();
   init_providers();
   init_theme2();
-  PROVIDER_REASONS = {
-    litellm: "LiteLLM proxy",
-    "opencode-zen": "Free tier (OpenCode Zen)",
-    "opencode-zen-go": "Zen Go plan",
-    kimi: "Native Kimi API",
-    "kimi-coding": "Kimi Coding Plan",
-    minimax: "Native MiniMax API",
-    "minimax-coding": "MiniMax Coding Plan",
-    glm: "Native GLM API",
-    "glm-coding": "GLM Coding Plan",
-    "qwen-token-plan": "Alibaba Token Plan",
-    "qwen-coding": "Alibaba Coding Plan",
-    "qwen-payg": "Alibaba PAYG",
-    google: "Direct Gemini API",
-    openai: "Direct OpenAI API",
-    "openai-codex": "OpenAI Codex (Responses API)",
-    zai: "Z.AI API",
-    ollamacloud: "Cloud Ollama",
-    vertex: "Vertex AI (ADC)",
-    openrouter: "Fallback: 580+ models"
+  DROPPED_TEXT = {
+    "no-credential": "no credential",
+    "credential-unreadable": "credential could not be read",
+    "not-served": "the account does not serve it",
+    "excluded-by-membership": "not in the plan's membership"
+  };
+  FALLBACK_SOURCE_LABEL = {
+    "cli-flag": "--default-provider",
+    "env-var": "CLAUDISH_DEFAULT_PROVIDER",
+    "config-file": "config",
+    "openrouter-key": "default",
+    hardcoded: "default"
   };
 });
 
@@ -70092,6 +70600,7 @@ function RoutingDetail({ probeMode, mergedRules }) {
   }
   const globalCustom = mergedRules.filter((r) => r.kind === "global").length;
   const projectRules = mergedRules.filter((r) => r.kind === "project");
+  const hasCatchAll = mergedRules.some((r) => r.pattern === "*");
   const fmtCount = (n) => String(n).padStart(2, " ");
   return /* @__PURE__ */ jsxs21("box", {
     height: DETAIL_H,
@@ -70157,7 +70666,7 @@ function RoutingDetail({ probeMode, mergedRules }) {
           children: /* @__PURE__ */ jsx25("text", {
             children: /* @__PURE__ */ jsx25("span", {
               fg: C.fgMuted,
-              children: " Anything with no rule here is routed from the models catalog."
+              children: hasCatchAll ? ' The "*" rule takes every model no other rule here matches.' : " Anything with no rule here is routed from the cloud models catalog."
             })
           })
         })
@@ -70652,20 +71161,76 @@ var probeProxy = null, probeProxyStarting = null;
 
 // src/tui/hooks/useRouteProbe.ts
 import { useCallback as useCallback3, useState as useState10 } from "react";
-async function routeForProbe(model) {
+function probeRowsFrom(explanation) {
+  const summary = {
+    line: describeRouteExplanation(explanation),
+    warnings: explanation.warnings.map((warning) => warning.message),
+    notes: []
+  };
+  if (explanation.source === "native") {
+    summary.notes.push(NATIVE_NOT_PROBED);
+    const native = explanation.native;
+    const rows = native ? [
+      {
+        provider: native.provider,
+        displayName: native.displayName,
+        modelSpec: native.modelSpec,
+        status: "unverified"
+      }
+    ] : [];
+    return { summary, rows };
+  }
+  if (explanation.catalog === "found" && explanation.fallbackWithheld) {
+    summary.notes.push(FALLBACK_WITHHELD_NOTE[explanation.fallbackWithheld]);
+  }
+  if (explanation.outcome.kind === "no-route") {
+    const { reason, hint } = explanation.outcome;
+    summary.noRoute = hint !== undefined ? { reason, hint } : { reason };
+  }
+  const rows = explanation.candidates.map((candidate) => {
+    const row = {
+      provider: candidate.provider,
+      displayName: candidate.displayName,
+      modelSpec: candidate.modelSpec,
+      position: candidate.position,
+      ...candidate.tier !== undefined ? { tier: candidate.tier } : {},
+      status: "pending"
+    };
+    if (candidate.outcome !== "kept") {
+      row.status = "dropped";
+      row.outcome = candidate.outcome;
+    }
+    return row;
+  });
+  return { summary, rows };
+}
+function probeQueue(rows) {
+  return rows.flatMap((row, index) => row.status === "pending" && row.modelSpec !== undefined ? [{ index, provider: row.provider, modelSpec: row.modelSpec }] : []);
+}
+async function probeViewFor(model) {
   try {
-    return await route(model);
+    return probeRowsFrom(await explainRoute(model));
   } catch (err) {
-    return { kind: "no-route", reason: err instanceof Error ? err.message : String(err) };
+    return {
+      summary: {
+        line: "the route could not be calculated",
+        warnings: [],
+        notes: [],
+        noRoute: { reason: err instanceof Error ? err.message : String(err) }
+      },
+      rows: []
+    };
   }
 }
-function useRouteProbe(config) {
+function useRouteProbe() {
   const [probeMode, setProbeMode] = useState10("idle");
   const [probeModel, setProbeModel] = useState10("");
   const [probeResults, setProbeResults] = useState10([]);
+  const [probeSummary, setProbeSummary] = useState10(null);
   const startInput = useCallback3(() => {
     setProbeModel("");
     setProbeResults([]);
+    setProbeSummary(null);
     setProbeMode("input");
   }, []);
   const typeChar = useCallback3((ch) => {
@@ -70677,11 +71242,13 @@ function useRouteProbe(config) {
   const cancel = useCallback3(() => {
     setProbeModel("");
     setProbeResults([]);
+    setProbeSummary(null);
     setProbeMode("idle");
   }, []);
   const enterFromDone = useCallback3(() => {
     setProbeModel("");
     setProbeResults([]);
+    setProbeSummary(null);
     setProbeMode("input");
   }, []);
   const submit = useCallback3(() => {
@@ -70692,71 +71259,28 @@ function useRouteProbe(config) {
       return;
     }
     (async () => {
-      const native = nativeRouteFor(model);
-      let chain;
-      if (native) {
-        chain = [native];
-      } else {
-        const plan = await routeForProbe(model);
-        if (plan.kind !== "ok") {
-          setProbeResults([
-            {
-              provider: "none",
-              displayName: "No routes found",
-              status: "failed",
-              error: plan.hint ?? plan.reason
-            }
-          ]);
-          setProbeMode("done");
-          return;
-        }
-        chain = [plan.primary, ...plan.fallbacks];
+      const { summary, rows } = await probeViewFor(model);
+      setProbeSummary(summary);
+      setProbeResults(rows);
+      const queue = probeQueue(rows);
+      if (queue.length === 0) {
+        setProbeMode("done");
+        return;
       }
-      const ruleEntries = Object.entries(config.routing ?? {});
-      const modelLower = model.toLowerCase();
-      const matchedRule = ruleEntries.find(([pat]) => {
-        if (pat.toLowerCase() === modelLower)
-          return true;
-        if (pat.includes("*")) {
-          const regex = new RegExp(`^${pat.replace(/\*/g, ".*")}$`, "i");
-          return regex.test(model);
-        }
-        return false;
-      });
-      const initial = chain.map((r) => {
-        return {
-          provider: r.provider,
-          displayName: r.displayName,
-          status: "pending",
-          hasKey: true,
-          reason: native ? "Native Claude Code auth \u2014 served by the proxy, never routed" : matchedRule ? `Custom rule: ${matchedRule[0]}` : "Default fallback chain"
-        };
-      });
-      setProbeResults(initial);
       setProbeMode("running");
       (async () => {
-        if (native) {
-          setProbeResults((prev) => prev.map((e) => ({ ...e, status: "unverified", reason: REASON_NATIVE })));
-          setProbeMode("done");
-          return;
-        }
         let proxyUrl;
         try {
           proxyUrl = await ensureProbeProxy();
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
-          setProbeResults((prev) => prev.map((e) => ({ ...e, status: "failed", error: `probe proxy: ${msg}` })));
+          const queued = new Set(queue.map((item) => item.index));
+          setProbeResults((prev) => prev.map((e, idx) => queued.has(idx) ? { ...e, status: "failed", error: `probe proxy: ${msg}` } : e));
           setProbeMode("done");
           return;
         }
-        for (let i = 0;i < chain.length; i++) {
-          const link = chain[i];
-          const provDef = getProviderDefs().find((p) => p.catalogName === link.provider);
-          const ready = provDef ? providerIsReady(provDef, config) : true;
-          if (!ready) {
-            setProbeResults((prev) => prev.map((e, idx) => idx === i ? { ...e, status: "no_key" } : e));
-            continue;
-          }
+        for (const link of queue) {
+          const i = link.index;
           setProbeResults((prev) => prev.map((e, idx) => idx === i ? { ...e, status: "testing" } : e));
           const startMs = Date.now();
           const result = await probeProviderRoute(proxyUrl, {
@@ -70778,7 +71302,7 @@ function useRouteProbe(config) {
                 error: ok ? undefined : describeProbeState(result),
                 ms
               };
-            if (idx > i && ok && e.status !== "no_key")
+            if (idx > i && ok && e.status === "pending")
               return { ...e, status: "skipped" };
             return e;
           }));
@@ -70788,7 +71312,7 @@ function useRouteProbe(config) {
         setProbeMode("done");
       })();
     })();
-  }, [config, probeModel]);
+  }, [probeModel]);
   let state;
   if (probeMode === "idle")
     state = { kind: "idle" };
@@ -70803,6 +71327,7 @@ function useRouteProbe(config) {
     probeMode,
     probeModel,
     probeResults,
+    probeSummary,
     startInput,
     typeChar,
     backspace,
@@ -70811,13 +71336,18 @@ function useRouteProbe(config) {
     enterFromDone
   };
 }
-var REASON_NATIVE = "Native Claude Code auth \u2014 not probed \u2014 served on Claude Code's own auth, which this process cannot forward";
+var FALLBACK_WITHHELD_NOTE;
 var init_useRouteProbe = __esm(() => {
   init_native_route();
   init_probe_live();
   init_probe_runner();
   init_routing_rules();
-  init_providers();
+  FALLBACK_WITHHELD_NOTE = {
+    disabled: 'No fallback hop: the default provider is set to "".',
+    "catalog-unreadable": "No fallback hop: there is no cloud models catalog to check it against.",
+    "already-gathered": "No separate fallback hop: that provider is already a catalog candidate.",
+    "catalog-denies": "No fallback hop: the catalog maps that provider no connection to this model."
+  };
 });
 
 // src/tui/onepassword-fields.ts
@@ -71114,8 +71644,8 @@ function App({ requestLogin } = {}) {
       return next;
     });
   }, []);
-  const probe = useRouteProbe(config);
-  const { probeMode, probeModel, probeResults } = probe;
+  const probe = useRouteProbe();
+  const { probeMode, probeModel, probeResults, probeSummary } = probe;
   const wizard = useProfileWizard({ mode, setMode, refreshConfig, setStatusMsg });
   const { editProfileValue, profileScope, suggestions, suggestionIndex, providerPickerIndex } = wizard;
   const hasCfgKey = !!config.apiKeys?.[selectedProvider.apiKeyEnvVar];
@@ -71139,14 +71669,10 @@ function App({ requestLogin } = {}) {
     const out = [];
     const localCfg = loadLocalConfig();
     for (const [pat, chain] of Object.entries(config.routing ?? {})) {
-      if (pat === "*")
-        continue;
       out.push({ kind: "global", pattern: pat, chain });
     }
     if (localCfg?.routing) {
       for (const [pat, chain] of Object.entries(localCfg.routing)) {
-        if (pat === "*")
-          continue;
         out.push({ kind: "project", pattern: pat, chain });
       }
     }
@@ -72634,6 +73160,7 @@ function App({ requestLogin } = {}) {
             probeMode,
             probeModel,
             probeResults,
+            probeSummary,
             mode,
             routingPattern,
             chainSelected,
@@ -72851,7 +73378,7 @@ import {
   mkdtempSync,
   openSync as openSync8,
   rmSync as rmSync2,
-  writeFileSync as writeFileSync21
+  writeFileSync as writeFileSync20
 } from "fs";
 import { connect as netConnect2 } from "net";
 import { join as join43 } from "path";
@@ -72925,7 +73452,7 @@ function planMagmuxWrap(input) {
   const deltas = envDeltas(parentEnv, input.childEnv);
   const fd = openSync8(scriptPath, "wx", 384);
   try {
-    writeFileSync21(fd, buildLauncherScript(input.claudeBinary, input.claudeArgs, deltas));
+    writeFileSync20(fd, buildLauncherScript(input.claudeBinary, input.claudeArgs, deltas));
   } finally {
     closeSync8(fd);
   }
@@ -73483,7 +74010,7 @@ import {
   readdirSync as readdirSync8,
   statSync as statSync8,
   unlinkSync as unlinkSync9,
-  writeFileSync as writeFileSync22
+  writeFileSync as writeFileSync21
 } from "fs";
 import { homedir as homedir37, tmpdir as tmpdir2 } from "os";
 import { dirname as dirname14, join as join44 } from "path";
@@ -73722,13 +74249,13 @@ process.stdin.on('end', () => {
   }
 });
 `;
-  writeFileSync22(scriptPath, script, "utf-8");
+  writeFileSync21(scriptPath, script, "utf-8");
   return scriptPath;
 }
 function initializeTokenFile(tokenFilePath) {
   try {
     mkdirSync21(dirname14(tokenFilePath), { recursive: true });
-    writeFileSync22(tokenFilePath, JSON.stringify({
+    writeFileSync21(tokenFilePath, JSON.stringify({
       input_tokens: 0,
       output_tokens: 0,
       total_tokens: 0,
@@ -73871,7 +74398,7 @@ function createTempSettingsFile(_modelDisplay, port, proxyAuthMode, userStatusLi
     padding: 0
   };
   const settings = buildClaudishSettingsOverlay(statusLine, proxyAuthMode);
-  writeFileSync22(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) {
@@ -73896,7 +74423,7 @@ function mergeUserSettingsIfPresent(config, tempSettingsPath, statusLine, proxyA
     if (proxyAuthMode && !("forceLoginMethod" in userSettings)) {
       userSettings.forceLoginMethod = "console";
     }
-    writeFileSync22(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}`);
@@ -74410,7 +74937,7 @@ var init_claude_runner = __esm(() => {
 });
 
 // src/diag-output.ts
-import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync22, unlinkSync as unlinkSync10, writeFileSync as writeFileSync23 } from "fs";
+import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync22, unlinkSync as unlinkSync10, writeFileSync as writeFileSync22 } from "fs";
 import { homedir as homedir38 } from "os";
 import { join as join45 } from "path";
 function getClaudishDir() {
@@ -74430,7 +74957,7 @@ class LogFileDiagOutput {
   constructor() {
     this.logPath = getDiagLogPath();
     try {
-      writeFileSync23(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" });
@@ -74775,7 +75302,7 @@ function resolveMainModelFact(model) {
   const definitionName = resolution.catalogName === "gemini" ? "google" : resolution.catalogName;
   const definition = definitionName ? getProviderByName(definitionName) : undefined;
   const format = definition ? pinnedFormatForTransport(definition.transport, resolution.modelName) : null;
-  const providerName = resolution.category === "unknown" ? "unresolved (routed on the first request)" : definition?.displayName || resolution.providerName;
+  const providerName = resolution.category === "unknown" || resolution.category === "auto-route" ? "unresolved (routed on the first request)" : definition?.displayName || resolution.providerName;
   return {
     model,
     providerName,
@@ -77119,9 +77646,22 @@ async function applyConfigOverride() {
   setConfigFileOverride(plan.path);
   process.env.CLAUDISH_CONFIG = plan.path;
 }
+async function applyDefaultProviderFlag() {
+  await Promise.resolve();
+  const plan = planDefaultProviderFlag(process.argv.slice(2));
+  if (plan.kind === "none")
+    return;
+  if (plan.kind === "error") {
+    console.error(`[claudish] ${plan.message}`);
+    process.exit(1);
+  }
+  process.argv = [...process.argv.slice(0, 2), ...plan.argv];
+  process.env.CLAUDISH_DEFAULT_PROVIDER = plan.value;
+}
 await traceSpan("startup:config-override", () => applyConfigOverride());
 await traceSpan("startup:op-env-flags", () => applyOpEnvironment());
 await traceSpan("startup:op-import-flag", () => applyOpImport());
+await traceSpan("startup:default-provider-flag", () => applyDefaultProviderFlag());
 var isMcpMode = process.argv.includes("--mcp");
 function handlePromptExit(err) {
   if (err instanceof PickerCancelled) {