claudish 7.50.0 → 7.52.0

package/dist/index.js

@@ -729,7 +729,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.50.0";
+var VERSION = "7.52.0";
 
 // src/logger.ts
 var exports_logger = {};
@@ -27509,6 +27509,9 @@ function loadConfig() {
     if (config2.customEndpoints !== undefined) {
       merged.customEndpoints = config2.customEndpoints;
     }
+    if (config2.predefinedEndpoints !== undefined) {
+      merged.predefinedEndpoints = config2.predefinedEndpoints;
+    }
     if (config2.behavior !== undefined) {
       merged.behavior = config2.behavior;
     }
@@ -27933,24 +27936,44 @@ function getApiKeyInfo(providerName) {
     oauthFallback: def.oauthFallback
   };
 }
+function describeMissingCredential(providerName) {
+  const info = getApiKeyInfo(providerName);
+  const keyNames = info?.envVar ? [info.envVar, ...info.aliases ?? []].join(" or ") : undefined;
+  const signup = info?.url ? ` Get one at ${info.url}.` : "";
+  const def = getProviderByName(providerName);
+  if (isLocalTransport(providerName)) {
+    const where = def ? ` Claudish will use ${getEffectiveBaseUrl(def)}.` : "";
+    const keyClause = keyNames ? ` (Only set ${keyNames} if your local server requires a bearer token.)` : "";
+    return `Provider "${providerName}" is a LOCAL server and is not enabled. ` + "Enable it in `claudish config` (Providers tab), or add " + `"localProviders": ["${providerName}"] to ~/.claudish/config.json.${where}${keyClause}`;
+  }
+  if (def?.oauthFallback) {
+    const keyClause = keyNames ? ` Or set ${keyNames} (env, config, or 1Password import) to use a metered API key instead.${signup}` : "";
+    return `No credential for provider "${providerName}". Sign in with ` + `\`claudish login ${providerName}\` to use your existing subscription.${keyClause}`;
+  }
+  return keyNames ? `No API key for provider "${providerName}". Set ${keyNames} (env, config, or 1Password import).${signup}` : `No API key for provider "${providerName}".`;
+}
 function getDisplayName(providerName) {
   const def = getProviderByName(providerName);
   return def?.displayName || providerName.charAt(0).toUpperCase() + providerName.slice(1);
 }
-function getEffectiveBaseUrl(def) {
-  if (def.baseUrlEnvVars) {
-    for (const envVar of def.baseUrlEnvVars) {
-      const fromConfig = getEndpoint(envVar);
-      if (fromConfig)
-        return fromConfig;
-    }
-    for (const envVar of def.baseUrlEnvVars) {
-      const value = process.env[envVar];
-      if (value)
-        return value;
-    }
+function baseUrlOverrideCandidates(baseUrlEnvVars) {
+  const found = [];
+  if (!baseUrlEnvVars || baseUrlEnvVars.length === 0)
+    return found;
+  for (const envVar of baseUrlEnvVars) {
+    const fromConfig = getEndpoint(envVar);
+    if (fromConfig)
+      found.push({ envVar, value: fromConfig, source: "config" });
+  }
+  for (const envVar of baseUrlEnvVars) {
+    const value = process.env[envVar];
+    if (value)
+      found.push({ envVar, value, source: "env" });
   }
-  return def.baseUrl;
+  return found;
+}
+function getEffectiveBaseUrl(def) {
+  return baseUrlOverrideCandidates(def.baseUrlEnvVars)[0]?.value ?? def.baseUrl;
 }
 function isLocalTransport(providerName) {
   if (!_localProvidersCache) {
@@ -30753,6 +30776,7 @@ class AntigravityProviderTransport {
       if (!data?.buckets?.length)
         return;
       const lines = [];
+      let sawThrottledModel = false;
       for (const bucket of data.buckets) {
         if (!bucket.modelId)
           continue;
@@ -30761,15 +30785,24 @@ class AntigravityProviderTransport {
           hour: "2-digit",
           minute: "2-digit"
         }) : "?";
-        lines.push(`  ${bucket.modelId}: ${pct} remaining (resets ${reset})`);
+        const mine = this.isThrottledModel(bucket.modelId);
+        if (mine)
+          sawThrottledModel = true;
+        lines.push(`  ${mine ? "> " : "  "}${bucket.modelId}: ${pct} remaining (resets ${reset})`);
       }
-      if (lines.length > 0) {
-        logStderr(`[Antigravity] Quota status:
+      if (lines.length === 0)
+        return;
+      const requested = this.servedModelName && this.servedModelName !== this.modelName ? `${this.modelName} (served as ${this.servedModelName})` : this.modelName;
+      const header = sawThrottledModel ? `[Antigravity] Quota status (> = ${requested}):` : `[Antigravity] Quota status \u2014 NOTE: ${requested} has no quota bucket below, ` + "so these figures do not explain its rate limit:";
+      logStderr(`${header}
 ${lines.join(`
 `)}`);
-      }
     } catch {}
   }
+  isThrottledModel(bucketModelId) {
+    const id = bucketModelId.toLowerCase();
+    return id === this.modelName.toLowerCase() || id === this.servedModelName.toLowerCase();
+  }
   async getQuotaRemaining(modelName) {
     if (!this.accessToken || !this.projectId)
       return;
@@ -30850,6 +30883,22 @@ var init_antigravity_credential = __esm(() => {
   init_antigravity_user();
 });
 
+// src/auth/credentials/local-api-key.ts
+function resolveLocalApiKey(q) {
+  return realValue(process.env[q.envVar]) || (q.aliases ?? []).map((a) => realValue(process.env[a])).find((v) => !!v) || realValue(getApiKey(q.envVar));
+}
+function hasLocalApiKey(q) {
+  try {
+    return !!resolveLocalApiKey(q);
+  } catch {
+    return false;
+  }
+}
+var init_local_api_key = __esm(() => {
+  init_env_placeholder();
+  init_profile_config();
+});
+
 // src/auth/credentials/api-key-credential.ts
 import { existsSync as existsSync8 } from "fs";
 import { homedir as homedir10 } from "os";
@@ -30877,7 +30926,7 @@ class ApiKeyCredentialProvider {
     this.declaredKey = descriptor.declaredKey;
   }
   resolveFromEnvConfig() {
-    return realValue(process.env[this.envVar]) || this.aliases.map((a) => realValue(process.env[a])).find((v) => !!v) || realValue(getApiKey(this.envVar)) || realValue(this.resolveDeclared());
+    return resolveLocalApiKey({ envVar: this.envVar, aliases: this.aliases }) || realValue(this.resolveDeclared());
   }
   resolveDeclared() {
     try {
@@ -30958,7 +31007,7 @@ class ApiKeyCredentialProvider {
 }
 var init_api_key_credential = __esm(() => {
   init_env_placeholder();
-  init_profile_config();
+  init_local_api_key();
   init_op_source();
 });
 
@@ -32359,7 +32408,7 @@ var init_authority = __esm(() => {
 });
 
 // src/config-schema.ts
-var BuiltinDefaultProviderSchema, CustomEndpointSimpleSchema, CustomEndpointComplexSchema, CustomEndpointSchema, DefaultProviderSchema;
+var BuiltinDefaultProviderSchema, CustomEndpointSimpleSchema, CustomEndpointComplexSchema, CustomEndpointSchema, PredefinedEndpointsConfigSchema, DefaultProviderSchema;
 var init_config_schema = __esm(() => {
   init_zod();
   BuiltinDefaultProviderSchema = exports_external.enum([
@@ -32394,6 +32443,11 @@ var init_config_schema = __esm(() => {
     CustomEndpointSimpleSchema,
     CustomEndpointComplexSchema
   ]);
+  PredefinedEndpointsConfigSchema = exports_external.object({
+    enabled: exports_external.boolean().optional(),
+    disable: exports_external.array(exports_external.string()).optional(),
+    enable: exports_external.array(exports_external.string()).optional()
+  });
   DefaultProviderSchema = exports_external.union([BuiltinDefaultProviderSchema, exports_external.string().min(1)]);
 });
 
@@ -32631,12 +32685,14 @@ var init_deepseek_model_dialect = __esm(() => {
     }
     applyNativeReasoning(request, originalRequest) {
       const effort = this.resolveEffortLevel(originalRequest);
-      if (effort && this.isV4Model()) {
+      if (effort && this.acceptsReasoningControls()) {
         if (effort === "none" || effort === "minimal") {
           request.thinking = { type: "disabled" };
           log(`[DeepSeekModelDialect] effort ${effort} -> thinking.type: disabled for ${this.modelId}`);
         } else {
-          const value = effort === "xhigh" || effort === "max" ? "max" : "high";
+          const reasoning = this.lookupReasoningCapability();
+          const clamped = reasoning?.control === "effort" && reasoning.efforts?.length ? this.clampToAdvertisedEffort(effort, reasoning) : undefined;
+          const value = clamped ?? (effort === "xhigh" || effort === "max" ? "max" : "high");
           request.reasoning_effort = value;
           log(`[DeepSeekModelDialect] effort ${effort} -> reasoning_effort: ${value} for ${this.modelId}`);
         }
@@ -32648,9 +32704,15 @@ var init_deepseek_model_dialect = __esm(() => {
       }
       return request;
     }
-    isV4Model() {
+    acceptsReasoningControls() {
+      const reasoning = this.lookupReasoningCapability();
+      if (reasoning)
+        return reasoning.supported === true && reasoning.control === "effort";
       const model = this.modelId.toLowerCase();
-      return model.includes("v4") || model.includes("deepseek-chat") || model.includes("deepseek-reasoner");
+      if (model.includes("deepseek-chat") || model.includes("deepseek-reasoner"))
+        return true;
+      const version2 = /(?:^|[^a-z0-9])v(\d+)/.exec(model);
+      return version2 ? Number(version2[1]) >= 4 : false;
     }
     shouldHandle(modelId) {
       return matchesModelFamily(modelId, "deepseek");
@@ -34061,11 +34123,87 @@ var init_glm_model_dialect = __esm(() => {
   };
 });
 
+// src/adapters/grok-effort-support.ts
+function acceptsReasoningEffort(modelId) {
+  const id = norm(modelId);
+  if (!id)
+    return false;
+  if (learnedRejects.has(id))
+    return false;
+  const reasoning = lookupModelReasoning(id) ?? lookupModelReasoning(modelId);
+  if (reasoning)
+    return reasoning.supported === true && reasoning.control === "effort";
+  return !SEED_REJECTS.some((re) => re.test(id));
+}
+function catalogReasoningFor(modelId) {
+  return lookupModelReasoning(norm(modelId)) ?? lookupModelReasoning(modelId);
+}
+function rememberReasoningEffortRejected(modelId) {
+  const id = norm(modelId);
+  if (!id || learnedRejects.has(id))
+    return;
+  learnedRejects.add(id);
+  log(`[GrokEffortSupport] ${id} rejected reasoning_effort \u2014 not sending it again this session.`);
+}
+function isReasoningEffortRejection(errorText) {
+  if (!errorText)
+    return false;
+  return /does not support parameter\s+`?reasoning[_]?effort`?/i.test(errorText);
+}
+function acceptsReasoningEffortValue(modelId, value) {
+  return !learnedValueRejects.has(pairKey(modelId, value));
+}
+function rememberReasoningEffortValueRejected(modelId, value) {
+  const key = pairKey(modelId, value);
+  if (learnedValueRejects.has(key))
+    return;
+  learnedValueRejects.add(key);
+  log(`[GrokEffortSupport] ${norm(modelId)} rejected reasoning_effort value "${value}" \u2014 ` + "falling back and not sending it again this session.");
+}
+function rejectedReasoningEffortValue(errorText) {
+  if (!errorText)
+    return null;
+  const m = /does not support\s+`?reasoning[_]?effort`?\s+value\s+`?([a-z]+)`?/i.exec(errorText);
+  return m ? m[1].toLowerCase() : null;
+}
+function fallbackReasoningEffortValue(value) {
+  switch (value.toLowerCase()) {
+    case "none":
+      return "low";
+    case "minimal":
+      return "low";
+    case "low":
+      return null;
+    case "medium":
+      return "low";
+    case "high":
+      return "medium";
+    default:
+      return null;
+  }
+}
+var SEED_REJECTS, learnedRejects, norm = (modelId) => modelId.trim().toLowerCase().replace(/^x-ai\//, ""), learnedValueRejects, pairKey = (modelId, value) => `${norm(modelId)}\x00${value.toLowerCase()}`;
+var init_grok_effort_support = __esm(() => {
+  init_logger();
+  init_model_catalog();
+  SEED_REJECTS = [
+    /non-reasoning/i,
+    /^grok-2/i,
+    /^grok-4(?![.\d])(?!.*fast-reasoning)/i,
+    /^grok-build-/i,
+    /^grok-code-/i,
+    /^grok-4\.20/i
+  ];
+  learnedRejects = new Set;
+  learnedValueRejects = new Set;
+});
+
 // src/adapters/grok-model-dialect.ts
 var GrokModelDialect;
 var init_grok_model_dialect = __esm(() => {
   init_logger();
   init_base_api_format();
+  init_grok_effort_support();
   init_model_catalog();
   GrokModelDialect = class GrokModelDialect extends BaseAPIFormat {
     xmlBuffer = "";
@@ -34128,34 +34266,78 @@ var init_grok_model_dialect = __esm(() => {
       return request;
     }
     effortToReasoningEffort(effort) {
-      const model = this.modelId.toLowerCase();
-      const isMini = model.includes("mini");
-      const isGrok43 = /grok-4\.3(\b|[-.]|$)/.test(model);
-      const isFastReasoning = model.includes("fast-reasoning");
-      if (!(isMini || isGrok43 || isFastReasoning)) {
+      if (!acceptsReasoningEffort(this.modelId)) {
         return;
       }
-      if (isMini) {
-        switch (effort) {
-          case "high":
-          case "xhigh":
-          case "max":
-            return "high";
-          default:
-            return "low";
+      let value;
+      const reasoning = catalogReasoningFor(this.modelId);
+      const clamped = reasoning ? this.clampToAdvertisedEffort(effort, reasoning) : undefined;
+      if (clamped) {
+        value = clamped;
+      } else {
+        const model = this.modelId.toLowerCase();
+        const isMini = model.includes("mini");
+        if (isMini) {
+          switch (effort) {
+            case "high":
+            case "xhigh":
+            case "max":
+              value = "high";
+              break;
+            default:
+              value = "low";
+          }
+        } else {
+          switch (effort) {
+            case "none":
+              value = "none";
+              break;
+            case "minimal":
+            case "low":
+              value = "low";
+              break;
+            case "medium":
+              value = "medium";
+              break;
+            default:
+              value = "high";
+          }
         }
       }
-      switch (effort) {
-        case "none":
-          return "none";
-        case "minimal":
-        case "low":
-          return "low";
-        case "medium":
-          return "medium";
-        default:
-          return "high";
+      let guard = 0;
+      while (!acceptsReasoningEffortValue(this.modelId, value) && guard++ < 8) {
+        const next = fallbackReasoningEffortValue(value);
+        if (!next)
+          return;
+        value = next;
       }
+      return value;
+    }
+    recoverFromRejection(payload, errorText) {
+      if (!payload || payload.reasoning_effort === undefined)
+        return null;
+      if (isReasoningEffortRejection(errorText)) {
+        rememberReasoningEffortRejected(this.modelId);
+        const next = { ...payload };
+        delete next.reasoning_effort;
+        return { payload: next, note: `dropped reasoning_effort for ${this.modelId}` };
+      }
+      const rejected = rejectedReasoningEffortValue(errorText);
+      if (rejected) {
+        rememberReasoningEffortValueRejected(this.modelId, rejected);
+        const fallback = fallbackReasoningEffortValue(rejected);
+        const next = { ...payload };
+        if (fallback) {
+          next.reasoning_effort = fallback;
+          return {
+            payload: next,
+            note: `reasoning_effort "${rejected}" -> "${fallback}" for ${this.modelId}`
+          };
+        }
+        delete next.reasoning_effort;
+        return { payload: next, note: `dropped unsupported reasoning_effort for ${this.modelId}` };
+      }
+      return null;
     }
     parseXmlParameters(xmlContent) {
       const params = {};
@@ -36035,6 +36217,45 @@ Do not invent a different filename, and do not derive one from the task. Claude
   PLAN_MODE_RULES = [planFilePathRule];
 });
 
+// src/behavior/rules/session-context.ts
+function hasInjectedSessionContext(systemText2, messages) {
+  const haystacks = [systemText2 ?? ""];
+  const first = Array.isArray(messages) ? messages[0] : undefined;
+  if (first && typeof first === "object") {
+    const content = first.content;
+    if (typeof content === "string") {
+      haystacks.push(content);
+    } else if (Array.isArray(content)) {
+      for (const block of content) {
+        const text = block?.text;
+        if (typeof text === "string")
+          haystacks.push(text);
+      }
+    }
+  }
+  return haystacks.some((h) => {
+    const lower = h.toLowerCase();
+    return SESSION_CONTEXT_MARKERS.some((m) => lower.includes(m));
+  });
+}
+var SESSION_CONTEXT_MARKERS, NOTE, noHarnessEchoRule, SESSION_CONTEXT_RULES;
+var init_session_context = __esm(() => {
+  SESSION_CONTEXT_MARKERS = ["sessionstart hook additional context", "hook additional context"];
+  NOTE = "Operational context note. This session may include text injected by the harness " + "itself \u2014 SessionStart hook output, coaching or insight blocks, tooling banners, " + "status lines. That material is addressed to you, not to the user, and it is not " + "part of the task. Never reproduce, summarise, or quote it in your answer, and never " + "let it open your response. Begin your answer with the requested deliverable and " + "nothing before it.";
+  noHarnessEchoRule = {
+    id: "session-context/no-harness-echo",
+    description: "Stop foreign models opening their answer with harness-injected session context " + "(SessionStart hook output, coaching/insight blocks).",
+    defaultSeverity: "fix",
+    appliesTo: ({ isNativeAnthropic }) => !isNativeAnthropic,
+    onRequest(ctx) {
+      if (!hasInjectedSessionContext(ctx.systemText, ctx.messages))
+        return [];
+      return [{ type: "injectSystemNote", text: NOTE }];
+    }
+  };
+  SESSION_CONTEXT_RULES = [noHarnessEchoRule];
+});
+
 // src/behavior/hooks.ts
 import { isAbsolute, resolve } from "path";
 function isBehaviorRule(value) {
@@ -36244,6 +36465,7 @@ var init_behavior = __esm(() => {
   init_config();
   init_engine();
   init_plan_mode();
+  init_session_context();
   init_engine();
   init_config();
   init_harness();
@@ -36253,7 +36475,7 @@ var init_behavior = __esm(() => {
   init_corpus();
   init_aggregate();
   init_upload();
-  BUILTIN_RULES = [...PLAN_MODE_RULES];
+  BUILTIN_RULES = [...PLAN_MODE_RULES, ...SESSION_CONTEXT_RULES];
   hookRules = [];
 });
 
@@ -36581,7 +36803,14 @@ class OpenAIProviderTransport {
   async getHeaders() {
     const headers = {};
     if (this.apiKey) {
-      headers.Authorization = `Bearer ${this.apiKey}`;
+      if (this.provider.authScheme === "x-api-key") {
+        headers["x-api-key"] = this.apiKey;
+      } else {
+        headers.Authorization = `Bearer ${this.apiKey}`;
+      }
+    }
+    if (this.provider.headers) {
+      Object.assign(headers, this.provider.headers);
     }
     return headers;
   }
@@ -40789,6 +41018,30 @@ class ComposedHandler {
     }
     log(`[${this.provider.displayName}] Response status: ${response.status}`);
     this.capturePlanUsage(response);
+    if (!response.ok) {
+      if (response.status >= 400 && response.status < 500 && this.modelAdapter?.recoverFromRejection) {
+        const errorText = await response.clone().text();
+        const recovery = this.modelAdapter.recoverFromRejection(requestPayload, errorText);
+        if (recovery) {
+          log(`[${this.provider.displayName}] Parameter rejected \u2014 retrying: ${recovery.note}`);
+          requestPayload = recovery.payload;
+          const retrySerialized = this.provider.serializeBody?.(requestPayload);
+          const retryHeaders = await this.provider.getHeaders();
+          retryHeaders["Content-Type"] = retrySerialized?.contentType ?? "application/json";
+          const retryResp = await fetch(endpoint, {
+            method: "POST",
+            headers: retryHeaders,
+            body: retrySerialized?.body ?? JSON.stringify(requestPayload),
+            ...this.provider.getRequestInit?.() || {}
+          });
+          if (retryResp.ok) {
+            response = retryResp;
+          } else {
+            log(`[${this.provider.displayName}] Retry after ${recovery.note} still failed ` + `(HTTP ${retryResp.status})`);
+          }
+        }
+      }
+    }
     if (!response.ok) {
       if (response.status === 401 && this.provider.forceRefreshAuth) {
         log(`[${this.provider.displayName}] Got 401, forcing auth refresh and retrying`);
@@ -41383,6 +41636,21 @@ var init_composed_handler = __esm(() => {
   STREAM_RETRY_DELAYS_MS = [3000, 15000, 30000];
 });
 
+// src/providers/endpoint-diagnostics.ts
+function recordEndpointUnavailable(name, reason) {
+  reasons.set(name, reason);
+}
+function clearEndpointUnavailable(name) {
+  reasons.delete(name);
+}
+function getEndpointUnavailableReason(name) {
+  return reasons.get(name);
+}
+var reasons;
+var init_endpoint_diagnostics = __esm(() => {
+  reasons = new Map;
+});
+
 // src/providers/devin/devin-request.ts
 import { randomUUID as randomUUID3 } from "crypto";
 function encodeChatMetadata(meta3) {
@@ -42645,6 +42913,21 @@ var init_litellm = __esm(() => {
 });
 
 // src/providers/custom-endpoints-loader.ts
+function registerEndpoint(name, entry, ovr) {
+  const validated = CustomEndpointSchema.parse(entry);
+  const def = buildProviderDefinition(name, validated, ovr);
+  const profile = buildProviderProfile(validated, ovr);
+  registerRuntimeProvider(def);
+  registerRuntimeProfile(name, profile);
+  credentials.registerApiKeyProvider({
+    name: def.name,
+    envVar: def.apiKeyEnvVar,
+    aliases: def.apiKeyAliases,
+    authScheme: def.authScheme === "x-api-key" ? "x-api-key" : "bearer",
+    declaredKey: () => resolveDeclaredEndpointKey(validated)
+  });
+  clearEndpointUnavailable(name);
+}
 function loadCustomEndpoints(config2) {
   const result = { registered: 0, errors: [] };
   const raw = config2.customEndpoints;
@@ -42652,17 +42935,7 @@ function loadCustomEndpoints(config2) {
     return result;
   for (const [name, entry] of Object.entries(raw)) {
     try {
-      const validated = CustomEndpointSchema.parse(entry);
-      const def = buildProviderDefinition(name, validated);
-      const profile = buildProviderProfile(validated);
-      registerRuntimeProvider(def);
-      registerRuntimeProfile(name, profile);
-      credentials.registerApiKeyProvider({
-        name: def.name,
-        envVar: def.apiKeyEnvVar,
-        authScheme: def.authScheme === "x-api-key" ? "x-api-key" : "bearer",
-        declaredKey: () => resolveDeclaredEndpointKey(validated)
-      });
+      registerEndpoint(name, entry);
       result.registered++;
     } catch (err) {
       const message = err instanceof exports_external.ZodError ? err.issues.map((i) => i.message).join(", ") : err instanceof Error ? err.message : String(err);
@@ -42671,22 +42944,28 @@ function loadCustomEndpoints(config2) {
   }
   return result;
 }
-function buildProviderDefinition(name, ep) {
+function buildProviderDefinition(name, ep, ovr) {
+  const apiKeyEnvVar = ovr?.apiKeyEnvVar ?? customEndpointKeyEnvVar(name);
+  const apiKeyAliases = ovr?.apiKeyAliases;
+  const baseUrlEnvVars = ovr?.baseUrlEnvVars;
+  const apiKeyUrl = ovr?.apiKeyUrl ?? "";
   if (ep.kind === "simple") {
     return {
       name,
       displayName: name,
       transport: ep.format,
       baseUrl: stripTrailingSlash(ep.url),
+      baseUrlEnvVars,
       apiPath: "/chat/completions",
-      apiKeyEnvVar: `CUSTOM_${sanitizeEnvName(name)}_KEY`,
-      apiKeyDescription: `${name} (custom endpoint)`,
-      apiKeyUrl: "",
+      apiKeyEnvVar,
+      apiKeyAliases,
+      apiKeyDescription: ovr?.apiKeyDescription ?? `${name} (custom endpoint)`,
+      apiKeyUrl,
       shortcuts: [name],
       legacyPrefixes: [],
       isDirectApi: true,
       shortestPrefix: name,
-      description: `Custom endpoint: ${name}`,
+      description: ovr?.description ?? `Custom endpoint: ${name}`,
       authScheme: "bearer"
     };
   }
@@ -42695,33 +42974,68 @@ function buildProviderDefinition(name, ep) {
     displayName: ep.displayName,
     transport: ep.transport,
     baseUrl: stripTrailingSlash(ep.baseUrl),
+    baseUrlEnvVars,
     apiPath: ep.apiPath ?? "/v1/chat/completions",
-    apiKeyEnvVar: `CUSTOM_${sanitizeEnvName(name)}_KEY`,
-    apiKeyDescription: `${ep.displayName} (custom endpoint)`,
-    apiKeyUrl: "",
+    apiKeyEnvVar,
+    apiKeyAliases,
+    apiKeyDescription: ovr?.apiKeyDescription ?? `${ep.displayName} (custom endpoint)`,
+    apiKeyUrl,
     shortcuts: [name],
     legacyPrefixes: [],
     isDirectApi: true,
     shortestPrefix: name,
-    description: `Custom endpoint: ${ep.displayName}`,
+    description: ovr?.description ?? `Custom endpoint: ${ep.displayName}`,
     headers: ep.headers,
     authScheme: ep.authScheme ?? "bearer"
   };
 }
-function buildProviderProfile(ep) {
+function buildProviderProfile(ep, ovr) {
   return {
     createHandler(ctx) {
       const apiKey = ctx.apiKey || resolveCustomEndpointApiKey(ep);
+      const declaredBaseUrl = ep.kind === "simple" ? ep.url : ep.baseUrl;
+      const resolved = classifyEndpointBaseUrl(declaredBaseUrl, ovr?.baseUrlEnvVars);
+      if (!resolved.ok) {
+        const reason = describeBadBaseUrlOverride(resolved, declaredBaseUrl);
+        console.error(`[claudish] ${reason}`);
+        recordEndpointUnavailable(ctx.provider.name, `its ${reason}`);
+        return null;
+      }
+      const baseUrl = resolved.url;
       if (ep.kind === "simple") {
-        return buildSimpleHandler(ep, ctx, apiKey);
+        return buildSimpleHandler(ep, ctx, apiKey, baseUrl);
       }
-      return buildComplexHandler(ep, ctx, apiKey);
+      return buildComplexHandler(ep, ctx, apiKey, baseUrl);
     }
   };
 }
-function buildSimpleHandler(ep, ctx, apiKey) {
+function classifyEndpointBaseUrl(declared, baseUrlEnvVars) {
+  for (const candidate of baseUrlOverrideCandidates(baseUrlEnvVars)) {
+    const value = realValue(candidate.value)?.trim();
+    if (!value)
+      continue;
+    if (!isHttpUrl(value)) {
+      return { ok: false, envVar: candidate.envVar, value, source: candidate.source };
+    }
+    return { ok: true, url: stripTrailingSlash(value) };
+  }
+  return { ok: true, url: stripTrailingSlash(declared) };
+}
+function describeBadBaseUrlOverride(bad, declared) {
+  const where = bad.source === "config" ? `config.endpoints["${bad.envVar}"] is set to '${bad.value}'` : `${bad.envVar} is set to '${bad.value}'`;
+  const remedy = bad.source === "config" ? "Fix or remove it (claudish config -> Providers)." : "Fix or unset it.";
+  return `${where}, which is not a valid http(s) URL. ` + `${remedy} (Not falling back to ${declared} \u2014 the override was set on purpose.)`;
+}
+function isHttpUrl(value) {
+  try {
+    const parsed = new URL(value);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function buildSimpleHandler(ep, ctx, apiKey, baseUrl) {
   const finalModel = ep.modelPrefix ? `${ep.modelPrefix}${ctx.modelName}` : ctx.modelName;
-  const baseUrl = stripTrailingSlash(ep.url);
   if (ep.format === "openai") {
     const remoteProvider2 = {
       name: ctx.provider.name,
@@ -42756,9 +43070,8 @@ function buildSimpleHandler(ep, ctx, apiKey) {
     ...ctx.sharedOpts
   });
 }
-function buildComplexHandler(ep, ctx, apiKey) {
+function buildComplexHandler(ep, ctx, apiKey, baseUrl) {
   const finalModel = ep.modelPrefix ? `${ep.modelPrefix}${ctx.modelName}` : ctx.modelName;
-  const baseUrl = stripTrailingSlash(ep.baseUrl);
   const apiPath = ep.apiPath ?? "/v1/chat/completions";
   switch (ep.transport) {
     case "litellm": {
@@ -42830,6 +43143,9 @@ function resolveDeclaredEndpointKey(ep) {
 function stripTrailingSlash(url2) {
   return url2.replace(/\/+$/, "");
 }
+function customEndpointKeyEnvVar(name) {
+  return `CUSTOM_${sanitizeEnvName(name)}_KEY`;
+}
 function sanitizeEnvName(name) {
   return name.toUpperCase().replace(/[^A-Z0-9]/g, "_");
 }
@@ -42840,13 +43156,518 @@ var init_custom_endpoints_loader = __esm(() => {
   init_openai_api_format();
   init_authority();
   init_config_schema();
+  init_env_placeholder();
   init_composed_handler();
+  init_endpoint_diagnostics();
+  init_provider_definitions();
   init_runtime_providers();
   init_anthropic_compat();
   init_litellm();
   init_openai();
 });
 
+// src/providers/picker-alias-extra.ts
+var PROVIDER_FILTER_ALIAS_EXTRA;
+var init_picker_alias_extra = __esm(() => {
+  PROVIDER_FILTER_ALIAS_EXTRA = {
+    gem: "google",
+    zen: "opencode-zen"
+  };
+});
+
+// src/providers/predefined-catalog.ts
+var PREDEFINED_ENDPOINTS;
+var init_predefined_catalog = __esm(() => {
+  PREDEFINED_ENDPOINTS = [
+    {
+      name: "groq",
+      displayName: "Groq",
+      baseUrl: "https://api.groq.com/openai",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "GROQ_API_KEY",
+      apiKeyUrl: "https://console.groq.com/keys",
+      description: "Groq LPU inference (groq@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "cerebras",
+      displayName: "Cerebras",
+      baseUrl: "https://api.cerebras.ai",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "CEREBRAS_API_KEY",
+      apiKeyUrl: "https://cloud.cerebras.ai",
+      description: "Cerebras Inference wafer-scale hosting (cerebras@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "together",
+      displayName: "Together AI",
+      baseUrl: "https://api.together.xyz",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "TOGETHER_API_KEY",
+      apiKeyUrl: "https://api.together.xyz/settings/api-keys",
+      description: "Together AI direct inference API (together@) \u2014 distinct from the 'together-ai' vendor id models-index uses as an aggregator label",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "fireworks",
+      displayName: "Fireworks AI",
+      baseUrl: "https://api.fireworks.ai/inference",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "FIREWORKS_API_KEY",
+      apiKeyUrl: "https://fireworks.ai/account/api-keys",
+      description: "Fireworks AI serverless inference (fireworks@)",
+      evidence: {
+        tier: "probe",
+        verdict: "model-gate",
+        status: 404,
+        measuredAt: "2026-08-14",
+        note: "404 rejecting the fake model ('Model not found, inaccessible, and/or not deployed'); the bogus sibling path answered 'Path not found', so the route resolved"
+      }
+    },
+    {
+      name: "deepinfra",
+      displayName: "DeepInfra",
+      baseUrl: "https://api.deepinfra.com/v1/openai",
+      apiPath: "/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "DEEPINFRA_API_KEY",
+      apiKeyUrl: "https://deepinfra.com/dash/api_keys",
+      description: "DeepInfra hosted open models (deepinfra@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "nebius",
+      displayName: "Nebius AI Studio",
+      baseUrl: "https://api.studio.nebius.com",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "NEBIUS_API_KEY",
+      apiKeyUrl: "https://studio.nebius.com",
+      description: "Nebius AI Studio hosted open models (nebius@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "hyperbolic",
+      displayName: "Hyperbolic",
+      baseUrl: "https://api.hyperbolic.xyz",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "HYPERBOLIC_API_KEY",
+      apiKeyUrl: "https://app.hyperbolic.xyz",
+      description: "Hyperbolic decentralized GPU inference (hyperbolic@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "sambanova",
+      displayName: "SambaNova Cloud",
+      baseUrl: "https://api.sambanova.ai",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "SAMBANOVA_API_KEY",
+      apiKeyUrl: "https://cloud.sambanova.ai",
+      description: "SambaNova Cloud RDU inference (sambanova@)",
+      evidence: {
+        tier: "probe",
+        verdict: "model-gate",
+        status: 404,
+        measuredAt: "2026-08-14",
+        note: "404 naming our fake model ('The model `probe-nonexistent-model-zzz` does not exist'), i.e. the route resolved and the model was rejected before auth"
+      }
+    },
+    {
+      name: "novita",
+      displayName: "Novita AI",
+      baseUrl: "https://api.novita.ai/v3/openai",
+      apiPath: "/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "NOVITA_API_KEY",
+      apiKeyUrl: "https://novita.ai/settings",
+      description: "Novita AI hosted open models (novita@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "baseten",
+      displayName: "Baseten",
+      baseUrl: "https://inference.baseten.co",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "BASETEN_API_KEY",
+      apiKeyUrl: "https://app.baseten.co",
+      description: "Baseten model APIs (baseten@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 403, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "perplexity",
+      displayName: "Perplexity",
+      baseUrl: "https://api.perplexity.ai",
+      apiPath: "/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "PERPLEXITY_API_KEY",
+      apiKeyUrl: "https://www.perplexity.ai/settings/api",
+      description: "Perplexity Sonar search-grounded models (perplexity@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "venice",
+      displayName: "Venice AI",
+      baseUrl: "https://api.venice.ai/api",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "VENICE_API_KEY",
+      apiKeyUrl: "https://venice.ai/settings/api",
+      description: "Venice AI privacy-focused open models (venice@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "chutes",
+      displayName: "Chutes",
+      baseUrl: "https://llm.chutes.ai",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "CHUTES_API_KEY",
+      description: "Chutes decentralized inference on Bittensor (chutes@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "featherless",
+      displayName: "Featherless AI",
+      baseUrl: "https://api.featherless.ai",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "FEATHERLESS_API_KEY",
+      description: "Featherless AI serverless HuggingFace model hosting (featherless@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "parasail",
+      displayName: "Parasail",
+      baseUrl: "https://api.parasail.io",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "PARASAIL_API_KEY",
+      description: "Parasail on-demand GPU inference (parasail@)",
+      evidence: {
+        tier: "probe",
+        verdict: "auth-realm",
+        status: 401,
+        measuredAt: "2026-08-14",
+        note: "non-OpenAI error shape: plain text 'Unauthorized. Invalid token.' under content-type application/json;charset=ISO-8859-1. Classified terminal on the 401 status, so no retry is burned; see validation/error-shape-probe.md"
+      }
+    },
+    {
+      name: "inference-net",
+      displayName: "Inference.net",
+      baseUrl: "https://api.inference.net",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "INFERENCE_NET_API_KEY",
+      description: "Inference.net distributed open-model inference (inference-net@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "aimlapi",
+      displayName: "AI/ML API",
+      baseUrl: "https://api.aimlapi.com",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "AIMLAPI_API_KEY",
+      description: "AI/ML API multi-vendor aggregator (aimlapi@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "requesty",
+      displayName: "Requesty",
+      baseUrl: "https://router.requesty.ai",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "REQUESTY_API_KEY",
+      description: "Requesty LLM router (requesty@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 403, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "nanogpt",
+      displayName: "NanoGPT",
+      baseUrl: "https://nano-gpt.com/api",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "NANOGPT_API_KEY",
+      description: "NanoGPT pay-per-prompt multi-vendor aggregator (nanogpt@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "cohere",
+      displayName: "Cohere",
+      baseUrl: "https://api.cohere.ai/compatibility",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "COHERE_API_KEY",
+      apiKeyUrl: "https://dashboard.cohere.com/api-keys",
+      description: "Cohere Command models via their OpenAI-compatibility layer (cohere@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "scaleway",
+      displayName: "Scaleway Generative APIs",
+      baseUrl: "https://api.scaleway.ai",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "SCALEWAY_API_KEY",
+      apiKeyUrl: "https://console.scaleway.com",
+      description: "Scaleway Generative APIs, EU-hosted open models (scaleway@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 403, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "upstage",
+      displayName: "Upstage",
+      baseUrl: "https://api.upstage.ai",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "UPSTAGE_API_KEY",
+      apiKeyUrl: "https://console.upstage.ai",
+      description: "Upstage Solar models (upstage@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "writer",
+      displayName: "Writer",
+      baseUrl: "https://api.writer.com",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "WRITER_API_KEY",
+      description: "Writer Palmyra models (writer@)",
+      evidence: {
+        tier: "probe",
+        verdict: "auth-realm",
+        status: 401,
+        measuredAt: "2026-08-14",
+        note: 'non-OpenAI error shape: {"tpe":"fail.auth","errors":[{"description":\u2026}]} with no top-level `error` object. Classified terminal on the 401 status, so no retry is burned; see validation/error-shape-probe.md'
+      }
+    },
+    {
+      name: "moonshot-cn",
+      displayName: "Moonshot AI (China)",
+      baseUrl: "https://api.moonshot.cn",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "MOONSHOT_CN_API_KEY",
+      apiKeyUrl: "https://platform.moonshot.cn",
+      description: "Moonshot AI China-region endpoint (moonshot-cn@) \u2014 a separate product from the builtin Kimi provider reached by moonshot@/kimi@",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "tuningengines",
+      displayName: "Tuning Engines",
+      baseUrl: "https://api.tuningengines.com",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "TUNING_ENGINES_API_KEY",
+      baseUrlEnvVars: ["TUNING_ENGINES_BASE_URL"],
+      description: "Tuning Engines enterprise LLM gateway (tuningengines@); self-hosted instances point TUNING_ENGINES_BASE_URL at their own host",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    }
+  ];
+});
+
+// src/providers/predefined-endpoints.ts
+function warnOnce2(message) {
+  if (warnedMessages2.has(message))
+    return;
+  warnedMessages2.add(message);
+  console.error(message);
+}
+function activeCatalog() {
+  return catalogOverride ?? PREDEFINED_ENDPOINTS;
+}
+function reservedNamespace() {
+  const reserved = new Map;
+  for (const def of BUILTIN_PROVIDERS) {
+    reserved.set(def.name.toLowerCase(), def.name);
+    for (const shortcut of def.shortcuts) {
+      reserved.set(shortcut.toLowerCase(), def.name);
+    }
+    for (const legacy of def.legacyPrefixes) {
+      reserved.set(legacy.prefix.replace(/[/:]+$/, "").toLowerCase(), def.name);
+    }
+  }
+  for (const [alias, owner] of Object.entries(PROVIDER_FILTER_ALIAS_EXTRA)) {
+    reserved.set(alias.toLowerCase(), owner);
+  }
+  return reserved;
+}
+function readOptOut(config2) {
+  const off = { disabled: true, disable: new Set, enable: new Set };
+  if (process.env[KILL_SWITCH_ENV] === "1")
+    return off;
+  const raw = config2?.predefinedEndpoints;
+  let parsed = {};
+  if (raw !== undefined) {
+    const result = PredefinedEndpointsConfigSchema.safeParse(raw);
+    if (result.success) {
+      parsed = result.data;
+    } else {
+      warnOnce2("[claudish] config 'predefinedEndpoints' is not valid and was ignored: " + result.error.issues.map((i) => `${i.path.join(".") || "(root)"} ${i.message}`).join(", "));
+    }
+  }
+  return {
+    disabled: parsed.enabled === false,
+    disable: new Set((parsed.disable ?? []).map((n) => n.trim().toLowerCase())),
+    enable: new Set((parsed.enable ?? []).map((n) => n.trim().toLowerCase()))
+  };
+}
+function compileToCustomEndpoint(entry) {
+  return {
+    kind: "complex",
+    displayName: entry.displayName,
+    transport: entry.format,
+    baseUrl: entry.baseUrl,
+    apiPath: entry.apiPath,
+    apiKey: `\${${entry.apiKeyEnvVar}}`,
+    authScheme: entry.authScheme,
+    headers: entry.headers,
+    modelPrefix: entry.modelPrefix
+  };
+}
+function credentialEnvVars(entry) {
+  return {
+    envVar: entry.apiKeyEnvVar,
+    aliases: [...entry.apiKeyAliases ?? [], customEndpointKeyEnvVar(entry.name)]
+  };
+}
+function overridesFor(entry) {
+  const { envVar, aliases } = credentialEnvVars(entry);
+  return {
+    apiKeyEnvVar: envVar,
+    apiKeyAliases: aliases,
+    baseUrlEnvVars: entry.baseUrlEnvVars,
+    apiKeyUrl: entry.apiKeyUrl ?? "",
+    apiKeyDescription: `${entry.displayName} (${envVar})`,
+    description: entry.description ?? `${entry.displayName} (bundled endpoint)`
+  };
+}
+function loadPredefinedEndpoints(config2, opts = {}) {
+  const result = { registered: [], skipped: [] };
+  const optOut = readOptOut(config2);
+  const catalog = opts.catalog ?? activeCatalog();
+  const runtime = getRuntimeProviders();
+  const noteStale = (entry, name, reason) => {
+    if (!ownRegistrations.has(name) || !runtime.has(entry.name))
+      return;
+    warnOnce2(`[claudish] predefined endpoint '${entry.name}' is no longer eligible (${reason}) but stays ` + "registered for the rest of this process \u2014 runtime provider registration cannot be " + "undone. Restart claudish to apply the change.");
+  };
+  if (optOut.disabled) {
+    for (const entry of catalog) {
+      result.skipped.push({ name: entry.name, reason: "catalog off" });
+      noteStale(entry, entry.name.toLowerCase(), "catalog off");
+    }
+    return result;
+  }
+  const reserved = reservedNamespace();
+  const userEndpoints = new Set(Object.keys(config2?.customEndpoints ?? {}).map((n) => n.toLowerCase()));
+  const seen = new Set;
+  for (const entry of catalog) {
+    const name = entry.name.toLowerCase();
+    const skip = (reason) => result.skipped.push({ name: entry.name, reason });
+    const skipStale = (reason) => {
+      skip(reason);
+      noteStale(entry, name, reason);
+    };
+    if (seen.has(name)) {
+      warnOnce2(`[claudish] predefined endpoint '${entry.name}' appears more than once in the bundled ` + "catalog. The first row wins; the later one is ignored.");
+      skip("duplicate row");
+      continue;
+    }
+    seen.add(name);
+    const owner = reserved.get(name);
+    if (owner) {
+      const reason = `'${entry.name}' is already claimed by builtin provider '${owner}' ` + "(as its name, a shortcut, or a legacy prefix)";
+      warnOnce2(`[claudish] predefined endpoint '${entry.name}' skipped: ${reason}. ` + "The builtin wins; the bundled entry is inactive.");
+      recordEndpointUnavailable(entry.name, `bundled endpoint was skipped because ${reason}`);
+      skip("collides with builtin");
+      continue;
+    }
+    if (runtime.has(entry.name) && !ownRegistrations.has(name)) {
+      warnOnce2(`[claudish] predefined endpoint '${entry.name}' skipped: a provider named ` + `'${entry.name}' is already registered for this process.`);
+      skip("already registered");
+      continue;
+    }
+    if (userEndpoints.has(name)) {
+      if (hasLocalApiKey({ envVar: entry.apiKeyEnvVar })) {
+        warnOnce2(`[claudish] customEndpoints['${entry.name}'] replaces the bundled entry entirely; ` + `${entry.apiKeyEnvVar} no longer applies to it. Add ` + `"apiKey": "\${${entry.apiKeyEnvVar}}" to that entry to keep using it.`);
+      }
+      skipStale("replaced by customEndpoints");
+      continue;
+    }
+    if (optOut.disable.has(name)) {
+      skipStale("disabled in config");
+      continue;
+    }
+    const { envVar, aliases } = credentialEnvVars(entry);
+    const permitted = optOut.enable.has(name) || hasLocalApiKey({ envVar, aliases });
+    if (!permitted) {
+      skipStale("no local credential");
+      continue;
+    }
+    const resolvedUrl = classifyEndpointBaseUrl(entry.baseUrl, entry.baseUrlEnvVars);
+    if (!resolvedUrl.ok) {
+      const detail = describeBadBaseUrlOverride(resolvedUrl, entry.baseUrl);
+      warnOnce2(`[claudish] predefined endpoint '${entry.name}' skipped: ${detail}`);
+      recordEndpointUnavailable(entry.name, detail);
+      skipStale("invalid base URL override");
+      continue;
+    }
+    try {
+      registerEndpoint(entry.name, compileToCustomEndpoint(entry), overridesFor(entry));
+      ownRegistrations.add(name);
+      result.registered.push(entry.name);
+    } catch (err) {
+      warnOnce2(`[claudish] predefined endpoint '${entry.name}' skipped: ` + `${err instanceof Error ? err.message : String(err)}`);
+      skip("invalid catalog row");
+    }
+  }
+  return result;
+}
+var KILL_SWITCH_ENV = "CLAUDISH_NO_PREDEFINED_ENDPOINTS", warnedMessages2, ownRegistrations, catalogOverride = null;
+var init_predefined_endpoints = __esm(() => {
+  init_local_api_key();
+  init_config_schema();
+  init_custom_endpoints_loader();
+  init_endpoint_diagnostics();
+  init_picker_alias_extra();
+  init_predefined_catalog();
+  init_provider_definitions();
+  init_runtime_providers();
+  warnedMessages2 = new Set;
+  ownRegistrations = new Set;
+});
+
+// src/providers/endpoint-registration.ts
+var exports_endpoint_registration = {};
+__export(exports_endpoint_registration, {
+  invalidateEndpointRegistration: () => invalidateEndpointRegistration,
+  ensureEndpointsRegistered: () => ensureEndpointsRegistered
+});
+function ensureEndpointsRegistered(opts = {}) {
+  if (registered && !opts.force)
+    return;
+  registered = true;
+  try {
+    loadPredefinedEndpoints(opts.config ?? loadConfig());
+  } catch {}
+}
+function invalidateEndpointRegistration() {
+  registered = false;
+}
+var registered = false;
+var init_endpoint_registration = __esm(() => {
+  init_profile_config();
+  init_predefined_endpoints();
+});
+
 // src/providers/provider-registry.ts
 function resolveBaseUrl2(envVar, fallbackEnvVars, staticDefault) {
   for (const v of [envVar, ...fallbackEnvVars]) {
@@ -43715,7 +44536,9 @@ async function prepareParentRoutingContext() {
   if (!parentRoutingContextReady) {
     parentRoutingContextReady = true;
     try {
-      loadCustomEndpoints(loadConfig());
+      const config2 = loadConfig();
+      ensureEndpointsRegistered({ config: config2 });
+      loadCustomEndpoints(config2);
     } catch {}
   }
   try {
@@ -43765,6 +44588,7 @@ var init_prehydrate = __esm(() => {
   init_auto_route();
   init_catalog_client();
   init_custom_endpoints_loader();
+  init_endpoint_registration();
   init_model_parser();
   init_onepassword();
   init_provider_resolver();
@@ -44021,6 +44845,48 @@ var init_signal_watcher = __esm(() => {
   QUESTION_PATTERNS = [/\?\s*$/m, /\bchoose\b.*:/im, /\bselect\b.*:/im, /\benter\b.*:/im];
 });
 
+// src/process-tree.ts
+function signalProcessTree(proc, signal) {
+  if (KILL_PROCESS_GROUP && proc.pid) {
+    try {
+      process.kill(-proc.pid, signal);
+    } catch {}
+  }
+  try {
+    if (!proc.killed)
+      proc.kill(signal);
+  } catch {}
+}
+function waitForExit(proc, ms) {
+  if (proc.exitCode !== null || proc.signalCode !== null)
+    return Promise.resolve(true);
+  return new Promise((resolve2) => {
+    let settled = false;
+    const done = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      proc.off("exit", onExit);
+      resolve2(value);
+    };
+    const onExit = () => done(true);
+    proc.once("exit", onExit);
+    const t = setTimeout(() => done(false), ms);
+    t.unref?.();
+  });
+}
+async function terminateChildTree(proc, graceMs = TERMINATE_GRACE_MS) {
+  signalProcessTree(proc, "SIGTERM");
+  if (await waitForExit(proc, graceMs))
+    return true;
+  signalProcessTree(proc, "SIGKILL");
+  return waitForExit(proc, graceMs);
+}
+var KILL_PROCESS_GROUP, TERMINATE_GRACE_MS = 5000;
+var init_process_tree = __esm(() => {
+  KILL_PROCESS_GROUP = process.platform !== "win32";
+});
+
 // src/spawn-claudish.ts
 function resolveClaudishSpawn(env = process.env) {
   const bin = env[CLAUDISH_BIN_ENV]?.trim();
@@ -44077,7 +44943,8 @@ class SessionManager {
     const proc = spawn(spawnTarget.command, [...spawnTarget.prefixArgs, ...args], {
       cwd: opts.cwd ?? process.cwd(),
       stdio: ["pipe", "pipe", "pipe"],
-      shell: false
+      shell: false,
+      detached: KILL_PROCESS_GROUP
     });
     const scrollback = new ScrollbackBuffer(this.scrollbackCapacity);
     const watcher = new SignalWatcher(sessionId2, (sid, data) => {
@@ -44157,10 +45024,10 @@ class SessionManager {
     });
     entry.timeoutHandle = setTimeout(() => {
       if (!proc.killed) {
-        proc.kill("SIGTERM");
+        signalProcessTree(proc, "SIGTERM");
         entry.killHandle = setTimeout(() => {
           try {
-            proc.kill("SIGKILL");
+            signalProcessTree(proc, "SIGKILL");
           } catch {}
         }, KILL_GRACE_MS);
         entry.info.status = "timeout";
@@ -44218,10 +45085,10 @@ class SessionManager {
     entry.info.completedAt = new Date().toISOString();
     entry.watcher.forceState("cancelled", "Session cancelled");
     if (!entry.process.killed) {
-      entry.process.kill("SIGTERM");
+      signalProcessTree(entry.process, "SIGTERM");
       entry.killHandle = setTimeout(() => {
         try {
-          entry.process.kill("SIGKILL");
+          signalProcessTree(entry.process, "SIGKILL");
         } catch {}
       }, KILL_GRACE_MS);
     }
@@ -44252,11 +45119,11 @@ class SessionManager {
     const promises = [];
     for (const [, entry] of this.sessions) {
       if (!entry.process.killed) {
-        entry.process.kill("SIGTERM");
+        signalProcessTree(entry.process, "SIGTERM");
         promises.push(new Promise((resolve2) => {
           const timeout = setTimeout(() => {
             try {
-              entry.process.kill("SIGKILL");
+              signalProcessTree(entry.process, "SIGKILL");
             } catch {}
             resolve2();
           }, KILL_GRACE_MS);
@@ -44302,6 +45169,7 @@ class SessionManager {
 }
 var DEFAULT_MAX_SESSIONS = 20, DEFAULT_SCROLLBACK = 2000, DEFAULT_TIMEOUT = 600, MAX_TIMEOUT = 3600, KILL_GRACE_MS = 5000;
 var init_session_manager = __esm(() => {
+  init_process_tree();
   init_scrollback_buffer();
   init_signal_watcher();
 });
@@ -47534,38 +48402,6 @@ var init_native_handler = __esm(() => {
   init_anthropic_error();
 });
 
-// src/providers/api-key-map.ts
-var API_KEY_MAP;
-var init_api_key_map = __esm(() => {
-  API_KEY_MAP = {
-    litellm: { envVar: "LITELLM_API_KEY" },
-    openrouter: { envVar: "OPENROUTER_API_KEY" },
-    google: { envVar: "GEMINI_API_KEY" },
-    openai: { envVar: "OPENAI_API_KEY" },
-    minimax: { envVar: "MINIMAX_API_KEY" },
-    "minimax-coding": { envVar: "MINIMAX_CODING_API_KEY" },
-    kimi: { envVar: "MOONSHOT_API_KEY", aliases: ["KIMI_API_KEY"] },
-    "kimi-coding": { envVar: "KIMI_CODING_API_KEY" },
-    glm: { envVar: "ZHIPU_API_KEY", aliases: ["GLM_API_KEY"] },
-    "glm-coding": { envVar: "GLM_CODING_API_KEY", aliases: ["ZAI_CODING_API_KEY"] },
-    "z-ai": { envVar: "ZAI_API_KEY" },
-    deepseek: { envVar: "DEEPSEEK_API_KEY" },
-    mistralai: { envVar: "MISTRAL_API_KEY" },
-    sakana: { envVar: "SAKANA_API_KEY" },
-    "sakana-subscription": {
-      envVar: "SAKANA_SUBSCRIPTION_API_KEY",
-      aliases: ["SAKANA_CODING_API_KEY"]
-    },
-    "qwen-cloud": { envVar: "QWEN_CLOUD_PLAN_API_KEY" },
-    "qwen-payg": { envVar: "DASHSCOPE_API_KEY", aliases: ["QWEN_API_KEY"] },
-    ollamacloud: { envVar: "OLLAMA_API_KEY" },
-    "opencode-zen": { envVar: "OPENCODE_API_KEY" },
-    "opencode-zen-go": { envVar: "OPENCODE_GO_API_KEY", aliases: ["OPENCODE_API_KEY"] },
-    vertex: { envVar: "VERTEX_API_KEY", aliases: ["VERTEX_PROJECT"] },
-    poe: { envVar: "POE_API_KEY" }
-  };
-});
-
 // src/providers/devin/tool-descriptions.ts
 function currentMonthAndYear(now = new Date) {
   return `${MONTHS[now.getMonth()]} ${now.getFullYear()}`;
@@ -49411,7 +50247,9 @@ __export(exports_proxy_server, {
 });
 async function createProxyServer(port, _openrouterApiKey, model, monitorMode = false, anthropicApiKey, modelMap, options = {}) {
   try {
-    const customEpResult = loadCustomEndpoints(loadConfig());
+    const config2 = loadConfig();
+    ensureEndpointsRegistered({ config: config2 });
+    const customEpResult = loadCustomEndpoints(config2);
     if (customEpResult.registered > 0) {
       log(`[Proxy] Registered ${customEpResult.registered} custom endpoint(s) from config`);
     }
@@ -49704,9 +50542,11 @@ ${plan.hint}` : `[Route] ${plan.reason}`;
     if (hasExplicitProvider) {
       const parsedExplicit = parseModelSpec(target);
       if (parsedExplicit.provider !== "openrouter") {
-        const keyInfo = API_KEY_MAP[parsedExplicit.provider];
-        const keyNames = keyInfo ? [keyInfo.envVar, ...keyInfo.aliases ?? []].join(" or ") : undefined;
-        const hint = keyNames ? `No API key for provider "${parsedExplicit.provider}". Set ${keyNames} (env, config, or 1Password import).` : `No API key for provider "${parsedExplicit.provider}".`;
+        const recorded = getEndpointUnavailableReason(parsedExplicit.provider);
+        if (recorded) {
+          throw new RoutingError(`Explicit model "${target}" could not be routed \u2014 ${recorded}`);
+        }
+        const hint = describeMissingCredential(parsedExplicit.provider);
         throw new RoutingError(`Explicit model "${target}" could not be routed \u2014 its provider has no credential. ${hint}`);
       }
     }
@@ -49858,11 +50698,13 @@ var init_proxy_server = __esm(() => {
   init_logger();
   init_model_loader();
   init_profile_config();
-  init_api_key_map();
   init_auto_route();
   init_catalog_client();
   init_custom_endpoints_loader();
+  init_endpoint_diagnostics();
+  init_endpoint_registration();
   init_model_parser();
+  init_provider_definitions();
   init_provider_profiles();
   init_provider_registry();
   init_provider_resolver();
@@ -50214,6 +51056,7 @@ __export(exports_team_orchestrator, {
   runModels: () => runModels,
   resolveCaptureMode: () => resolveCaptureMode,
   parseJudgeVotes: () => parseJudgeVotes,
+  meaningfulStderr: () => meaningfulStderr,
   judgeResponses: () => judgeResponses,
   getStatus: () => getStatus,
   fisherYatesShuffle: () => fisherYatesShuffle,
@@ -50222,6 +51065,9 @@ __export(exports_team_orchestrator, {
   aggregateVerdict: () => aggregateVerdict,
   TEAM_CAPTURE_ENV_VAR: () => TEAM_CAPTURE_ENV_VAR,
   STDOUT_TAIL_LIMIT: () => STDOUT_TAIL_LIMIT,
+  GRACE_INTERVAL_MS: () => GRACE_INTERVAL_MS,
+  DRAIN_TIMEOUT_MS: () => DRAIN_TIMEOUT_MS,
+  DEFAULT_STALL_SECONDS: () => DEFAULT_STALL_SECONDS,
   DEFAULT_MIN_OUTPUT_BYTES: () => DEFAULT_MIN_OUTPUT_BYTES
 });
 import { spawn as spawn2 } from "child_process";
@@ -50294,6 +51140,13 @@ function classifyRunOutput(opts) {
   }
   return null;
 }
+function meaningfulStderr(stderr) {
+  if (!stderr)
+    return "";
+  return stderr.split(`
+`).filter((line) => line.trim().length > 0).filter((line) => !BENIGN_STDERR_PATTERNS.some((re) => re.test(line))).join(`
+`).trim();
+}
 function persistErrorLog(errorLogPath, header, stderr, stdoutTail) {
   const parts = [`=== ${redactSecrets(header)} ===`, ""];
   parts.push("--- stderr ---", stderr.trim() ? redactSecrets(stderr) : "(empty)", "");
@@ -50405,13 +51258,40 @@ async function runModels(sessionPath, opts = {}) {
   const minOutputBytes = opts.minOutputBytes ?? DEFAULT_MIN_OUTPUT_BYTES;
   const requirePattern = opts.requirePattern;
   const captureMode = resolveCaptureMode(opts.captureMode);
+  function reconcileTimedOutOutput(id, finalBytes, stdoutTail, stderr) {
+    const current = statusCache.models[id];
+    if (!current || current.state !== "TIMEOUT")
+      return;
+    if (finalBytes <= current.outputSize)
+      return;
+    const degraded = classifyRunOutput({
+      outputSize: finalBytes,
+      stdoutTail,
+      stderr,
+      minOutputBytes
+    });
+    if (degraded) {
+      updateModelStatus(id, { outputSize: finalBytes });
+      return;
+    }
+    updateModelStatus(id, {
+      state: "COMPLETED",
+      outputSize: finalBytes,
+      completedAt: new Date().toISOString(),
+      error: undefined
+    });
+    const note = `Recovered after the deadline: the child flushed ${finalBytes} B while shutting down, ` + "so its answer is complete and is being counted. The run still exceeded its timeout.";
+    const rt = runtimes.get(id);
+    if (rt)
+      persistErrorLog(rt.errorLogPath, `RECOVERED: ${note}`, stderr, stdoutTail);
+    opts.onStatusChange?.(id, statusCache.models[id]);
+  }
   mkdirSync12(statsDir(sessionPath), { recursive: true });
   const processes = new Map;
   const runtimes = new Map;
   const sigintHandler = () => {
     for (const [, proc] of processes) {
-      if (!proc.killed)
-        proc.kill("SIGTERM");
+      signalProcessTree(proc, "SIGTERM");
     }
     process.exit(1);
   };
@@ -50437,6 +51317,7 @@ async function runModels(sessionPath, opts = {}) {
     const proc = spawn2(teamSpawnTarget.command, [...teamSpawnTarget.prefixArgs, ...args], {
       stdio: ["pipe", "pipe", "pipe"],
       shell: false,
+      detached: KILL_PROCESS_GROUP,
       env: {
         ...process.env,
         CLAUDISH_TOKEN_FILE: tokenFileFor(sessionPath, anonId)
@@ -50497,6 +51378,7 @@ async function runModels(sessionPath, opts = {}) {
           return;
         if (statusCache.models[anonId].state === "TIMEOUT") {
           resolved = true;
+          reconcileTimedOutOutput(anonId, byteCount, stdoutTail, stderr);
           resolve4();
           return;
         }
@@ -50554,13 +51436,8 @@ async function runModels(sessionPath, opts = {}) {
       };
       outputStream.on("close", finish);
       proc.on("exit", (code) => {
-        const current = statusCache.models[anonId];
-        if (current?.state === "TIMEOUT") {
-          resolved = true;
-          resolve4();
-          return;
-        }
-        if (stderr) {
+        const timedOut = statusCache.models[anonId]?.state === "TIMEOUT";
+        if (!timedOut && meaningfulStderr(stderr)) {
           writeFileSync12(errorLogPath, redactSecrets(stderr), "utf-8");
         }
         exitCode = code;
@@ -50602,48 +51479,98 @@ async function runModels(sessionPath, opts = {}) {
   emitProgress();
   const progressHandle = setInterval(() => emitProgress("running"), POLL_MS);
   progressHandle.unref?.();
-  let timeoutHandle = null;
-  await Promise.race([
-    Promise.all(completionPromises),
-    new Promise((resolve4) => {
-      timeoutHandle = setTimeout(() => {
-        for (const [id, proc] of processes) {
-          const current = statusCache.models[id];
-          if (current.state === "RUNNING") {
-            if (!proc.killed)
-              proc.kill("SIGTERM");
-            const rt = runtimes.get(id);
-            rt?.flushPartial();
-            const stderr = rt?.getStderr() ?? "";
-            const stdoutTail = rt?.getStdoutTail() ?? "";
-            const bytes2 = rt?.getByteCount() ?? 0;
-            const detail = `Killed by the orchestrator after ${timeoutMs / 1000}s with ${bytes2} B of stdout. ` + "That figure counts the ANSWER, not the wire format, so 0 B means the child had " + `not produced an assistant message yet \u2014 "did not finish", not "produced nothing".`;
-            if (rt)
-              persistErrorLog(rt.errorLogPath, `TIMEOUT: ${detail}`, stderr, stdoutTail);
-            updateModelStatus(id, {
-              state: "TIMEOUT",
-              completedAt: new Date().toISOString(),
-              outputSize: bytes2,
-              error: rt ? {
-                model: id,
-                command: rt.command,
-                reason: "timeout",
-                detail,
-                stderrSnippet: stderr ? redactSecrets(stderr).slice(-2000) : undefined,
-                stdoutSnippet: stdoutTail ? redactSecrets(stdoutTail).slice(-2000) : undefined,
-                errorLogPath: rt.errorLogPath,
-                workDir: sessionPath
-              } : undefined
-            });
-            opts.onStatusChange?.(id, statusCache.models[id]);
-          }
+  const graceEnabled = opts.graceExtension ?? true;
+  const maxGraceMs = Math.max(0, (opts.maxGraceSeconds ?? timeoutMs / 1000) * 1000);
+  const stallMs = Math.max(0, (opts.stallSeconds ?? DEFAULT_STALL_SECONDS) * 1000);
+  const idleMsFor = (id) => {
+    const s = readTokenStats(sessionPath, id);
+    if (!s || typeof s.updated_at !== "number" || s.updated_at <= 0)
+      return null;
+    return Math.max(0, Date.now() - s.updated_at);
+  };
+  const graceStartedAt = new Map;
+  const graceUsedMs = (id, now) => {
+    const start = graceStartedAt.get(id);
+    return start === undefined ? 0 : Math.max(0, now - start);
+  };
+  const runningIds = () => [...processes.keys()].filter((id) => statusCache.models[id]?.state === "RUNNING");
+  const timeoutModel = async (id, why) => {
+    const proc = processes.get(id);
+    if (!proc || statusCache.models[id]?.state !== "RUNNING")
+      return;
+    const rt = runtimes.get(id);
+    rt?.flushPartial();
+    const stderr = rt?.getStderr() ?? "";
+    const stdoutTail = rt?.getStdoutTail() ?? "";
+    const bytes2 = rt?.getByteCount() ?? 0;
+    const grace = graceUsedMs(id, Date.now());
+    const detail = `Killed by the orchestrator after ${(timeoutMs + grace) / 1000}s ` + `(deadline ${timeoutMs / 1000}s${grace ? ` + ${grace / 1000}s grace` : ""}) ` + `with ${bytes2} B of stdout \u2014 ${why}. ` + "That figure counts the ANSWER, not the wire format, so 0 B means the child had " + `not produced an assistant message yet \u2014 "did not finish", not "produced nothing".`;
+    if (rt)
+      persistErrorLog(rt.errorLogPath, `TIMEOUT: ${detail}`, stderr, stdoutTail);
+    updateModelStatus(id, {
+      state: "TIMEOUT",
+      completedAt: new Date().toISOString(),
+      outputSize: bytes2,
+      error: rt ? {
+        model: id,
+        command: rt.command,
+        reason: "timeout",
+        detail,
+        stderrSnippet: stderr ? redactSecrets(stderr).slice(-2000) : undefined,
+        stdoutSnippet: stdoutTail ? redactSecrets(stdoutTail).slice(-2000) : undefined,
+        errorLogPath: rt.errorLogPath,
+        workDir: sessionPath
+      } : undefined
+    });
+    opts.onStatusChange?.(id, statusCache.models[id]);
+    const stopped = await terminateChildTree(proc);
+    if (!stopped) {
+      persistErrorLog(rt?.errorLogPath ?? join28(sessionPath, "errors", `${id}.log`), "TIMEOUT: child survived SIGKILL \u2014 it may still be running and billing", stderr, stdoutTail);
+    }
+  };
+  const allDone = Promise.all(completionPromises);
+  let settled = false;
+  allDone.then(() => {
+    settled = true;
+  }, () => {
+    settled = true;
+  });
+  const deadlineWatcher = (async () => {
+    await delay(timeoutMs);
+    for (;; ) {
+      if (settled)
+        return;
+      const running = runningIds();
+      if (running.length === 0)
+        return;
+      const extended = [];
+      const now = Date.now();
+      for (const id of running) {
+        const idleMs = idleMsFor(id);
+        const usedGrace = graceUsedMs(id, now);
+        if (!graceEnabled) {
+          await timeoutModel(id, "deadline reached (grace extension disabled)");
+        } else if (usedGrace >= maxGraceMs) {
+          await timeoutModel(id, `grace exhausted after ${Math.round(usedGrace / 1000)}s of extra time`);
+        } else if (idleMs === null) {
+          await timeoutModel(id, "deadline reached with no measurable progress to extend for");
+        } else if (idleMs >= stallMs) {
+          await timeoutModel(id, `no measurable progress for ${Math.round(idleMs / 1000)}s`);
+        } else {
+          if (!graceStartedAt.has(id))
+            graceStartedAt.set(id, now);
+          extended.push(id);
         }
-        resolve4();
-      }, timeoutMs);
-    })
-  ]);
-  if (timeoutHandle !== null)
-    clearTimeout(timeoutHandle);
+      }
+      if (extended.length === 0)
+        return;
+      emitProgress("running");
+      await delay(Math.min(GRACE_INTERVAL_MS, Math.max(1000, stallMs)));
+    }
+  })().catch(() => {});
+  await Promise.race([allDone, deadlineWatcher]);
+  if (!settled)
+    await Promise.race([allDone, delay(DRAIN_TIMEOUT_MS)]);
   clearInterval(progressHandle);
   emitProgress("settled");
   process.off("SIGINT", sigintHandler);
@@ -50829,14 +51756,19 @@ function formatVerdict(verdict, sessionPath) {
   }
   return output;
 }
-var TEAM_CAPTURE_ENV_VAR = "CLAUDISH_TEAM_CAPTURE", STDOUT_TAIL_LIMIT = 4000, API_ERROR_RE, BG_CEILING_RE, DEFAULT_MIN_OUTPUT_BYTES = 0, SENTINEL_MODELS;
+var TEAM_CAPTURE_ENV_VAR = "CLAUDISH_TEAM_CAPTURE", STDOUT_TAIL_LIMIT = 4000, API_ERROR_RE, BG_CEILING_RE, DEFAULT_MIN_OUTPUT_BYTES = 0, DRAIN_TIMEOUT_MS = 1e4, GRACE_INTERVAL_MS = 60000, DEFAULT_STALL_SECONDS = 90, delay = (ms) => new Promise((resolve4) => {
+  const t = setTimeout(resolve4, ms);
+  t.unref?.();
+}), BENIGN_STDERR_PATTERNS, SENTINEL_MODELS;
 var init_team_orchestrator = __esm(() => {
   init_prehydrate();
+  init_process_tree();
   init_redact();
   init_team_stats();
   init_team_stream_capture();
   API_ERROR_RE = /\[API Error:\s*([^\]]{0,300})\]/i;
   BG_CEILING_RE = /Background tasks still running after (\d+)s; terminating/i;
+  BENIGN_STDERR_PATTERNS = [/^\s*\[claude-code:unrecognized_model\]/];
   SENTINEL_MODELS = new Set([
     "internal",
     "default",
@@ -52034,6 +52966,7 @@ async function serveCommand(args) {
     console.error("[claudish serve] --models <path> is required");
     process.exit(1);
   }
+  ensureEndpointsRegistered();
   let slotMap;
   let slotIds;
   try {
@@ -52054,6 +52987,7 @@ async function serveCommand(args) {
   await new Promise(() => {});
 }
 var init_serve_command = __esm(() => {
+  init_endpoint_registration();
   init_proxy_server();
 });
 
@@ -52378,6 +53312,11 @@ function findMagmuxBinary() {
   throw new Error(`magmux not found. Install it:
   brew install MadAppGang/tap/magmux`);
 }
+function withoutControlPanes(evt) {
+  if (!Array.isArray(evt.panes))
+    return evt;
+  return { ...evt, panes: evt.panes.filter((p) => p?.control !== true) };
+}
 async function subscribeToMagmux(sockPath, onEvent) {
   let client = null;
   for (let attempt = 0;attempt < 40; attempt++) {
@@ -52414,7 +53353,7 @@ async function subscribeToMagmux(sockPath, onEvent) {
           const evt = JSON.parse(line);
           onEvent?.(evt);
           if (evt.type === "results") {
-            finalResults = evt;
+            finalResults = withoutControlPanes(evt);
           }
         } catch {}
       }
@@ -65350,7 +66289,8 @@ var init_antigravity_oauth = __esm(() => {
 var exports_auth_commands = {};
 __export(exports_auth_commands, {
   logoutCommand: () => logoutCommand,
-  loginCommand: () => loginCommand
+  loginCommand: () => loginCommand,
+  findProvider: () => findProvider
 });
 function getAuthStatus(provider) {
   const hasCredentials = provider.registryKeys.some((k) => hasOAuthCredentials(k)) || provider.name === "antigravity" && hasSharedAntigravityToken();
@@ -65865,7 +66805,7 @@ __export(exports_model_selector, {
   buildDiscoveredModelRows: () => buildDiscoveredModelRows
 });
 function isUserDeployedProvider(value) {
-  return LOCAL_OR_USER_DEPLOYED.has(value);
+  return LOCAL_OR_USER_DEPLOYED.has(value) || getRuntimeProviders().has(value);
 }
 function firebaseSlugToProviderName(slug) {
   const lower = slug.toLowerCase();
@@ -66625,7 +67565,7 @@ async function selectProfile(profiles) {
 async function confirmAction(message) {
   return dist_default4({ message, default: false });
 }
-var pickerProviderToFirebaseSlug, LOCAL_OR_USER_DEPLOYED, SUBSCRIPTION_PRICING, PROVIDER_FILTER_ALIAS_EXTRA, PICKER_COPY, PICKER_ORDER, PROVIDER_MODEL_PREFIX_OVERRIDE;
+var pickerProviderToFirebaseSlug, LOCAL_OR_USER_DEPLOYED, SUBSCRIPTION_PRICING, PICKER_COPY, PICKER_ORDER, PROVIDER_MODEL_PREFIX_OVERRIDE;
 var init_model_selector = __esm(() => {
   init_dist16();
   init_model_catalog();
@@ -66635,7 +67575,9 @@ var init_model_selector = __esm(() => {
   init_model_catalog2();
   init_model_discovery();
   init_registry2();
+  init_picker_alias_extra();
   init_provider_definitions();
+  init_runtime_providers();
   init_probe_discovery();
   pickerProviderToFirebaseSlug = {
     openrouter: "openrouter",
@@ -66663,10 +67605,6 @@ var init_model_selector = __esm(() => {
     output: "SUB",
     average: "SUB"
   };
-  PROVIDER_FILTER_ALIAS_EXTRA = {
-    gem: "google",
-    zen: "opencode-zen"
-  };
   PICKER_COPY = {
     openrouter: { description: "580+ models via unified API" },
     "opencode-zen": { name: "OpenCode Zen", description: "Free models, no API key needed" },
@@ -69369,6 +70307,38 @@ var init_probe_tui_runtime = __esm(() => {
   init_probe_tui_app();
 });
 
+// src/providers/api-key-map.ts
+var API_KEY_MAP;
+var init_api_key_map = __esm(() => {
+  API_KEY_MAP = {
+    litellm: { envVar: "LITELLM_API_KEY" },
+    openrouter: { envVar: "OPENROUTER_API_KEY" },
+    google: { envVar: "GEMINI_API_KEY" },
+    openai: { envVar: "OPENAI_API_KEY" },
+    minimax: { envVar: "MINIMAX_API_KEY" },
+    "minimax-coding": { envVar: "MINIMAX_CODING_API_KEY" },
+    kimi: { envVar: "MOONSHOT_API_KEY", aliases: ["KIMI_API_KEY"] },
+    "kimi-coding": { envVar: "KIMI_CODING_API_KEY" },
+    glm: { envVar: "ZHIPU_API_KEY", aliases: ["GLM_API_KEY"] },
+    "glm-coding": { envVar: "GLM_CODING_API_KEY", aliases: ["ZAI_CODING_API_KEY"] },
+    "z-ai": { envVar: "ZAI_API_KEY" },
+    deepseek: { envVar: "DEEPSEEK_API_KEY" },
+    mistralai: { envVar: "MISTRAL_API_KEY" },
+    sakana: { envVar: "SAKANA_API_KEY" },
+    "sakana-subscription": {
+      envVar: "SAKANA_SUBSCRIPTION_API_KEY",
+      aliases: ["SAKANA_CODING_API_KEY"]
+    },
+    "qwen-cloud": { envVar: "QWEN_CLOUD_PLAN_API_KEY" },
+    "qwen-payg": { envVar: "DASHSCOPE_API_KEY", aliases: ["QWEN_API_KEY"] },
+    ollamacloud: { envVar: "OLLAMA_API_KEY" },
+    "opencode-zen": { envVar: "OPENCODE_API_KEY" },
+    "opencode-zen-go": { envVar: "OPENCODE_GO_API_KEY", aliases: ["OPENCODE_API_KEY"] },
+    vertex: { envVar: "VERTEX_API_KEY", aliases: ["VERTEX_PROJECT"] },
+    poe: { envVar: "POE_API_KEY" }
+  };
+});
+
 // src/providers/probe-runner.ts
 function pinProbeModelSpec(link) {
   if (link.provider === "native-anthropic")
@@ -69688,6 +70658,7 @@ async function parseArgs(args) {
           probeTimeoutMs = parsed * 1000;
         }
       }
+      ensureEndpointsRegistered();
       await probeModelRouting(expandedModels, hasJsonFlag, {
         live: !noProbeFlag,
         timeoutMs: probeTimeoutMs
@@ -71029,6 +72000,7 @@ var init_cli = __esm(() => {
   init_profile_config();
   init_api_key_map();
   init_api_key_provenance();
+  init_endpoint_registration();
   init_model_parser();
   init_probe_live();
   init_probe_runner();
@@ -76734,6 +77706,7 @@ function App({ requestLogin } = {}) {
   const selectedProviderIsLocal = !!(selectedProvider.isLocal || selectedProviderDef?.isLocal);
   const selectedLocalEnabled = selectedProviderIsLocal && isLocalProviderEnabled(selectedProvider.catalogName, config3);
   const refreshConfig = useCallback3(() => {
+    ensureEndpointsRegistered({ force: true });
     setConfig(loadConfig());
     setBufStats(getBufferStats());
     setOpTick((t) => t + 1);
@@ -78287,6 +79260,7 @@ var init_App = __esm(() => {
   init_op_source();
   init_profile_config();
   init_default_routing_rules();
+  init_endpoint_registration();
   init_local_liveness();
   init_onepassword_config();
   init_onepassword();
@@ -78326,6 +79300,7 @@ import { createCliRenderer as createCliRenderer2 } from "@opentui/core";
 import { createRoot as createRoot2 } from "@opentui/react";
 import { jsxDEV as jsxDEV17 } from "@opentui/react/jsx-dev-runtime";
 async function startConfigTui() {
+  ensureEndpointsRegistered();
   setStderrQuiet(true);
   const loginRequest = {
     slug: null
@@ -78385,6 +79360,7 @@ var init_tui = __esm(() => {
   init_codex_oauth();
   init_kimi_oauth();
   init_logger();
+  init_endpoint_registration();
   init_App();
   if (isDirectRun) {
     startConfigTui().catch((err) => {
@@ -82515,6 +83491,10 @@ async function runCli() {
   }
   try {
     const cliConfig = await traceSpan("startup:parse-args", () => parseArgs2(process.argv.slice(2)));
+    await traceSpan("startup:endpoint-registration", async () => {
+      const { ensureEndpointsRegistered: ensureEndpointsRegistered2 } = await Promise.resolve().then(() => (init_endpoint_registration(), exports_endpoint_registration));
+      ensureEndpointsRegistered2();
+    });
     if (cliConfig.team && cliConfig.team.length > 0) {
       let prompt = cliConfig.claudeArgs.join(" ");
       if (cliConfig.inputFile) {