@sonnechasser/ntrp 0.1.8 → 0.2.1

package/dist/whimsy/time-bank-smoke.js

@@ -359,7 +359,7 @@ function migrateUsageIfNeeded(state) {
   if (state.usage?.first_active_at) return { state, changed: false };
   const fromCredits = rebuildFromCredits(state.credits);
   const prior = state.usage;
-  const usage2 = {
+  const usage3 = {
     sessions_closed: prior?.sessions_closed ?? 0,
     llm_calls: prior?.llm_calls ?? 0,
     input_tokens: prior?.input_tokens ?? 0,
@@ -367,7 +367,7 @@ function migrateUsageIfNeeded(state) {
     ...fromCredits,
     weekly: mergeWeekly(prior?.weekly ?? [], fromCredits.weekly)
   };
-  return { state: { ...state, usage: usage2 }, changed: true };
+  return { state: { ...state, usage: usage3 }, changed: true };
 }
 var init_usage_backfill = __esm({
   "src/whimsy/usage-backfill.ts"() {
@@ -1212,48 +1212,48 @@ function bumpWeekly2(weekly, patch) {
 }
 function touchUsage(state, patch) {
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
-  const usage2 = ensureUsage(state);
+  const usage3 = ensureUsage(state);
   return {
     ...state,
     usage: {
-      ...usage2,
+      ...usage3,
       ...patch,
-      first_active_at: usage2.first_active_at ?? now2,
+      first_active_at: usage3.first_active_at ?? now2,
       last_active_at: now2,
-      weekly: patch.weekly ?? usage2.weekly
+      weekly: patch.weekly ?? usage3.weekly
     }
   };
 }
 function recordUsageFromCredit(action, minutes) {
   if (minutes <= 0) return;
   let state = loadProgress();
-  const usage2 = ensureUsage(state);
-  const weekly = bumpWeekly2(usage2.weekly, { minutes_saved: minutes, actions: 1 });
+  const usage3 = ensureUsage(state);
+  const weekly = bumpWeekly2(usage3.weekly, { minutes_saved: minutes, actions: 1 });
   const counters = { weekly };
-  if (action === "diagnose" || action === "diagnose_findings") counters.diagnoses = usage2.diagnoses + 1;
-  if (action === "metrics" || action === "metrics_findings") counters.metrics_runs = usage2.metrics_runs + 1;
-  if (action === "deliverable" || action === "deliverable_deck") counters.deliverables = usage2.deliverables + 1;
-  if (action === "nl_answer") counters.nl_exchanges = usage2.nl_exchanges + 1;
+  if (action === "diagnose" || action === "diagnose_findings") counters.diagnoses = usage3.diagnoses + 1;
+  if (action === "metrics" || action === "metrics_findings") counters.metrics_runs = usage3.metrics_runs + 1;
+  if (action === "deliverable" || action === "deliverable_deck") counters.deliverables = usage3.deliverables + 1;
+  if (action === "nl_answer") counters.nl_exchanges = usage3.nl_exchanges + 1;
   state = touchUsage(state, counters);
   saveProgress(state);
 }
 function recordSessionClosed() {
   let state = loadProgress();
-  const usage2 = ensureUsage(state);
+  const usage3 = ensureUsage(state);
   state = touchUsage(state, {
-    sessions_closed: usage2.sessions_closed + 1,
-    weekly: bumpWeekly2(usage2.weekly, { actions: 1 })
+    sessions_closed: usage3.sessions_closed + 1,
+    weekly: bumpWeekly2(usage3.weekly, { actions: 1 })
   });
   saveProgress(state);
 }
 function recordLlmUsage(tokenUsage) {
   let state = loadProgress();
-  const usage2 = ensureUsage(state);
-  const weekly = bumpWeekly2(usage2.weekly, { llm_calls: 1 });
+  const usage3 = ensureUsage(state);
+  const weekly = bumpWeekly2(usage3.weekly, { llm_calls: 1 });
   state = touchUsage(state, {
-    llm_calls: usage2.llm_calls + 1,
-    input_tokens: usage2.input_tokens + (tokenUsage?.input_tokens ?? 0),
-    output_tokens: usage2.output_tokens + (tokenUsage?.output_tokens ?? 0),
+    llm_calls: usage3.llm_calls + 1,
+    input_tokens: usage3.input_tokens + (tokenUsage?.input_tokens ?? 0),
+    output_tokens: usage3.output_tokens + (tokenUsage?.output_tokens ?? 0),
     weekly
   });
   saveProgress(state);
@@ -6639,55 +6639,108 @@ var init_markdown = __esm({
   }
 });
 
-// src/ai/llm/catalog.ts
-function getCatalogEntry(id) {
-  return byId.get(id);
-}
-function listCatalogEntries(provider) {
-  if (!provider) return [...ENTRIES];
-  return ENTRIES.filter((e) => e.provider === provider);
-}
-function resolveRetiredModel(id) {
-  const seen = /* @__PURE__ */ new Set();
-  let current = id;
-  while (true) {
-    if (seen.has(current)) break;
-    seen.add(current);
-    const entry = byId.get(current);
-    if (!entry) return current;
-    if (entry.status === "active") return entry.id;
-    if (!entry.successor_id) {
-      const fallback = cheapestActiveInTier(entry.provider, entry.tier);
-      return fallback?.id ?? current;
-    }
-    current = entry.successor_id;
+// src/ai/llm/models-cache.ts
+import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "fs";
+import { join as join9 } from "path";
+function cachePath() {
+  return join9(ntrpHome(), "models.json");
+}
+function loadFile() {
+  if (cached) return cached;
+  const path = cachePath();
+  if (!existsSync9(path)) {
+    cached = { version: 1, providers: {} };
+    return cached;
   }
-  return id;
+  try {
+    const parsed = JSON.parse(readFileSync7(path, "utf-8"));
+    cached = { version: 1, providers: parsed.providers ?? {} };
+  } catch {
+    cached = { version: 1, providers: {} };
+  }
+  return cached;
+}
+function saveFile(file) {
+  writeFileSync7(cachePath(), JSON.stringify(file, null, 2) + "\n");
+  cached = file;
+}
+function getProviderModels(provider) {
+  return loadFile().providers[provider];
 }
-function cheapestActiveInTier(provider, tier) {
+function setProviderModels(provider, entry) {
+  const file = loadFile();
+  file.providers[provider] = entry;
+  saveFile(file);
+}
+function getCachedTierModel(provider, tier) {
+  return getProviderModels(provider)?.tier_stack?.[tier];
+}
+function findCachedModel(provider, modelId) {
+  return getProviderModels(provider)?.models.find((m) => m.id === modelId);
+}
+function cachedModelProvider(modelId) {
+  const file = loadFile();
+  for (const [provider, entry] of Object.entries(file.providers)) {
+    if (entry.models.some((m) => m.id === modelId)) return provider;
+  }
+  return void 0;
+}
+function markModelNoTools(provider, modelId) {
+  const file = loadFile();
+  const entry = file.providers[provider];
+  if (!entry) return;
+  const noTools = new Set(entry.quirks?.no_tools ?? []);
+  if (noTools.has(modelId)) return;
+  noTools.add(modelId);
+  entry.quirks = { ...entry.quirks, no_tools: [...noTools] };
+  saveFile(file);
+}
+function modelHasNoToolsQuirk(provider, modelId) {
+  return !!getProviderModels(provider)?.quirks?.no_tools?.includes(modelId);
+}
+function isProviderCacheStale(provider, ttlMs = CACHE_TTL_MS) {
+  const entry = getProviderModels(provider);
+  if (!entry) return true;
+  const fetched = Date.parse(entry.fetched_at);
+  if (Number.isNaN(fetched)) return true;
+  return Date.now() - fetched > ttlMs;
+}
+var CACHE_TTL_MS, cached;
+var init_models_cache = __esm({
+  "src/ai/llm/models-cache.ts"() {
+    "use strict";
+    init_store();
+    CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+    cached = null;
+  }
+});
+
+// src/ai/llm/catalog.ts
+function catalogTierDefault(provider, tier) {
   const candidates = ENTRIES.filter(
     (e) => e.provider === provider && e.tier === tier && e.status === "active"
   );
   if (candidates.length === 0) return void 0;
   return candidates.sort((a, b) => a.relative_cost - b.relative_cost)[0];
 }
-function getTierDefault(provider, tier) {
-  const entry = cheapestActiveInTier(provider, tier);
-  if (!entry) {
-    throw new Error(`No active ${tier}-tier model for provider ${provider} in catalog`);
-  }
-  return entry;
+function modelProviderHint(modelId) {
+  return cachedModelProvider(modelId) ?? byId.get(modelId)?.provider;
 }
-function resolveModel(provider, tier, override) {
-  if (override) {
-    const entry = byId.get(override);
-    if (!entry) return resolveRetiredModel(override);
-    if (entry.status === "retired") return resolveRetiredModel(override);
-    return entry.id;
-  }
-  return getTierDefault(provider, tier).id;
+function overrideForProvider(override, provider, activeProvider) {
+  if (!override) return void 0;
+  const hint = modelProviderHint(override);
+  if (hint) return hint === provider ? override : void 0;
+  return provider === activeProvider ? override : void 0;
+}
+function resolveModelSafe(provider, tier, override) {
+  if (override) return override;
+  const discovered = getCachedTierModel(provider, tier);
+  if (discovered) return discovered;
+  return catalogTierDefault(provider, tier)?.id;
 }
 function formatModelLabel(provider, modelId) {
+  const cachedName = findCachedModel(provider, modelId)?.display_name;
+  if (cachedName) return `${provider}/${cachedName}`;
   const entry = byId.get(modelId);
   return entry ? `${provider}/${entry.display_name}` : `${provider}/${modelId}`;
 }
@@ -6695,6 +6748,7 @@ var ENTRIES, byId;
 var init_catalog = __esm({
   "src/ai/llm/catalog.ts"() {
     "use strict";
+    init_models_cache();
     ENTRIES = [
       {
         id: "claude-opus-4-6",
@@ -6779,6 +6833,9 @@ function formatLlmAttribution(meta) {
   return line;
 }
 function printLlmAttribution(meta) {
+  for (const notice of meta.notices ?? []) {
+    console.log(chalk6.dim(`  ${notice}`));
+  }
   const line = formatLlmAttribution(meta);
   if (line) console.log(chalk6.dim(`  ${line}`));
 }
@@ -7096,6 +7153,7 @@ async function renderDiagnoseStream(options) {
     let modelUsed = "";
     let providerUsed;
     let failover;
+    let notices;
     let rawPrompt = "";
     try {
       for await (const event of runFindings(fullResult)) {
@@ -7111,6 +7169,7 @@ async function renderDiagnoseStream(options) {
           modelUsed = event.model_used;
           providerUsed = event.provider_used;
           failover = event.failover;
+          notices = event.usage?.notices;
           rawPrompt = event.raw_prompt;
         }
       }
@@ -7134,7 +7193,8 @@ async function renderDiagnoseStream(options) {
       printLlmAttribution({
         model_used: modelUsed,
         provider_used: providerUsed,
-        failover
+        failover,
+        notices
       });
     } catch (err) {
       findingsSpinner.fail(deep ? "Agentic investigation failed" : "AI findings failed");
@@ -7189,10 +7249,232 @@ var init_terminal = __esm({
   }
 });
 
+// src/ai/llm/providers.ts
+var providers_exports = {};
+__export(providers_exports, {
+  findSpecByConfigKey: () => findSpecByConfigKey,
+  getProviderSpec: () => getProviderSpec,
+  isEndpointEnabled: () => isEndpointEnabled,
+  keyConfigNameFor: () => keyConfigNameFor,
+  listProviderSpecs: () => listProviderSpecs,
+  loadCustomProviders: () => loadCustomProviders,
+  modelsUrl: () => modelsUrl,
+  providerLabel: () => providerLabel,
+  removeCustomProvider: () => removeCustomProvider,
+  resetProvidersCache: () => resetProvidersCache,
+  saveCustomProvider: () => saveCustomProvider
+});
+import { existsSync as existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "fs";
+import { join as join10 } from "path";
+function providersPath() {
+  return join10(ntrpHome(), "providers.json");
+}
+function loadCustomProviders() {
+  if (cachedEntries) return cachedEntries;
+  const path = providersPath();
+  if (!existsSync10(path)) {
+    cachedEntries = [];
+    return cachedEntries;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync8(path, "utf-8"));
+    cachedEntries = Array.isArray(parsed.providers) ? parsed.providers : [];
+  } catch {
+    cachedEntries = [];
+  }
+  return cachedEntries;
+}
+function saveCustomProvider(entry) {
+  const entries = loadCustomProviders().filter((e) => e.id !== entry.id);
+  entries.push(entry);
+  writeFileSync8(providersPath(), JSON.stringify({ version: 1, providers: entries }, null, 2) + "\n");
+  cachedEntries = entries;
+}
+function removeCustomProvider(id) {
+  const entries = loadCustomProviders().filter((e) => e.id !== id);
+  writeFileSync8(providersPath(), JSON.stringify({ version: 1, providers: entries }, null, 2) + "\n");
+  cachedEntries = entries;
+}
+function resetProvidersCache() {
+  cachedEntries = null;
+}
+function customEntryToSpec(entry) {
+  return {
+    id: entry.id,
+    label: entry.label ?? entry.id,
+    api: "openai-compat",
+    base_url: entry.base_url.replace(/\/+$/, ""),
+    key_prefixes: [],
+    shared_prefixes: [],
+    key_config_name: keyConfigNameFor(entry.id),
+    requires_key: entry.requires_key ?? false,
+    custom: true
+  };
+}
+function keyConfigNameFor(providerId) {
+  return providerId === "anthropic" ? "api-key" : `${providerId}-api-key`;
+}
+function listProviderSpecs() {
+  const customs = loadCustomProviders();
+  const customById = new Map(customs.map((e) => [e.id, e]));
+  const specs = BUILTIN_SPECS.map((spec) => {
+    const override = customById.get(spec.id);
+    if (override?.base_url) {
+      return { ...spec, base_url: override.base_url.replace(/\/+$/, "") };
+    }
+    return spec;
+  });
+  for (const entry of customs) {
+    if (!BUILTIN_SPECS.some((s) => s.id === entry.id)) {
+      specs.push(customEntryToSpec(entry));
+    }
+  }
+  return specs;
+}
+function getProviderSpec(id) {
+  return listProviderSpecs().find((s) => s.id === id);
+}
+function findSpecByConfigKey(configKey) {
+  return listProviderSpecs().find((s) => s.key_config_name === configKey);
+}
+function isEndpointEnabled(id) {
+  const entry = loadCustomProviders().find((e) => e.id === id);
+  return !!entry && entry.enabled !== false;
+}
+function modelsUrl(spec) {
+  if (spec.api === "anthropic") return `${spec.base_url}/v1/models?limit=100`;
+  return `${spec.base_url}/models`;
+}
+function providerLabel(id) {
+  return getProviderSpec(id)?.label ?? id;
+}
+var BUILTIN_SPECS, cachedEntries;
+var init_providers = __esm({
+  "src/ai/llm/providers.ts"() {
+    "use strict";
+    init_store();
+    BUILTIN_SPECS = [
+      {
+        id: "anthropic",
+        label: "Anthropic",
+        api: "anthropic",
+        base_url: "https://api.anthropic.com",
+        key_prefixes: ["sk-ant-"],
+        shared_prefixes: [],
+        key_config_name: "api-key",
+        requires_key: true
+      },
+      {
+        id: "openai",
+        label: "OpenAI",
+        api: "openai-compat",
+        base_url: "https://api.openai.com/v1",
+        key_prefixes: ["sk-proj-", "sk-svcacct-", "sk-admin-"],
+        shared_prefixes: ["sk-"],
+        key_config_name: "openai-api-key",
+        env_var: "OPENAI_API_KEY",
+        requires_key: true
+      },
+      {
+        id: "google",
+        label: "Google Gemini",
+        api: "openai-compat",
+        base_url: "https://generativelanguage.googleapis.com/v1beta/openai",
+        key_prefixes: ["AIza"],
+        shared_prefixes: [],
+        key_config_name: "google-api-key",
+        requires_key: true
+      },
+      {
+        id: "groq",
+        label: "Groq",
+        api: "openai-compat",
+        base_url: "https://api.groq.com/openai/v1",
+        key_prefixes: ["gsk_"],
+        shared_prefixes: [],
+        key_config_name: "groq-api-key",
+        requires_key: true
+      },
+      {
+        id: "mistral",
+        label: "Mistral",
+        api: "openai-compat",
+        base_url: "https://api.mistral.ai/v1",
+        key_prefixes: [],
+        shared_prefixes: [],
+        key_config_name: "mistral-api-key",
+        requires_key: true
+      },
+      {
+        id: "deepseek",
+        label: "DeepSeek",
+        api: "openai-compat",
+        base_url: "https://api.deepseek.com/v1",
+        key_prefixes: [],
+        shared_prefixes: ["sk-"],
+        key_config_name: "deepseek-api-key",
+        requires_key: true
+      },
+      {
+        id: "xai",
+        label: "xAI",
+        api: "openai-compat",
+        base_url: "https://api.x.ai/v1",
+        key_prefixes: ["xai-"],
+        shared_prefixes: [],
+        key_config_name: "xai-api-key",
+        requires_key: true
+      },
+      {
+        id: "openrouter",
+        label: "OpenRouter",
+        api: "openai-compat",
+        base_url: "https://openrouter.ai/api/v1",
+        key_prefixes: ["sk-or-"],
+        shared_prefixes: [],
+        key_config_name: "openrouter-api-key",
+        requires_key: true
+      },
+      {
+        id: "together",
+        label: "Together AI",
+        api: "openai-compat",
+        base_url: "https://api.together.xyz/v1",
+        key_prefixes: [],
+        shared_prefixes: [],
+        key_config_name: "together-api-key",
+        requires_key: true
+      },
+      {
+        id: "fireworks",
+        label: "Fireworks AI",
+        api: "openai-compat",
+        base_url: "https://api.fireworks.ai/inference/v1",
+        key_prefixes: ["fw_"],
+        shared_prefixes: [],
+        key_config_name: "fireworks-api-key",
+        requires_key: true
+      },
+      {
+        id: "ollama",
+        label: "Ollama (local)",
+        api: "openai-compat",
+        base_url: "http://localhost:11434/v1",
+        key_prefixes: [],
+        shared_prefixes: [],
+        key_config_name: "ollama-api-key",
+        requires_key: false
+      }
+    ];
+    cachedEntries = null;
+  }
+});
+
 // src/config/llm-config.ts
 function parseProvider(raw) {
-  if (raw === "anthropic" || raw === "openai") return raw;
-  return void 0;
+  if (!raw?.trim()) return void 0;
+  const id = raw.trim();
+  return getProviderSpec(id) ? id : void 0;
 }
 function parseTier(raw) {
   if (raw === "high" || raw === "medium" || raw === "low") return raw;
@@ -7200,7 +7482,7 @@ function parseTier(raw) {
 }
 function parseFailoverOrder(raw) {
   if (!raw?.trim()) return ["openai"];
-  return raw.split(",").map((s) => s.trim()).filter((s) => s === "anthropic" || s === "openai");
+  return raw.split(",").map((s) => s.trim()).filter((s) => !!s && !!getProviderSpec(s));
 }
 function parseAutoFailover(raw) {
   if (!raw) return false;
@@ -7215,30 +7497,42 @@ function getOpenAiApiKey() {
   if (fromConfig) return fromConfig;
   return process.env.OPENAI_API_KEY?.trim() || void 0;
 }
+function getProviderApiKey(provider) {
+  const spec = getProviderSpec(provider);
+  if (!spec) return void 0;
+  const record = loadConfig();
+  const fromConfig = record[spec.key_config_name]?.trim();
+  if (fromConfig) return fromConfig;
+  if (spec.env_var) {
+    const fromEnv = process.env[spec.env_var]?.trim();
+    if (fromEnv) return fromEnv;
+  }
+  return void 0;
+}
 function hasProviderKey(provider) {
-  if (provider === "anthropic") return !!getAnthropicApiKey();
-  return !!getOpenAiApiKey();
+  const spec = getProviderSpec(provider);
+  if (!spec) return false;
+  if (!spec.requires_key) return isEndpointEnabled(spec.id) || !!getProviderApiKey(provider);
+  return !!getProviderApiKey(provider);
 }
 function getAvailableProviders() {
-  const out = [];
-  if (hasProviderKey("anthropic")) out.push("anthropic");
-  if (hasProviderKey("openai")) out.push("openai");
-  return out;
+  return listProviderSpecs().filter((s) => hasProviderKey(s.id)).map((s) => s.id);
 }
 function hasAnyLlmProvider() {
   return getAvailableProviders().length > 0;
 }
+function hasKeylessConfiguredProvider() {
+  return listProviderSpecs().some((s) => !s.requires_key && hasProviderKey(s.id));
+}
 function applyLazyMigration(config) {
   if (migrated) return;
   migrated = true;
   let changed = false;
   const record = config;
   if (!record["llm-primary"]) {
-    if (record["api-key"]) {
-      record["llm-primary"] = "anthropic";
-      changed = true;
-    } else if (record["openai-api-key"] || process.env.OPENAI_API_KEY) {
-      record["llm-primary"] = "openai";
+    const available = getAvailableProviders();
+    if (available.length > 0) {
+      record["llm-primary"] = available[0];
       changed = true;
     }
   }
@@ -7278,20 +7572,20 @@ function loadLlmConfig() {
     openaiKey: getOpenAiApiKey()
   };
 }
-function getProviderApiKey(provider) {
-  if (provider === "anthropic") return getAnthropicApiKey();
-  return getOpenAiApiKey();
-}
 function getInvestigationApiKey(provider) {
   if (provider === "anthropic") {
     return process.env.NTRP_INVESTIGATION_API_KEY?.trim() || getAnthropicApiKey();
   }
-  return process.env.NTRP_INVESTIGATION_OPENAI_KEY?.trim() || getOpenAiApiKey();
+  if (provider === "openai") {
+    return process.env.NTRP_INVESTIGATION_OPENAI_KEY?.trim() || getOpenAiApiKey();
+  }
+  return getProviderApiKey(provider);
 }
 var migrated;
 var init_llm_config = __esm({
   "src/config/llm-config.ts"() {
     "use strict";
+    init_providers();
     init_store();
     migrated = false;
   }
@@ -7309,7 +7603,13 @@ function resolvePrimaryApiKey(ctx) {
   if (isInvestigationMode(ctx)) {
     return getInvestigationApiKey(primary) ?? getInvestigationApiKey("anthropic") ?? getInvestigationApiKey("openai");
   }
-  return getProviderApiKey(primary) ?? getProviderApiKey("anthropic") ?? getProviderApiKey("openai");
+  const primaryKey = getProviderApiKey(primary);
+  if (primaryKey) return primaryKey;
+  for (const provider of getAvailableProviders()) {
+    const key = getProviderApiKey(provider);
+    if (key) return key;
+  }
+  return void 0;
 }
 function canUseReplAi(ctx) {
   if (!ctx) return false;
@@ -7320,25 +7620,21 @@ function canUseReplAi(ctx) {
 }
 function assertReplAi(ctx) {
   if (!ctx) {
-    throw new Error(
-      "AI features require stored API keys. Run `ntrp`, then /config set api-key or /config set openai-api-key."
-    );
+    throw new Error(`AI features require stored API keys. Run \`ntrp\`, then /connect.`);
   }
   if (!canUseReplAi(ctx)) {
     if (!hasAnyLlmProvider()) {
-      throw new Error(
-        "No LLM API key configured. Run: /config set api-key (Anthropic) and/or /config set openai-api-key"
-      );
+      throw new Error(NO_KEY_MESSAGE);
     }
     throw new Error(
       "AI features run only in the interactive REPL or headless mode with stored keys."
     );
   }
   const key = resolvePrimaryApiKey(ctx);
-  if (!key) {
-    throw new Error("No LLM API key configured. Run: /config set api-key or /config set openai-api-key");
+  if (!key && !hasKeylessConfiguredProvider()) {
+    throw new Error(NO_KEY_MESSAGE);
   }
-  return key;
+  return key ?? "";
 }
 function hasEnvApiKeyHint() {
   return !!(process.env.ANTHROPIC_API_KEY ?? process.env.NTRP_API_KEY ?? process.env.OPENAI_API_KEY);
@@ -7351,10 +7647,12 @@ function describeLlmReadiness() {
     openai: providers.includes("openai")
   };
 }
+var NO_KEY_MESSAGE;
 var init_gate = __esm({
   "src/ai/llm/gate.ts"() {
     "use strict";
     init_llm_config();
+    NO_KEY_MESSAGE = "No LLM API key configured. Run /connect and paste any provider's key (Anthropic, OpenAI, Groq, Gemini, ...).";
   }
 });
 
@@ -7379,18 +7677,18 @@ var init_repl_api = __esm({
 });
 
 // src/demo/taxonomy-cache.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync7, existsSync as existsSync9, mkdirSync as mkdirSync7, unlinkSync as unlinkSync4 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync9, existsSync as existsSync11, mkdirSync as mkdirSync7, unlinkSync as unlinkSync4 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join9 } from "path";
+import { join as join11 } from "path";
 function ensureDir6() {
-  if (!existsSync9(NTRP_DIR4)) {
+  if (!existsSync11(NTRP_DIR4)) {
     mkdirSync7(NTRP_DIR4, { recursive: true });
   }
 }
 function loadCachedTaxonomy(profile) {
-  if (!existsSync9(TAXONOMY_PATH)) return null;
+  if (!existsSync11(TAXONOMY_PATH)) return null;
   try {
-    const parsed = JSON.parse(readFileSync7(TAXONOMY_PATH, "utf-8"));
+    const parsed = JSON.parse(readFileSync9(TAXONOMY_PATH, "utf-8"));
     if (!parsed || typeof parsed !== "object") return null;
     if (parsed.profile_updated_at !== profile.updated_at) return null;
     return parsed;
@@ -7400,10 +7698,10 @@ function loadCachedTaxonomy(profile) {
 }
 function saveCachedTaxonomy(taxonomy) {
   ensureDir6();
-  writeFileSync7(TAXONOMY_PATH, JSON.stringify(taxonomy, null, 2) + "\n");
+  writeFileSync9(TAXONOMY_PATH, JSON.stringify(taxonomy, null, 2) + "\n");
 }
 function invalidateTaxonomy() {
-  if (existsSync9(TAXONOMY_PATH)) {
+  if (existsSync11(TAXONOMY_PATH)) {
     try {
       unlinkSync4(TAXONOMY_PATH);
     } catch {
@@ -7414,8 +7712,8 @@ var NTRP_DIR4, TAXONOMY_PATH;
 var init_taxonomy_cache = __esm({
   "src/demo/taxonomy-cache.ts"() {
     "use strict";
-    NTRP_DIR4 = join9(homedir3(), ".ntrp");
-    TAXONOMY_PATH = join9(NTRP_DIR4, "demo-taxonomy.json");
+    NTRP_DIR4 = join11(homedir3(), ".ntrp");
+    TAXONOMY_PATH = join11(NTRP_DIR4, "demo-taxonomy.json");
   }
 });
 
@@ -7440,6 +7738,12 @@ var init_types2 = __esm({
 });
 
 // src/ai/llm/errors.ts
+function isToolsUnsupportedMessage(message) {
+  const msg = message.toLowerCase();
+  const mentionsTools = msg.includes("tool") || msg.includes("function");
+  const mentionsUnsupported = msg.includes("not support") || msg.includes("unsupported") || msg.includes("no support") || msg.includes("not available") || msg.includes("not enabled");
+  return mentionsTools && mentionsUnsupported;
+}
 function mapAnthropicError(err, provider) {
   const e = err;
   const status = e.status;
@@ -7457,6 +7761,9 @@ function mapAnthropicError(err, provider) {
   if (status === 503) {
     return new LlmError("OVERLOADED", message, provider, status);
   }
+  if (isToolsUnsupportedMessage(message)) {
+    return new LlmError("TOOLS_UNSUPPORTED", message, provider, status);
+  }
   if (status === 404 || message.toLowerCase().includes("model")) {
     return new LlmError("MODEL_NOT_FOUND", message, provider, status);
   }
@@ -7465,6 +7772,11 @@ function mapAnthropicError(err, provider) {
   }
   return new LlmError("UNKNOWN", message, provider, status);
 }
+function isModelNotFoundMessage(message) {
+  const msg = message.toLowerCase();
+  if (!msg.includes("model")) return false;
+  return msg.includes("not found") || msg.includes("does not exist") || msg.includes("decommissioned") || msg.includes("deprecated") || msg.includes("retired") || msg.includes("do not have access") || msg.includes("invalid model");
+}
 function mapOpenAiError(err, provider) {
   const e = err;
   const status = e.status;
@@ -7479,7 +7791,10 @@ function mapOpenAiError(err, provider) {
   if (status === 503 || code === "server_error") {
     return new LlmError("OVERLOADED", message, provider, status);
   }
-  if (status === 404 || code === "model_not_found") {
+  if (isToolsUnsupportedMessage(message)) {
+    return new LlmError("TOOLS_UNSUPPORTED", message, provider, status);
+  }
+  if (status === 404 || code === "model_not_found" || code === "model_decommissioned" || isModelNotFoundMessage(message)) {
     return new LlmError("MODEL_NOT_FOUND", message, provider, status);
   }
   if (code === "context_length_exceeded") {
@@ -7615,8 +7930,15 @@ var init_anthropic = __esm({
   }
 });
 
-// src/ai/llm/adapters/openai.ts
+// src/ai/llm/adapters/openai-compat.ts
 import OpenAI from "openai";
+function makeClient(apiKey, baseUrl) {
+  return new OpenAI({
+    // Keyless endpoints (Ollama) still need a non-empty string for the SDK.
+    apiKey: apiKey || "local",
+    ...baseUrl ? { baseURL: baseUrl } : {}
+  });
+}
 function toOpenAiTools(tools) {
   return tools.map((t) => ({
     type: "function",
@@ -7685,9 +8007,8 @@ function parseResponse2(message) {
     assistant_message: { role: "assistant", content: text, tool_calls }
   };
 }
-async function openaiComplete(apiKey, model, req) {
-  const provider = "openai";
-  const client = new OpenAI({ apiKey });
+async function openaiCompatComplete(provider, baseUrl, apiKey, model, req) {
+  const client = makeClient(apiKey, baseUrl);
   try {
     const response = await client.chat.completions.create({
       model,
@@ -7697,7 +8018,7 @@ async function openaiComplete(apiKey, model, req) {
     });
     const choice = response.choices[0];
     if (!choice?.message) {
-      throw new Error("OpenAI returned no message");
+      throw new Error(`${provider} returned no message`);
     }
     const parsed = parseResponse2(choice.message);
     if (response.usage) {
@@ -7708,15 +8029,11 @@ async function openaiComplete(apiKey, model, req) {
     }
     return parsed;
   } catch (err) {
-    if (err instanceof OpenAI.APIError) {
-      throw mapOpenAiError(err, provider);
-    }
     throw mapOpenAiError(err, provider);
   }
 }
-async function* openaiStream(apiKey, model, req) {
-  const provider = "openai";
-  const client = new OpenAI({ apiKey });
+async function* openaiCompatStream(provider, baseUrl, apiKey, model, req) {
+  const client = makeClient(apiKey, baseUrl);
   try {
     const stream = await client.chat.completions.create({
       model,
@@ -7729,19 +8046,316 @@ async function* openaiStream(apiKey, model, req) {
       if (delta) yield { type: "text_delta", text: delta };
     }
   } catch (err) {
-    if (err instanceof OpenAI.APIError) {
-      throw mapOpenAiError(err, provider);
-    }
     throw mapOpenAiError(err, provider);
   }
 }
-var init_openai = __esm({
-  "src/ai/llm/adapters/openai.ts"() {
+var init_openai_compat = __esm({
+  "src/ai/llm/adapters/openai-compat.ts"() {
     "use strict";
     init_errors2();
   }
 });
 
+// src/ai/llm/http.ts
+import { readFileSync as readFileSync10 } from "fs";
+function fixtureResponse(url, headers) {
+  try {
+    const raw = readFileSync10(process.env.NTRP_LLM_HTTP_FIXTURE, "utf-8");
+    const entries = JSON.parse(raw);
+    const headerValues = Object.values(headers).join(" ");
+    for (const entry of entries) {
+      if (!url.includes(entry.url_includes)) continue;
+      if (entry.auth_includes && !headerValues.includes(entry.auth_includes)) continue;
+      return { status: entry.status, ok: entry.status >= 200 && entry.status < 300, body: entry.body };
+    }
+  } catch {
+  }
+  return { status: 0, ok: false, body: void 0 };
+}
+async function llmHttpGetJson(url, headers, timeoutMs = 6e3) {
+  if (process.env.NTRP_LLM_HTTP_FIXTURE) {
+    return fixtureResponse(url, headers);
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, { method: "GET", headers, signal: controller.signal });
+    let body;
+    try {
+      body = await res.json();
+    } catch {
+      body = void 0;
+    }
+    return { status: res.status, ok: res.ok, body };
+  } catch {
+    return { status: 0, ok: false, body: void 0 };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var init_http = __esm({
+  "src/ai/llm/http.ts"() {
+    "use strict";
+  }
+});
+
+// src/ai/llm/ranking.ts
+function compareModels(a, b) {
+  const createdA = a.created ?? 0;
+  const createdB = b.created ?? 0;
+  if (createdA !== createdB) return createdB - createdA;
+  const versionA = extractVersion(a.id);
+  const versionB = extractVersion(b.id);
+  if (versionA !== versionB) return versionB - versionA;
+  if (a.id.length !== b.id.length) return a.id.length - b.id.length;
+  return a.id.localeCompare(b.id);
+}
+function extractVersion(id) {
+  const match = id.match(/(\d+(?:\.\d+)?)/);
+  return match ? Number(match[1]) : 0;
+}
+function pickByPatterns(models, patterns) {
+  for (const pattern of patterns) {
+    const matches = models.filter((m) => pattern.test(m.id));
+    if (matches.length > 0) return [...matches].sort(compareModels)[0];
+  }
+  return void 0;
+}
+function genericBucket(model) {
+  if (GENERIC_HIGH.test(model.id)) return "high";
+  if (GENERIC_LOW.test(model.id)) return "low";
+  return "medium";
+}
+function genericPick(models, tier) {
+  const bucket = models.filter((m) => genericBucket(m) === tier);
+  if (bucket.length > 0) return [...bucket].sort(compareModels)[0];
+  return void 0;
+}
+function rankModels(providerId, models) {
+  if (models.length === 0) return null;
+  const preferences = PROVIDER_PREFERENCES[providerId];
+  const picks = {};
+  for (const tier of ["high", "medium", "low"]) {
+    const preferred = preferences ? pickByPatterns(models, preferences[tier]) : void 0;
+    const generic = preferred ?? genericPick(models, tier);
+    if (generic) picks[tier] = generic.id;
+  }
+  const anyModel = [...models].sort(compareModels)[0].id;
+  const high = picks.high ?? picks.medium ?? picks.low ?? anyModel;
+  const medium = picks.medium ?? picks.high ?? picks.low ?? anyModel;
+  const low = picks.low ?? picks.medium ?? picks.high ?? anyModel;
+  return { high, medium, low };
+}
+var PROVIDER_PREFERENCES, GENERIC_LOW, GENERIC_HIGH;
+var init_ranking = __esm({
+  "src/ai/llm/ranking.ts"() {
+    "use strict";
+    PROVIDER_PREFERENCES = {
+      anthropic: {
+        high: [/^claude-opus/i, /^claude-sonnet/i],
+        medium: [/^claude-sonnet/i, /^claude-haiku/i],
+        low: [/^claude-haiku/i, /^claude-sonnet/i]
+      },
+      openai: {
+        high: [/^gpt-5(?!.*(mini|nano|chat))/i, /^gpt-4\.1(?!.*(mini|nano))/i, /^gpt-4o(?!.*mini)/i, /^o3(?!.*mini)/i],
+        medium: [/^gpt-5.*mini/i, /^gpt-4\.1-mini/i, /^gpt-4o-mini/i, /^o4-mini/i],
+        low: [/^gpt-5.*nano/i, /^gpt-4\.1-nano/i, /^gpt-4o-mini/i]
+      },
+      google: {
+        high: [/^gemini-[\d.]+-pro/i, /^gemini-[\d.]+-flash(?!-lite)/i],
+        medium: [/^gemini-[\d.]+-flash(?!-lite|-8b)/i, /^gemini-[\d.]+-pro/i],
+        low: [/^gemini-[\d.]+-flash-lite/i, /flash-8b/i, /^gemini-[\d.]+-flash(?!-lite)/i]
+      },
+      groq: {
+        high: [/llama-3\.3-70b/i, /gpt-oss-120b/i, /70b/i, /deepseek-r1/i],
+        medium: [/llama-3\.1-8b-instant/i, /gpt-oss-20b/i, /llama.*8b/i],
+        low: [/8b-instant/i, /llama.*8b/i, /gemma/i]
+      },
+      deepseek: {
+        high: [/reasoner/i, /chat/i],
+        medium: [/chat/i],
+        low: [/chat/i]
+      },
+      mistral: {
+        high: [/large/i, /medium/i],
+        medium: [/medium/i, /^mistral-small/i],
+        low: [/ministral/i, /small/i, /tiny/i]
+      },
+      xai: {
+        high: [/^grok-\d+(?!.*(mini|fast))/i, /^grok(?!.*(mini|fast))/i],
+        medium: [/^grok.*mini(?!.*fast)/i, /^grok.*fast/i],
+        low: [/^grok.*mini.*fast/i, /^grok.*mini/i]
+      },
+      openrouter: {
+        high: [/^openrouter\/auto$/i, /claude.*opus/i, /^openai\/gpt-5(?!.*(mini|nano))/i, /gemini.*pro/i],
+        medium: [/claude.*sonnet/i, /gpt-5.*mini/i, /gpt-4\.1-mini/i, /gemini.*flash(?!-lite)/i],
+        low: [/claude.*haiku/i, /nano/i, /flash-lite/i, /mini/i]
+      }
+    };
+    GENERIC_LOW = /(mini|nano|lite|tiny|micro|small|haiku|instant|flash|turbo|\b0?\.?5b\b|\b[1-8]b\b)/i;
+    GENERIC_HIGH = /(opus|ultra|large|max\b|\bpro\b|405b|253b|235b|120b|72b|70b|reason|-r1\b|think|deep)/i;
+  }
+});
+
+// src/ai/llm/discovery.ts
+var discovery_exports = {};
+__export(discovery_exports, {
+  fetchProviderModels: () => fetchProviderModels,
+  filterChatModels: () => filterChatModels,
+  refreshProviderModels: () => refreshProviderModels,
+  refreshStaleProviderCaches: () => refreshStaleProviderCaches,
+  rerankExcluding: () => rerankExcluding,
+  storeDiscoveredModels: () => storeDiscoveredModels
+});
+function authHeaders(spec, apiKey) {
+  if (spec.api === "anthropic") {
+    return { "x-api-key": apiKey ?? "", "anthropic-version": "2023-06-01" };
+  }
+  return apiKey ? { Authorization: `Bearer ${apiKey}` } : {};
+}
+function normalizeItem(spec, item) {
+  let id = item.id ?? "";
+  if (!id) return null;
+  if (id.startsWith("models/")) id = id.slice("models/".length);
+  const model = { id };
+  const display2 = item.display_name ?? item.name;
+  if (display2 && display2 !== id) model.display_name = display2;
+  if (typeof item.created === "number") model.created = item.created;
+  else if (item.created_at) {
+    const parsed = Date.parse(item.created_at);
+    if (!Number.isNaN(parsed)) model.created = Math.floor(parsed / 1e3);
+  }
+  if (typeof item.context_length === "number") model.context_length = item.context_length;
+  if (Array.isArray(item.supported_parameters)) {
+    model.supports_tools = item.supported_parameters.includes("tools");
+  }
+  return model;
+}
+async function fetchProviderModels(spec, apiKey, timeoutMs = 6e3) {
+  const headers = authHeaders(spec, apiKey);
+  if (spec.api === "anthropic") {
+    const models2 = [];
+    let url = modelsUrl(spec);
+    for (let page = 0; page < 5 && url; page++) {
+      const res2 = await llmHttpGetJson(url, headers, timeoutMs);
+      if (!res2.ok) return models2.length > 0 ? { ok: true, models: models2 } : { ok: false, status: res2.status };
+      const body2 = res2.body;
+      for (const item of body2?.data ?? []) {
+        const model = normalizeItem(spec, item);
+        if (model) models2.push(model);
+      }
+      url = body2?.has_more && body2.last_id ? `${spec.base_url}/v1/models?limit=100&after_id=${encodeURIComponent(body2.last_id)}` : null;
+    }
+    return { ok: true, models: models2 };
+  }
+  const res = await llmHttpGetJson(modelsUrl(spec), headers, timeoutMs);
+  if (!res.ok) return { ok: false, status: res.status };
+  const body = res.body;
+  const list = Array.isArray(body) ? body : body?.data ?? [];
+  const models = [];
+  for (const item of list) {
+    const model = normalizeItem(spec, item);
+    if (model) models.push(model);
+  }
+  return { ok: true, models };
+}
+function filterChatModels(spec, models) {
+  const extra = PROVIDER_EXCLUDE[spec.id];
+  return models.filter((m) => !NON_CHAT.test(m.id) && !(extra && extra.test(m.id)));
+}
+function storeDiscoveredModels(providerId, rawModels) {
+  const spec = getProviderSpec(providerId);
+  if (!spec || rawModels.length === 0) return null;
+  const chat = filterChatModels(spec, rawModels);
+  const usable = chat.length > 0 ? chat : rawModels;
+  const stack = rankModels(providerId, usable);
+  if (!stack) return null;
+  const prior = getProviderModels(providerId);
+  const entry = {
+    fetched_at: (/* @__PURE__ */ new Date()).toISOString(),
+    models: usable,
+    tier_stack: stack,
+    ...prior?.quirks ? { quirks: prior.quirks } : {}
+  };
+  setProviderModels(providerId, entry);
+  return entry;
+}
+async function refreshProviderModels(providerId, opts = {}) {
+  const spec = getProviderSpec(providerId);
+  if (!spec) return null;
+  if (!opts.force && !isProviderCacheStale(providerId)) {
+    return getProviderModels(providerId) ?? null;
+  }
+  const apiKey = opts.apiKey ?? getProviderApiKey(providerId);
+  if (spec.requires_key && !apiKey) return null;
+  const result = await fetchProviderModels(spec, apiKey);
+  if (!result.ok) return null;
+  return storeDiscoveredModels(providerId, result.models);
+}
+function rerankExcluding(providerId, deadModelId) {
+  const prior = getProviderModels(providerId);
+  if (!prior) return null;
+  const survivors = prior.models.filter((m) => m.id !== deadModelId);
+  const stack = rankModels(providerId, survivors);
+  if (!stack) return null;
+  const entry = { ...prior, models: survivors, tier_stack: stack };
+  setProviderModels(providerId, entry);
+  return entry;
+}
+async function refreshStaleProviderCaches() {
+  await Promise.allSettled(
+    getAvailableProviders().filter((p) => isProviderCacheStale(p)).map((p) => refreshProviderModels(p))
+  );
+}
+var NON_CHAT, PROVIDER_EXCLUDE;
+var init_discovery = __esm({
+  "src/ai/llm/discovery.ts"() {
+    "use strict";
+    init_llm_config();
+    init_http();
+    init_models_cache();
+    init_providers();
+    init_ranking();
+    NON_CHAT = /(embed|embedding|whisper|tts|dall-e|davinci|babbage|curie|\bada\b|moderation|-audio|realtime|transcribe|-image|rerank|guard|voice|sora|distil-whisper)/i;
+    PROVIDER_EXCLUDE = {
+      openai: /(chatgpt|-search|deep-research|-pro\b|computer-use|codex-mini|-instruct\b)/i
+    };
+  }
+});
+
+// src/ai/llm/heal.ts
+async function healModelNotFound(opts) {
+  const { provider, tier, deadModel } = opts;
+  const refreshed = await refreshProviderModels(provider, { apiKey: opts.apiKey, force: true });
+  let candidate = refreshed?.tier_stack?.[tier] ?? getCachedTierModel(provider, tier);
+  if (!candidate || candidate === deadModel) {
+    const reranked = rerankExcluding(provider, deadModel);
+    candidate = reranked?.tier_stack?.[tier];
+  }
+  if (!candidate || candidate === deadModel) return null;
+  clearDeadOverride(deadModel, opts.ctx);
+  return {
+    model: candidate,
+    notice: `model ${deadModel} is no longer available \u2014 switched to ${candidate}`
+  };
+}
+function clearDeadOverride(deadModel, ctx) {
+  if (getConfigValue("llm-model-override")?.trim() === deadModel) {
+    deleteConfigValue("llm-model-override");
+  }
+  if (ctx?.llm?.modelOverride === deadModel) {
+    ctx.llm.modelOverride = void 0;
+  }
+}
+var init_heal = __esm({
+  "src/ai/llm/heal.ts"() {
+    "use strict";
+    init_store();
+    init_discovery();
+    init_models_cache();
+  }
+});
+
 // src/ai/llm/surfaces.ts
 function tierForSurface(surface, userTier) {
   const spec = SURFACE_SPECS[surface];
@@ -7769,6 +8383,26 @@ var init_surfaces = __esm({
 });
 
 // src/ai/llm/session-state.ts
+var session_state_exports = {};
+__export(session_state_exports, {
+  availableEngineLabels: () => availableEngineLabels,
+  clearLlmSession: () => clearLlmSession,
+  countAvailableEngines: () => countAvailableEngines,
+  ensureLlmSession: () => ensureLlmSession,
+  formatActiveStack: () => formatActiveStack,
+  formatActiveStackShort: () => formatActiveStackShort,
+  getSessionModelOverride: () => getSessionModelOverride,
+  getSessionProvider: () => getSessionProvider,
+  getSessionTier: () => getSessionTier,
+  isSessionAutoFailover: () => isSessionAutoFailover,
+  resolveActiveProvider: () => resolveActiveProvider,
+  resolveAutoFailoverEnabled: () => resolveAutoFailoverEnabled,
+  resolveEffectiveModelOverride: () => resolveEffectiveModelOverride,
+  resolveEffectiveTier: () => resolveEffectiveTier,
+  resolveModelForActive: () => resolveModelForActive,
+  resolveProviderOrder: () => resolveProviderOrder,
+  validateModelForProvider: () => validateModelForProvider
+});
 function ensureLlmSession(ctx) {
   if (!ctx.llm) ctx.llm = {};
   return ctx.llm;
@@ -7793,7 +8427,7 @@ function resolveActiveProvider(ctx) {
   if (session && hasProviderKey(session)) return session;
   const cfg = loadLlmConfig();
   if (hasProviderKey(cfg.primary)) return cfg.primary;
-  const available = ["anthropic", "openai"].filter(hasProviderKey);
+  const available = getAvailableProviders();
   if (available.length > 0) return available[0];
   return cfg.primary;
 }
@@ -7815,8 +8449,8 @@ function resolveModelForActive(ctx, surface) {
   const provider = resolveActiveProvider(ctx);
   const tier = resolveEffectiveTier(ctx, surface);
   const override = resolveEffectiveModelOverride(ctx);
-  const providerOverride = override && getCatalogEntry(override)?.provider === provider ? override : void 0;
-  const modelId = resolveModel(provider, tier, providerOverride);
+  const providerOverride = overrideForProvider(override, provider, provider);
+  const modelId = resolveModelSafe(provider, tier, providerOverride);
   return { provider, tier, modelId };
 }
 function resolveProviderOrder(ctx) {
@@ -7827,26 +8461,30 @@ function resolveProviderOrder(ctx) {
   for (const p of cfg.failoverOrder) {
     if (p !== active && hasProviderKey(p) && !order.includes(p)) order.push(p);
   }
-  for (const p of ["anthropic", "openai"]) {
-    if (p !== active && hasProviderKey(p) && !order.includes(p)) order.push(p);
+  for (const p of getAvailableProviders()) {
+    if (p !== active && !order.includes(p)) order.push(p);
   }
   return order;
 }
 function formatActiveStack(ctx, surface = "agentic_investigation") {
   const { provider, tier, modelId } = resolveModelForActive(ctx, surface);
-  return `${provider} \xB7 ${tier} \xB7 ${modelId}`;
+  return `${provider} \xB7 ${tier} \xB7 ${modelId ?? "no models yet (run /connect)"}`;
+}
+function formatActiveStackShort(ctx, surface = "agentic_investigation") {
+  const { provider, tier } = resolveModelForActive(ctx, surface);
+  return `${provider} \xB7 ${tier}`;
 }
 function countAvailableEngines() {
-  return ["anthropic", "openai"].filter(hasProviderKey).length;
+  return getAvailableProviders().length;
 }
 function availableEngineLabels() {
-  return ["anthropic", "openai"].filter(hasProviderKey);
+  return getAvailableProviders();
 }
 function validateModelForProvider(modelId, provider) {
-  const entry = getCatalogEntry(modelId);
-  if (!entry) return null;
-  if (entry.provider !== provider) {
-    return `Model ${modelId} belongs to ${entry.provider}. Run /provider ${entry.provider} first.`;
+  const hint = modelProviderHint(modelId);
+  if (!hint) return null;
+  if (hint !== provider) {
+    return `Model ${modelId} belongs to ${hint}. Run /provider ${hint} first.`;
   }
   return null;
 }
@@ -7860,23 +8498,16 @@ var init_session_state = __esm({
 });
 
 // src/ai/llm/resolver.ts
-function getProviderOrder(config, ctx) {
-  void config;
-  return resolveProviderOrder(ctx);
-}
 function resolveCompletionContext(surface, opts = {}) {
   const activeProvider = resolveActiveProvider(opts.ctx);
   const tier = opts.tier ?? resolveEffectiveTier(opts.ctx, surface);
   const override = opts.modelOverride ?? resolveEffectiveModelOverride(opts.ctx);
   const providerOrder = resolveProviderOrder(opts.ctx);
   const modelByProvider = {};
-  for (const provider of providerOrder) {
-    const providerOverride = override && getCatalogEntry(override)?.provider === provider ? override : void 0;
-    modelByProvider[provider] = resolveModel(provider, tier, providerOverride);
-  }
-  if (!modelByProvider[activeProvider]) {
-    const activeOverride = override && getCatalogEntry(override)?.provider === activeProvider ? override : void 0;
-    modelByProvider[activeProvider] = resolveModel(activeProvider, tier, activeOverride);
+  for (const provider of /* @__PURE__ */ new Set([...providerOrder, activeProvider])) {
+    const providerOverride = overrideForProvider(override, provider, activeProvider);
+    const model = resolveModelSafe(provider, tier, providerOverride);
+    if (model) modelByProvider[provider] = model;
   }
   return {
     providerOrder,
@@ -7902,70 +8533,142 @@ var init_resolver2 = __esm({
 
 // src/ai/llm/failover.ts
 async function completeOnProvider(provider, model, apiKey, req) {
-  if (provider === "anthropic") return anthropicComplete(apiKey, model, req);
-  return openaiComplete(apiKey, model, req);
+  const spec = getProviderSpec(provider);
+  if (!spec) {
+    throw new LlmError("UNKNOWN", `Unknown provider "${provider}" \u2014 run /connect to register it.`, provider);
+  }
+  if (spec.api === "anthropic") {
+    return anthropicComplete(apiKey ?? "", model, req);
+  }
+  return openaiCompatComplete(provider, spec.base_url, apiKey, model, req);
+}
+function usableKey(provider, ctx) {
+  const spec = getProviderSpec(provider);
+  if (!spec) return { ok: false };
+  const apiKey = getApiKeyForProvider(provider, ctx);
+  if (spec.requires_key && !apiKey) return { ok: false };
+  return { ok: true, apiKey };
+}
+async function resolveModelWithDiscovery(provider, cfg, opts) {
+  const known = cfg.modelByProvider[provider];
+  if (known) return known;
+  const override = overrideForProvider(opts.modelOverride, provider, cfg.activeProvider);
+  const direct = resolveModelSafe(provider, cfg.tier, override);
+  if (direct) return direct;
+  await refreshProviderModels(provider, { apiKey: opts.apiKey, force: true }).catch(() => null);
+  return resolveModelSafe(provider, cfg.tier, override);
+}
+function stripTools(req) {
+  const { tools: _tools, ...rest } = req;
+  return rest;
 }
 async function completeWithFailover(req, opts = {}) {
-  const ctx = resolveCompletionContext(req.surface, {
+  const cfg = resolveCompletionContext(req.surface, {
     max_tokens: req.max_tokens,
     tier: opts.tier,
     modelOverride: opts.modelOverride,
     ctx: opts.ctx
   });
-  const providers = ctx.providerOrder;
+  const providers = cfg.providerOrder;
   if (providers.length === 0) {
-    throw new Error("No LLM provider configured. Set api-key and/or openai-api-key via /config.");
+    throw new Error(NO_PROVIDER_MESSAGE);
   }
+  const notices = [];
   let lastError;
   let failoverFrom;
+  const buildMeta = (provider, model, response) => ({
+    provider_used: provider,
+    model_used: model,
+    ...response.token_usage ?? {},
+    ...failoverFrom ? { failover: true, failover_from: failoverFrom } : {},
+    ...notices.length > 0 ? { notices: [...notices] } : {}
+  });
   for (let i = 0; i < providers.length; i++) {
     const provider = providers[i];
-    const apiKey = getApiKeyForProvider(provider, opts.ctx);
-    if (!apiKey) continue;
-    let model = ctx.modelByProvider[provider] ?? resolveModel(provider, ctx.tier, opts.modelOverride);
+    const key = usableKey(provider, opts.ctx);
+    if (!key.ok) continue;
+    let model = await resolveModelWithDiscovery(provider, cfg, {
+      modelOverride: opts.modelOverride,
+      apiKey: key.apiKey
+    });
+    if (!model) {
+      lastError = new LlmError(
+        "MODEL_NOT_FOUND",
+        `No models known for provider "${provider}". Run /connect or /model refresh.`,
+        provider
+      );
+      continue;
+    }
+    let effectiveReq = req;
+    if (req.tools?.length && modelHasNoToolsQuirk(provider, model)) {
+      effectiveReq = stripTools(req);
+      notices.push(`${model} doesn't support tool calling \u2014 answering without live data tools`);
+    }
     try {
-      const response = await completeOnProvider(provider, model, apiKey, req);
-      const meta = {
-        provider_used: provider,
-        model_used: model,
-        ...response.token_usage ?? {},
-        ...failoverFrom ? { failover: true, failover_from: failoverFrom } : {}
-      };
+      const response = await completeOnProvider(provider, model, key.apiKey, effectiveReq);
+      const meta = buildMeta(provider, model, response);
       recordLlmUsage(response.token_usage);
       return { response, meta };
     } catch (err) {
-      const llmErr = err;
+      let llmErr = err;
       if (llmErr.name !== "LlmError") throw err;
       lastError = llmErr;
-      if (llmErr.code === "MODEL_NOT_FOUND") {
-        model = resolveModel(provider, ctx.tier);
+      if (llmErr.code === "TOOLS_UNSUPPORTED" && effectiveReq.tools?.length) {
+        markModelNoTools(provider, model);
+        notices.push(`${model} doesn't support tool calling \u2014 retrying without live data tools`);
         try {
-          const response = await completeOnProvider(provider, model, apiKey, req);
-          const meta = {
-            provider_used: provider,
-            model_used: model,
-            ...response.token_usage ?? {},
-            ...failoverFrom ? { failover: true, failover_from: failoverFrom } : {}
-          };
+          const response = await completeOnProvider(provider, model, key.apiKey, stripTools(effectiveReq));
+          const meta = buildMeta(provider, model, response);
           recordLlmUsage(response.token_usage);
           return { response, meta };
         } catch (retryErr) {
           const retryLlm = retryErr;
-          if (retryLlm.name === "LlmError") lastError = retryLlm;
-          else throw retryErr;
+          if (retryLlm.name !== "LlmError") throw retryErr;
+          lastError = retryLlm;
+          llmErr = retryLlm;
+        }
+      }
+      if (llmErr.code === "MODEL_NOT_FOUND") {
+        const healed = await healModelNotFound({
+          provider,
+          tier: cfg.tier,
+          deadModel: model,
+          apiKey: key.apiKey,
+          ctx: opts.ctx
+        }).catch(() => null);
+        if (healed) {
+          notices.push(healed.notice);
+          model = healed.model;
+          let retryReq = req;
+          if (req.tools?.length && modelHasNoToolsQuirk(provider, model)) {
+            retryReq = stripTools(req);
+            notices.push(`${model} doesn't support tool calling \u2014 answering without live data tools`);
+          }
+          try {
+            const response = await completeOnProvider(provider, model, key.apiKey, retryReq);
+            const meta = buildMeta(provider, model, response);
+            recordLlmUsage(response.token_usage);
+            return { response, meta };
+          } catch (retryErr) {
+            const retryLlm = retryErr;
+            if (retryLlm.name !== "LlmError") throw retryErr;
+            lastError = retryLlm;
+            llmErr = retryLlm;
+          }
         }
       }
       if (!isFailoverEligible(llmErr.code)) throw llmErr;
       const next = providers[i + 1];
       if (next) {
         failoverFrom = failoverFrom ?? provider;
+        notices.push(`${provider} unavailable (${llmErr.code.toLowerCase()}) \u2014 trying ${next}`);
         opts.onFailover?.(provider, next, llmErr.code);
         continue;
       }
       throw llmErr;
     }
   }
-  throw lastError ?? new Error("No LLM provider available");
+  throw lastError ?? new Error(NO_PROVIDER_MESSAGE);
 }
 async function* streamWithFailover(req, opts = {}) {
   const cfg = resolveCompletionContext(req.surface, {
@@ -7974,23 +8677,47 @@ async function* streamWithFailover(req, opts = {}) {
     modelOverride: opts.modelOverride,
     ctx: opts.ctx
   });
-  const providers = getProviderOrder();
+  const providers = cfg.providerOrder;
   if (providers.length === 0) {
-    throw new Error("No LLM provider configured. Set api-key and/or openai-api-key via /config.");
+    throw new Error(NO_PROVIDER_MESSAGE);
   }
+  const notices = [];
   let lastError;
   let failoverFrom;
+  async function* streamOnProvider(provider, model, apiKey) {
+    const spec = getProviderSpec(provider);
+    if (!spec) {
+      throw new LlmError("UNKNOWN", `Unknown provider "${provider}" \u2014 run /connect to register it.`, provider);
+    }
+    if (spec.api === "anthropic") {
+      yield* anthropicStream(apiKey ?? "", model, req);
+      return;
+    }
+    yield* openaiCompatStream(provider, spec.base_url, apiKey, model, req);
+  }
   for (let i = 0; i < providers.length; i++) {
     const provider = providers[i];
-    const apiKey = getApiKeyForProvider(provider, opts.ctx);
-    if (!apiKey) continue;
-    const model = cfg.modelByProvider[provider] ?? resolveModel(provider, cfg.tier, opts.modelOverride);
-    try {
+    const key = usableKey(provider, opts.ctx);
+    if (!key.ok) continue;
+    let model = await resolveModelWithDiscovery(provider, cfg, {
+      modelOverride: opts.modelOverride,
+      apiKey: key.apiKey
+    });
+    if (!model) {
+      lastError = new LlmError(
+        "MODEL_NOT_FOUND",
+        `No models known for provider "${provider}". Run /connect or /model refresh.`,
+        provider
+      );
+      continue;
+    }
+    let yieldedAny = false;
+    const attempt = async function* (attemptModel) {
       let fullText = "";
-      const streamFn = provider === "anthropic" ? anthropicStream : openaiStream;
-      for await (const event of streamFn(apiKey, model, req)) {
+      for await (const event of streamOnProvider(provider, attemptModel, key.apiKey)) {
         if (event.type === "text_delta") {
           fullText += event.text;
+          yieldedAny = true;
           yield event;
         }
       }
@@ -7998,10 +8725,11 @@ async function* streamWithFailover(req, opts = {}) {
       recordLlmUsage({ input_tokens: 0, output_tokens: estimatedOut });
       const meta = {
         provider_used: provider,
-        model_used: model,
+        model_used: attemptModel,
         input_tokens: 0,
         output_tokens: estimatedOut,
-        ...failoverFrom ? { failover: true, failover_from: failoverFrom } : {}
+        ...failoverFrom ? { failover: true, failover_from: failoverFrom } : {},
+        ...notices.length > 0 ? { notices: [...notices] } : {}
       };
       yield {
         type: "done",
@@ -8013,32 +8741,66 @@ async function* streamWithFailover(req, opts = {}) {
         },
         meta
       };
+    };
+    try {
+      yield* attempt(model);
       return;
     } catch (err) {
       const llmErr = err;
       if (llmErr.name !== "LlmError") throw err;
       lastError = llmErr;
-      if (!isFailoverEligible(llmErr.code)) throw llmErr;
+      if (yieldedAny) throw llmErr;
+      if (llmErr.code === "MODEL_NOT_FOUND") {
+        const healed = await healModelNotFound({
+          provider,
+          tier: cfg.tier,
+          deadModel: model,
+          apiKey: key.apiKey,
+          ctx: opts.ctx
+        }).catch(() => null);
+        if (healed) {
+          notices.push(healed.notice);
+          model = healed.model;
+          try {
+            yield* attempt(model);
+            return;
+          } catch (retryErr) {
+            const retryLlm = retryErr;
+            if (retryLlm.name !== "LlmError") throw retryErr;
+            lastError = retryLlm;
+            if (yieldedAny) throw retryLlm;
+          }
+        }
+      }
+      if (!isFailoverEligible(lastError.code)) throw lastError;
       const next = providers[i + 1];
       if (next) {
         failoverFrom = failoverFrom ?? provider;
-        opts.onFailover?.(provider, next, llmErr.code);
+        notices.push(`${provider} unavailable (${lastError.code.toLowerCase()}) \u2014 trying ${next}`);
+        opts.onFailover?.(provider, next, lastError.code);
         continue;
       }
-      throw llmErr;
+      throw lastError;
     }
   }
-  throw lastError ?? new Error("No LLM provider available");
+  throw lastError ?? new Error(NO_PROVIDER_MESSAGE);
 }
+var NO_PROVIDER_MESSAGE;
 var init_failover = __esm({
   "src/ai/llm/failover.ts"() {
     "use strict";
     init_usage_stats();
     init_anthropic();
-    init_openai();
+    init_openai_compat();
     init_catalog();
+    init_discovery();
     init_errors2();
+    init_heal();
+    init_models_cache();
+    init_providers();
+    init_types2();
     init_resolver2();
+    NO_PROVIDER_MESSAGE = "No LLM provider configured. Run /connect and paste any API key (Anthropic, OpenAI, Groq, Gemini, ...).";
   }
 });
 
@@ -8407,8 +9169,8 @@ function markFailure(ctx) {
 }
 async function loadOrBuildTaxonomy(profile, forceRegen, ctx) {
   if (!forceRegen) {
-    const cached = loadCachedTaxonomy(profile);
-    if (cached) return cached;
+    const cached2 = loadCachedTaxonomy(profile);
+    if (cached2) return cached2;
   }
   const spinnerText = forceRegen ? "Rebuilding market taxonomy\u2026" : "Researching your market taxonomy\u2026";
   const spinner = ora2({ text: spinnerText, discardStdin: false }).start();
@@ -8566,7 +9328,7 @@ __export(ingest_exports, {
 });
 import chalk9 from "chalk";
 import ora3 from "ora";
-import { readFileSync as readFileSync8, existsSync as existsSync10 } from "fs";
+import { readFileSync as readFileSync11, existsSync as existsSync12 } from "fs";
 import { basename as basename2 } from "path";
 async function handler2(args, ctx) {
   const { positional, flags } = parseArgs(args, [
@@ -8590,7 +9352,7 @@ async function handler2(args, ctx) {
     console.error(chalk9.dim("         /ingest --demo [--scenario <name>]"));
     process.exit(1);
   }
-  if (!existsSync10(file)) {
+  if (!existsSync12(file)) {
     console.error(chalk9.red(`  File not found: ${file}`));
     process.exit(1);
   }
@@ -8608,7 +9370,7 @@ async function handler2(args, ctx) {
   try {
     await initSchema();
     spinner.text = "Parsing CSV...";
-    const content = readFileSync8(file, "utf-8");
+    const content = readFileSync11(file, "utf-8");
     const { rows, headers } = parseCSV(content);
     if (rows.length === 0) {
       spinner.fail("CSV is empty");
@@ -10933,16 +11695,16 @@ var init_compute = __esm({
 });
 
 // src/data/playbook.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9, appendFileSync } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync12, appendFileSync } from "fs";
+import { join as join12 } from "path";
 function playsPath() {
-  return join10(getMemoryDir(), PLAYS_FILE);
+  return join12(getMemoryDir(), PLAYS_FILE);
 }
 function getCustomPlays() {
   const path = playsPath();
-  if (!existsSync11(path)) return [];
+  if (!existsSync13(path)) return [];
   const out = [];
-  for (const line of readFileSync9(path, "utf-8").split("\n")) {
+  for (const line of readFileSync12(path, "utf-8").split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     try {
@@ -11534,7 +12296,7 @@ async function runMetricsAnalysis(options = {}) {
   if (options.findings) {
     if (!canUseReplAi(options.ctx)) {
       throw new Error(
-        "AI metrics findings require stored API keys. Run `ntrp`, set api-key and/or openai-api-key, then /metrics --findings."
+        "AI metrics findings require stored API keys. Run `ntrp`, then /connect (any provider key), then /metrics --findings."
       );
     }
     options.onProgress?.("findings");
@@ -11943,7 +12705,8 @@ async function* streamFindings(input, ctx) {
         findings,
         model_used: meta.model_used,
         provider_used: meta.provider_used,
-        raw_prompt: userMessage
+        raw_prompt: userMessage,
+        usage: meta
       };
     }
   }
@@ -12244,9 +13007,9 @@ var init_tool_schemas = __esm({
 });
 
 // src/ai/privacy.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync8, appendFileSync as appendFileSync2 } from "fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync8, appendFileSync as appendFileSync2 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join11 } from "path";
+import { join as join13 } from "path";
 function stripPII(obj) {
   if (obj === null || obj === void 0) return obj;
   if (typeof obj !== "object") return obj;
@@ -12261,14 +13024,14 @@ function stripPII(obj) {
   return out;
 }
 function ensureAuditDir() {
-  if (!existsSync12(AUDIT_DIR)) {
+  if (!existsSync14(AUDIT_DIR)) {
     mkdirSync8(AUDIT_DIR, { recursive: true });
   }
 }
 function logToolCall(entry) {
   ensureAuditDir();
   const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const path = join11(AUDIT_DIR, `agentic-${date}.jsonl`);
+  const path = join13(AUDIT_DIR, `agentic-${date}.jsonl`);
   appendFileSync2(path, JSON.stringify(entry) + "\n");
 }
 var PII_FIELDS, AUDIT_DIR;
@@ -12292,7 +13055,7 @@ var init_privacy = __esm({
       "raw_data",
       "metadata"
     ]);
-    AUDIT_DIR = join11(homedir4(), ".ntrp", "audit");
+    AUDIT_DIR = join13(homedir4(), ".ntrp", "audit");
   }
 });
 
@@ -12768,7 +13531,7 @@ __export(ingest_chat_exports, {
   loadDemoFromChat: () => loadDemoFromChat,
   looksLikeFilePath: () => looksLikeFilePath
 });
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { basename as basename3, resolve as resolve4 } from "path";
 import { homedir as homedir5 } from "os";
 import chalk15 from "chalk";
@@ -12788,11 +13551,11 @@ function extractFilePath(input) {
     const m = trimmed.match(re);
     if (m?.[1]) {
       const p = expandPath(m[1]);
-      if (existsSync13(p)) return p;
+      if (existsSync15(p)) return p;
     }
     if (!m?.[1] && re.test(trimmed) && trimmed.toLowerCase().endsWith(".csv")) {
       const p = expandPath(trimmed.replace(/^["']|["']$/g, ""));
-      if (existsSync13(p)) return p;
+      if (existsSync15(p)) return p;
     }
   }
   return null;
@@ -12822,12 +13585,12 @@ async function ingestFromChat(ctx, filePath) {
   }
   const { handler: ingest } = await Promise.resolve().then(() => (init_ingest(), ingest_exports));
   const { detectEntityType: detectEntityType2 } = await Promise.resolve().then(() => (init_csv_detect(), csv_detect_exports));
-  const { readFileSync: readFileSync16 } = await import("fs");
+  const { readFileSync: readFileSync19 } = await import("fs");
   const { parseCSV: parseCSV2 } = await Promise.resolve().then(() => (init_csv_parse(), csv_parse_exports));
   const { getStoredApiKey } = await Promise.resolve().then(() => (init_repl_api(), repl_api_exports));
   let headerCheckFailed = false;
   try {
-    const raw = readFileSync16(filePath, "utf-8");
+    const raw = readFileSync19(filePath, "utf-8");
     const { headers } = parseCSV2(raw);
     const detected = detectEntityType2(headers, "unknown");
     if (!detected) headerCheckFailed = true;
@@ -13186,15 +13949,18 @@ function inferHandoffTarget(input) {
   return "plan";
 }
 function isShipIntent(input) {
-  return /\b(handoff|ship|deliver|board memo|export|turn this into|write.?up|action plan)\b/i.test(
-    input.trim()
-  );
+  const line = input.trim();
+  if (/\?\s*$/.test(line) || QUESTION_LEAD_RE.test(line)) return false;
+  return SHIP_INTENT_RE.test(line);
 }
+var QUESTION_LEAD_RE, SHIP_INTENT_RE;
 var init_handoff_draft = __esm({
   "src/conversation/handoff-draft.ts"() {
     "use strict";
     init_profile();
     init_session_analysis();
+    QUESTION_LEAD_RE = /^\s*(what|why|how|when|where|who|which|is|are|was|were|do|does|did|explain|tell me|help me understand)\b/i;
+    SHIP_INTENT_RE = /\b(ship|export|deliver|write[- ]?up|board memo|action plan|turn (this|it|that) into|(draft|create|make|build|prepare|generate|send)\s+(me\s+)?(a\s+|the\s+)?hand[- ]?off|hand[- ]?off\s+(prompt|doc|document|plan))\b/i;
   }
 });
 
@@ -13575,12 +14341,12 @@ async function handleDraftHandoff(input) {
   };
 }
 async function executeToolCall(name, input, ctx) {
-  const handler45 = HANDLERS[name];
-  if (!handler45) {
+  const handler46 = HANDLERS[name];
+  if (!handler46) {
     return JSON.stringify({ error: `Unknown tool '${name}'` });
   }
   const start = Date.now();
-  const rawResult = await handler45(input, ctx);
+  const rawResult = await handler46(input, ctx);
   const safeResult = stripPII(rawResult);
   const resultJson = JSON.stringify(safeResult);
   const duration = Date.now() - start;
@@ -13973,7 +14739,7 @@ async function runDiagnosis(options = {}) {
   if (options.findings) {
     if (!canUseReplAi(options.ctx)) {
       throw new Error(
-        "AI findings require stored API keys. Run `ntrp`, then /config set api-key and/or /config set openai-api-key, and use /diagnose --findings."
+        "AI findings require stored API keys. Run `ntrp`, then /connect (any provider key), and use /diagnose --findings."
       );
     }
     if (options.deep) {
@@ -14116,7 +14882,7 @@ async function handler3(args, ctx) {
     console.log();
     console.log("  " + chalk16.red("AI findings run only in the interactive REPL."));
     console.log("  " + chalk16.dim("Vital signs compute without a key \u2014 omit --findings for numbers only."));
-    console.log("  " + chalk16.dim("Start with ") + paint("accent", "ntrp") + chalk16.dim(", set ") + paint("accent", "/config set api-key") + chalk16.dim(" or openai-api-key, then /diagnose --findings."));
+    console.log("  " + chalk16.dim("Start with ") + paint("accent", "ntrp") + chalk16.dim(", run ") + paint("accent", "/connect") + chalk16.dim(" (any provider key), then /diagnose --findings."));
     console.log();
     return;
   }
@@ -14776,6 +15542,235 @@ var init_profile2 = __esm({
   }
 });
 
+// src/ai/llm/detect.ts
+function detectProviderByKey(key) {
+  const k = key.trim();
+  const specs = listProviderSpecs();
+  let best;
+  for (const spec of specs) {
+    for (const prefix of spec.key_prefixes) {
+      if (k.startsWith(prefix) && (!best || prefix.length > best.length)) {
+        best = { id: spec.id, length: prefix.length };
+      }
+    }
+  }
+  if (best) return { certain: best.id, candidates: [best.id] };
+  const shared = specs.filter((s) => s.shared_prefixes.some((p) => k.startsWith(p)));
+  if (shared.length > 0) return { candidates: shared.map((s) => s.id) };
+  const noPrefix = specs.filter(
+    (s) => s.requires_key && !s.custom && s.key_prefixes.length === 0 && s.shared_prefixes.length === 0
+  );
+  return { candidates: noPrefix.map((s) => s.id) };
+}
+async function probeProviders(key, candidateIds, timeoutMs = 5e3) {
+  const results = await Promise.all(
+    candidateIds.map(async (id) => {
+      const spec = getProviderSpec(id);
+      if (!spec) return { id, ok: false, status: 0 };
+      const result = await fetchProviderModels(spec, key, timeoutMs);
+      if (result.ok) return { id, ok: true, models: result.models };
+      return { id, ok: false, status: result.status };
+    })
+  );
+  const accepted = [];
+  let sawNetworkFailure = false;
+  for (const r of results) {
+    if (r.ok && r.models.length > 0) accepted.push({ provider: r.id, models: r.models });
+    else if (!r.ok && r.status === 0) sawNetworkFailure = true;
+  }
+  return { accepted, sawNetworkFailure };
+}
+var init_detect = __esm({
+  "src/ai/llm/detect.ts"() {
+    "use strict";
+    init_discovery();
+    init_providers();
+  }
+});
+
+// src/services/connect.ts
+var connect_exports = {};
+__export(connect_exports, {
+  ConnectCancelled: () => ConnectCancelled,
+  ConnectError: () => ConnectError,
+  connectCustomEndpoint: () => connectCustomEndpoint,
+  connectKeyless: () => connectKeyless,
+  connectWithKey: () => connectWithKey,
+  describeConnectOutcome: () => describeConnectOutcome
+});
+function finishConnect(spec, opts) {
+  const before = getAvailableProviders();
+  if (opts.key) {
+    setConfigValue(spec.key_config_name, opts.key);
+  }
+  const entry = opts.models && opts.models.length > 0 ? storeDiscoveredModels(spec.id, opts.models) : null;
+  const cfg = loadLlmConfig();
+  let becamePrimary = false;
+  if (cfg.primary !== spec.id && (before.length === 0 || !hasProviderKey(cfg.primary))) {
+    setConfigValue("llm-primary", spec.id);
+    becamePrimary = true;
+  }
+  return {
+    provider: spec.id,
+    label: spec.label,
+    modelCount: entry?.models.length ?? 0,
+    ...entry ? { stack: entry.tier_stack } : {},
+    becamePrimary,
+    offline: !!opts.offline
+  };
+}
+async function connectWithKey(rawKey, opts = {}) {
+  const key = rawKey.trim();
+  if (!key) throw new ConnectError("Empty key.");
+  if (opts.providerId) {
+    const spec = getProviderSpec(opts.providerId);
+    if (!spec) {
+      throw new ConnectError(
+        `Unknown provider "${opts.providerId}". Use a built-in id or /connect --base-url <url> --id ${opts.providerId} for a custom endpoint.`
+      );
+    }
+    const result = await fetchProviderModels(spec, key);
+    if (result.ok) return finishConnect(spec, { key, models: result.models });
+    if (result.status === 0) {
+      return finishConnect(spec, { key, offline: true });
+    }
+    throw new ConnectError(`${spec.label} rejected this key (HTTP ${result.status}) \u2014 double-check it and try again.`);
+  }
+  const detection = detectProviderByKey(key);
+  if (detection.certain) {
+    const spec = getProviderSpec(detection.certain);
+    const result = await fetchProviderModels(spec, key);
+    if (result.ok) return finishConnect(spec, { key, models: result.models });
+    if (result.status === 0) return finishConnect(spec, { key, offline: true });
+    throw new ConnectError(`${spec.label} rejected this key (HTTP ${result.status}) \u2014 double-check it and try again.`);
+  }
+  const report = await probeProviders(key, detection.candidates);
+  if (report.accepted.length === 1) {
+    const match = report.accepted[0];
+    const spec = getProviderSpec(match.provider);
+    if (opts.callbacks?.confirmDetection) {
+      const ok = await opts.callbacks.confirmDetection(match.provider);
+      if (!ok) throw new ConnectCancelled();
+    }
+    return finishConnect(spec, { key, models: match.models });
+  }
+  if (report.accepted.length > 1) {
+    if (opts.callbacks?.chooseProvider) {
+      const chosen = await opts.callbacks.chooseProvider(report.accepted);
+      if (!chosen) throw new ConnectCancelled();
+      const match = report.accepted.find((a) => a.provider === chosen);
+      return finishConnect(getProviderSpec(chosen), { key, models: match.models });
+    }
+    throw new ConnectError(
+      `Multiple providers accepted this key (${report.accepted.map((a) => a.provider).join(", ")}). Re-run with --provider <id>.`
+    );
+  }
+  if (report.sawNetworkFailure) {
+    throw new ConnectError(
+      `Couldn't reach ${detection.candidates.map(providerLabel).join(" / ")} to identify this key. Check your connection, or force a provider with --provider <id>.`
+    );
+  }
+  throw new ConnectError(
+    `No provider accepted this key (tried ${detection.candidates.map(providerLabel).join(", ")}). If it belongs to an OpenAI-compatible endpoint, run /connect --base-url <url>.`
+  );
+}
+async function connectCustomEndpoint(opts) {
+  const id = opts.id.trim().toLowerCase();
+  if (!/^[a-z][a-z0-9_-]*$/.test(id)) {
+    throw new ConnectError(`Invalid provider id "${opts.id}" \u2014 use letters, digits, dashes.`);
+  }
+  const baseUrl = opts.baseUrl.trim().replace(/\/+$/, "");
+  if (!/^https?:\/\//.test(baseUrl)) {
+    throw new ConnectError(`Base URL must start with http:// or https:// (got "${opts.baseUrl}").`);
+  }
+  const builtin = getProviderSpec(id);
+  const spec = builtin ? { ...builtin, base_url: baseUrl } : {
+    id,
+    label: opts.label ?? id,
+    api: "openai-compat",
+    base_url: baseUrl,
+    key_prefixes: [],
+    shared_prefixes: [],
+    key_config_name: `${id}-api-key`,
+    requires_key: !!opts.key,
+    custom: true
+  };
+  const result = await fetchProviderModels(spec, opts.key);
+  if (!result.ok) {
+    if (result.status === 0) {
+      throw new ConnectError(`Couldn't reach ${baseUrl} \u2014 check the URL (expects an OpenAI-compatible /models endpoint).`);
+    }
+    if (result.status === 401 || result.status === 403) {
+      throw new ConnectError(
+        opts.key ? `${spec.label} rejected the key (HTTP ${result.status}).` : `${spec.label} requires an API key (HTTP ${result.status}) \u2014 re-run with a key.`
+      );
+    }
+    throw new ConnectError(`${baseUrl} answered HTTP ${result.status} \u2014 is this an OpenAI-compatible endpoint?`);
+  }
+  if (result.models.length === 0) {
+    throw new ConnectError(`${baseUrl} lists no models \u2014 nothing to connect.`);
+  }
+  saveCustomProvider({
+    id,
+    ...opts.label ? { label: opts.label } : {},
+    base_url: baseUrl,
+    requires_key: !!opts.key,
+    enabled: true
+  });
+  return finishConnect(getProviderSpec(id), { key: opts.key, models: result.models });
+}
+async function connectKeyless(providerId, baseUrl) {
+  const builtin = getProviderSpec(providerId);
+  if (!builtin) throw new ConnectError(`Unknown provider "${providerId}".`);
+  const spec = baseUrl ? { ...builtin, base_url: baseUrl.replace(/\/+$/, "") } : builtin;
+  const result = await fetchProviderModels(spec, void 0);
+  if (!result.ok) {
+    throw new ConnectError(
+      `${spec.label} not reachable at ${spec.base_url}. Is it running? (ollama serve, then retry)`
+    );
+  }
+  if (result.models.length === 0) {
+    throw new ConnectError(`${spec.label} is running but has no models \u2014 pull one first (e.g. \`ollama pull llama3.2\`).`);
+  }
+  saveCustomProvider({ id: spec.id, base_url: spec.base_url, enabled: true });
+  return finishConnect(getProviderSpec(spec.id), { models: result.models });
+}
+function describeConnectOutcome(outcome) {
+  const lines = [];
+  if (outcome.offline) {
+    lines.push(`${outcome.label} key saved \u2014 provider unreachable right now, models will be discovered on first use.`);
+  } else {
+    lines.push(`Connected ${outcome.label} \u2014 ${outcome.modelCount} chat model${outcome.modelCount === 1 ? "" : "s"} available.`);
+  }
+  if (outcome.stack) {
+    lines.push(`high    ${outcome.stack.high}`);
+    lines.push(`medium  ${outcome.stack.medium}`);
+    lines.push(`low     ${outcome.stack.low}`);
+  }
+  if (outcome.becamePrimary) {
+    lines.push(`Primary engine: ${outcome.provider}`);
+  }
+  return lines;
+}
+var ConnectError, ConnectCancelled;
+var init_connect = __esm({
+  "src/services/connect.ts"() {
+    "use strict";
+    init_detect();
+    init_discovery();
+    init_providers();
+    init_llm_config();
+    init_store();
+    ConnectError = class extends Error {
+    };
+    ConnectCancelled = class extends ConnectError {
+      constructor() {
+        super("Connect cancelled.");
+      }
+    };
+  }
+});
+
 // src/commands/onboard.ts
 var onboard_exports = {};
 __export(onboard_exports, {
@@ -15103,42 +16098,58 @@ function printIntro() {
 }
 async function ensureLlmKeys(session) {
   if (hasAnyLlmProvider()) return;
+  const { connectWithKey: connectWithKey2, describeConnectOutcome: describeConnectOutcome2, ConnectCancelled: ConnectCancelled2 } = await Promise.resolve().then(() => (init_connect(), connect_exports));
+  const { providerLabel: providerLabel2 } = await Promise.resolve().then(() => (init_providers(), providers_exports));
+  const { countAvailableEngines: countAvailableEngines2 } = await Promise.resolve().then(() => (init_session_state(), session_state_exports));
   console.log();
   console.log("  " + chalk19.dim("Onboarding uses AI to draft your profile."));
   console.log(
-    "  " + chalk19.dim("Or run ") + paint("accent", "/config set api-key") + chalk19.dim(" / ") + paint("accent", "/config set openai-api-key") + chalk19.dim(" anytime.")
+    "  " + chalk19.dim("Paste any provider's API key \u2014 Anthropic, OpenAI, Groq, Gemini, Mistral, ...")
   );
-  const first = await session.choose("Add your first LLM engine", [
-    { value: "anthropic", label: "Anthropic (Claude)", description: "Strong tool-using investigation" },
-    { value: "openai", label: "OpenAI (GPT)", description: "Full parity on all surfaces" }
-  ]);
-  const firstLabel = first === "anthropic" ? "Anthropic API key" : "OpenAI API key";
-  const firstKey = await session.askSecret(firstLabel, { confirm: true });
-  if (first === "anthropic") setConfigValue("api-key", firstKey);
-  else setConfigValue("openai-api-key", firstKey);
-  setConfigValue("llm-primary", first);
-  setConfigValue("llm-tier", "high");
-  const second = first === "anthropic" ? "openai" : "anthropic";
-  setConfigValue("llm-failover-order", second);
-  setConfigValue("llm-auto-failover", "off");
-  const addSecond = await session.confirm(
-    `Add a second engine (${second}) for switching in the REPL?`,
-    false
+  console.log(
+    "  " + chalk19.dim("NTRP detects the provider and discovers its models. Or run ") + paint("accent", "/connect") + chalk19.dim(" anytime.")
   );
-  if (addSecond) {
-    const secondLabel = second === "anthropic" ? "Anthropic API key" : "OpenAI API key";
-    const secondKey = await session.askSecret(secondLabel, { confirm: true });
-    if (second === "anthropic") setConfigValue("api-key", secondKey);
-    else setConfigValue("openai-api-key", secondKey);
+  for (; ; ) {
+    const key = await session.askSecret("LLM API key (any provider)", { confirm: false });
+    const spinner = ora6({ text: "Identifying provider\u2026", discardStdin: false }).start();
+    try {
+      const outcome = await connectWithKey2(key, {
+        callbacks: {
+          confirmDetection: async (providerId) => {
+            spinner.stop();
+            return session.confirm(`Detected ${providerLabel2(providerId)} \u2014 connect it?`, true);
+          },
+          chooseProvider: async (accepted) => {
+            spinner.stop();
+            return session.choose(
+              "Multiple providers accepted this key \u2014 which is it?",
+              accepted.map((a) => ({ value: a.provider, label: providerLabel2(a.provider) }))
+            );
+          }
+        }
+      });
+      spinner.stop();
+      const [headline, ...rest] = describeConnectOutcome2(outcome);
+      console.log("  " + paint("success", "\u2713") + " " + (headline ?? ""));
+      for (const line of rest) console.log("    " + chalk19.dim(line));
+    } catch (err) {
+      spinner.stop();
+      if (!(err instanceof ConnectCancelled2)) {
+        console.log("  " + chalk19.red(String(err.message ?? err)));
+      }
+      const retry = await session.confirm("Try another key?", true);
+      if (retry) continue;
+      if (!hasAnyLlmProvider()) return;
+    }
+    const addAnother = await session.confirm("Add another engine? (switch anytime with /provider)", false);
+    if (!addAnother) break;
+  }
+  if (countAvailableEngines2() >= 2) {
     const enableFailover = await session.confirm(
       "Enable auto-failover on rate limits? (off = you choose engine with /provider)",
       false
     );
-    if (enableFailover) setConfigValue("llm-auto-failover", "on");
-  } else {
-    console.log(
-      "  " + chalk19.dim(`Single engine \u2014 add ${second} later via /config set ${second === "anthropic" ? "api-key" : "openai-api-key"}.`)
-    );
+    setConfigValue("llm-auto-failover", enableFailover ? "on" : "off");
   }
   console.log("  " + paint("success", "\u2713") + " " + chalk19.dim("LLM engines configured. Use /provider to switch."));
 }
@@ -15208,7 +16219,7 @@ __export(new_exports, {
   handler: () => handler6
 });
 import chalk20 from "chalk";
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { basename as basename4 } from "path";
 async function handler6(args, ctx) {
   const { positional, flags } = parseArgs(args, ["demo", "empty", "list-scenarios", "regen-taxonomy"]);
@@ -15230,7 +16241,7 @@ async function handler6(args, ctx) {
     console.error(chalk20.red("  Usage: /new <file.csv> | --demo [--scenario <name>] | --empty [--lens health|metrics]"));
     return;
   }
-  if (source.kind === "file" && !existsSync14(source.path)) {
+  if (source.kind === "file" && !existsSync16(source.path)) {
     console.error(chalk20.red(`  File not found: ${source.path}`));
     return;
   }
@@ -15297,11 +16308,11 @@ async function handler6(args, ctx) {
     return "New empty session";
   }
   if (lens === "revenue_metrics") {
-    const ora16 = (await import("ora")).default;
+    const ora19 = (await import("ora")).default;
     const { runMetricsAnalysis: runMetricsAnalysis2 } = await Promise.resolve().then(() => (init_metrics_analysis(), metrics_analysis_exports));
     const { renderMetricsReport: renderMetricsReport2 } = await Promise.resolve().then(() => (init_metrics_report(), metrics_report_exports));
     const structured = isStructuredOutput(ctx.execution);
-    const spinner = structured ? null : ora16({ text: "Computing SaaS metrics\u2026", indent: 2, discardStdin: false }).start();
+    const spinner = structured ? null : ora19({ text: "Computing SaaS metrics\u2026", indent: 2, discardStdin: false }).start();
     let result;
     try {
       result = await runMetricsAnalysis2({
@@ -15507,7 +16518,7 @@ __export(session_exports, {
   handler: () => handler8
 });
 import chalk22 from "chalk";
-import { join as join12 } from "path";
+import { join as join14 } from "path";
 import ora7 from "ora";
 async function handler8(args, ctx) {
   const sub = args[0];
@@ -15596,7 +16607,7 @@ async function pickUp(idArg, ctx) {
   }
   resetContextForSwitch(ctx, {
     sessionId: target.id,
-    sessionFile: join12(getSessionsDir(), `${target.id}.json`),
+    sessionFile: join14(getSessionsDir(), `${target.id}.json`),
     sessionName: session.name,
     messages: [...session.messages],
     conversation: session.thread ? [...session.thread] : [],
@@ -15908,7 +16919,7 @@ __export(report_exports, {
   handler: () => handler9
 });
 import chalk23 from "chalk";
-import { writeFileSync as writeFileSync8 } from "fs";
+import { writeFileSync as writeFileSync10 } from "fs";
 import { dirname as dirname2 } from "path";
 async function handler9(args, ctx) {
   const { flags } = parseArgs(args);
@@ -16004,7 +17015,7 @@ async function handler9(args, ctx) {
       if (!isInsideNtrp(resolvedOutput)) {
         console.warn(chalk23.yellow(`  Warning: writing report outside ~/.ntrp (${dirname2(resolvedOutput)})`));
       }
-      writeFileSync8(resolvedOutput, rendered);
+      writeFileSync10(resolvedOutput, rendered);
       console.log(chalk23.green(`  Report written to ${resolvedOutput}`));
     } else if (rendered) {
       console.log(rendered);
@@ -16035,8 +17046,8 @@ var init_report2 = __esm({
 });
 
 // src/output/notes-export.ts
-import { writeFileSync as writeFileSync9 } from "fs";
-import { join as join13 } from "path";
+import { writeFileSync as writeFileSync11 } from "fs";
+import { join as join15 } from "path";
 function exportToNotes(data) {
   const { computeResult, divergences, findings, exchanges } = data;
   const { aggregate, segments } = computeResult;
@@ -16045,7 +17056,7 @@ function exportToNotes(data) {
   const timeStr = formatTime(now2);
   const filename = `${dateStr}-${timeStr}-gtm-health.md`;
   const dir = getExportsDir();
-  const filepath = join13(dir, filename);
+  const filepath = join15(dir, filename);
   const severityTags = /* @__PURE__ */ new Set();
   for (const f of findings) severityTags.add(f.severity);
   const tags = ["ntrp", "gtm-health", ...severityTags];
@@ -16134,7 +17145,7 @@ function exportToNotes(data) {
     }
   }
   const content = frontmatter.join("\n") + "\n\n" + body.join("\n") + "\n";
-  writeFileSync9(filepath, content);
+  writeFileSync11(filepath, content);
   return filepath;
 }
 function formatDate(d) {
@@ -16274,8 +17285,8 @@ __export(backmeup_exports, {
 });
 import chalk25 from "chalk";
 import Papa5 from "papaparse";
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync10 } from "fs";
-import { join as join14 } from "path";
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync12 } from "fs";
+import { join as join16 } from "path";
 function sanitizeCsvValue(value) {
   if (typeof value !== "string") return value;
   return CSV_FORMULA_RE.test(value) ? `'${value}` : value;
@@ -16311,7 +17322,7 @@ async function handler11(args, _ctx) {
     if (!isInsideNtrp(baseDir)) {
       console.warn(chalk25.yellow(`  Warning: writing backup outside ~/.ntrp (${baseDir})`));
     }
-    const folder = join14(baseDir, folderName);
+    const folder = join16(baseDir, folderName);
     mkdirSync9(folder, { recursive: true });
     const generatedAt = now2.toISOString();
     let fileCount = 0;
@@ -16326,7 +17337,7 @@ async function handler11(args, _ctx) {
       "Total At Risk": health.total_value_at_risk != null ? formatCurrency(health.total_value_at_risk) : "N/A",
       "Generated At": generatedAt
     }));
-    writeFileSync10(join14(folder, "cover-sheet.csv"), Papa5.unparse(sanitizeCsvRows(coverRows)), "utf-8");
+    writeFileSync12(join16(folder, "cover-sheet.csv"), Papa5.unparse(sanitizeCsvRows(coverRows)), "utf-8");
     fileCount++;
     if (findings.length > 0) {
       const findingsRows = findings.map((f) => ({
@@ -16336,7 +17347,7 @@ async function handler11(args, _ctx) {
         Finding: f.finding,
         "Recommended Plays": f.recommended_plays ? f.recommended_plays.map((p) => p.play_name).join("; ") : ""
       }));
-      writeFileSync10(join14(folder, "findings.csv"), Papa5.unparse(sanitizeCsvRows(findingsRows)), "utf-8");
+      writeFileSync12(join16(folder, "findings.csv"), Papa5.unparse(sanitizeCsvRows(findingsRows)), "utf-8");
       fileCount++;
     }
     for (const vs of health.vital_signs) {
@@ -16346,7 +17357,7 @@ async function handler11(args, _ctx) {
         ...detail
       }));
       const filename = EVIDENCE_FILENAMES[vs.vital_sign] ?? `${vs.vital_sign}.csv`;
-      writeFileSync10(join14(folder, filename), Papa5.unparse(sanitizeCsvRows(rows)), "utf-8");
+      writeFileSync12(join16(folder, filename), Papa5.unparse(sanitizeCsvRows(rows)), "utf-8");
       fileCount++;
     }
     console.log(chalk25.green(`
@@ -16540,8 +17551,8 @@ var init_bundle = __esm({
 });
 
 // src/repositories/markdown.ts
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync11 } from "fs";
-import { basename as basename5, dirname as dirname3, join as join15, resolve as resolve6 } from "path";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync13 } from "fs";
+import { basename as basename5, dirname as dirname3, join as join17, resolve as resolve6 } from "path";
 import { stringify as stringifyYaml } from "yaml";
 function renderMarkdownFiles(pkg) {
   const bundleJson = JSON.stringify(pkg, null, 2) + "\n";
@@ -16764,9 +17775,9 @@ var init_markdown3 = __esm({
         mkdirSync10(root, { recursive: true });
         const written = [];
         for (const file of files) {
-          const absolutePath = join15(root, file.relativePath);
+          const absolutePath = join17(root, file.relativePath);
           mkdirSync10(dirname3(absolutePath), { recursive: true });
-          writeFileSync11(absolutePath, file.contents, "utf-8");
+          writeFileSync13(absolutePath, file.contents, "utf-8");
           written.push(absolutePath);
         }
         return {
@@ -17070,8 +18081,8 @@ __export(handoff_exports, {
   handler: () => handler13
 });
 import chalk27 from "chalk";
-import { writeFileSync as writeFileSync12 } from "fs";
-import { join as join16 } from "path";
+import { writeFileSync as writeFileSync14 } from "fs";
+import { join as join18 } from "path";
 async function handler13(args, ctx) {
   const sub = args[0];
   if (!sub) {
@@ -17129,7 +18140,7 @@ async function interactiveMenu(ctx) {
   }
 }
 async function runReport(args, ctx) {
-  const out = join16(getExportsDir(), `report-${stamp()}.md`);
+  const out = join18(getExportsDir(), `report-${stamp()}.md`);
   const { handler: report } = await Promise.resolve().then(() => (init_report2(), report_exports));
   await report(["--format", "md", "--output", out, ...args], ctx);
   recordDeliverable(ctx, { kind: "report", at: (/* @__PURE__ */ new Date()).toISOString(), path: out });
@@ -17177,8 +18188,8 @@ async function runPrompt(target, ctx) {
     return;
   }
   const prompt = draft.markdown;
-  const out = join16(getExportsDir(), `handoff-${target}-${stamp()}.md`);
-  writeFileSync12(out, prompt, "utf-8");
+  const out = join18(getExportsDir(), `handoff-${target}-${stamp()}.md`);
+  writeFileSync14(out, prompt, "utf-8");
   recordDeliverable(ctx, { kind: `prompt:${target}`, at: (/* @__PURE__ */ new Date()).toISOString(), path: out });
   console.log();
   console.log("  " + paint("accent", `Agent prompt ready (${target})`));
@@ -18050,24 +19061,24 @@ JSON SHAPE:
 
 // src/strategies/readers.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync15, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync13 } from "fs";
 import { extname, resolve as resolve7 } from "path";
 import { parse as parseYaml } from "yaml";
 import { PDFParse } from "pdf-parse";
 async function readStrategyFile(pathOrDash) {
   if (pathOrDash === "-") {
-    const text2 = readFileSync10(0, "utf-8");
+    const text2 = readFileSync13(0, "utf-8");
     return createDocument("stdin", null, text2, {});
   }
   const sourcePath = resolve7(pathOrDash);
-  if (!existsSync15(sourcePath)) {
+  if (!existsSync17(sourcePath)) {
     throw new NtrpError("strategy_file_not_found", `Strategy file not found: ${pathOrDash}`, 2 /* Usage */);
   }
   const ext = extname(sourcePath).toLowerCase();
   if (ext === ".pdf") {
     return readPdf(sourcePath);
   }
-  const text = readFileSync10(sourcePath, "utf-8");
+  const text = readFileSync13(sourcePath, "utf-8");
   if (ext === ".yaml" || ext === ".yml") {
     const structured = parseStructuredYaml(text);
     return createDocument("yaml", sourcePath, text, structured);
@@ -18082,7 +19093,7 @@ function readStrategyText(text) {
   return createDocument("text", null, text, {});
 }
 async function readPdf(sourcePath) {
-  const data = readFileSync10(sourcePath);
+  const data = readFileSync13(sourcePath);
   const parser = new PDFParse({ data });
   try {
     const result = await parser.getText();
@@ -18129,15 +19140,15 @@ var init_readers = __esm({
 });
 
 // src/strategies/library.ts
-import { writeFileSync as writeFileSync13 } from "fs";
-import { join as join17 } from "path";
+import { writeFileSync as writeFileSync15 } from "fs";
+import { join as join19 } from "path";
 import { stringify as stringifyYaml2 } from "yaml";
 function strategyLibraryPath(slug) {
-  return join17(getStrategiesDir(), `${slug}.md`);
+  return join19(getStrategiesDir(), `${slug}.md`);
 }
 function writeStrategyMarkdown(strategy) {
   const path = strategyLibraryPath(strategy.slug);
-  writeFileSync13(path, renderStrategyMarkdown(strategy), "utf-8");
+  writeFileSync15(path, renderStrategyMarkdown(strategy), "utf-8");
   return path;
 }
 function renderStrategyMarkdown(strategy) {
@@ -18211,7 +19222,7 @@ var init_library = __esm({
 // src/strategies/connectors.ts
 import { readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import { homedir as homedir7 } from "os";
-import { basename as basename6, extname as extname2, join as join18, relative, resolve as resolve8, sep as sep3 } from "path";
+import { basename as basename6, extname as extname2, join as join20, relative, resolve as resolve8, sep as sep3 } from "path";
 function createLocalFolderConnector(options) {
   const rootPath = resolveUserPath2(options.rootPath);
   const name = options.name ?? (basename6(rootPath) || "local");
@@ -18254,7 +19265,7 @@ function createLocalFolderConnector(options) {
 }
 function walkLocalFolder(rootPath, currentPath, refs, opts) {
   for (const entry of readdirSync2(currentPath, { withFileTypes: true })) {
-    const absolutePath = join18(currentPath, entry.name);
+    const absolutePath = join20(currentPath, entry.name);
     const relativePath = normalizePath(relative(rootPath, absolutePath));
     if (entry.isDirectory()) {
       if (shouldSkipDirectory(entry.name) || matchesAny(relativePath, opts.excludePatterns)) continue;
@@ -18318,7 +19329,7 @@ function normalizePath(path) {
 }
 function resolveUserPath2(path) {
   if (path === "~") return homedir7();
-  if (path.startsWith("~/")) return join18(homedir7(), path.slice(2));
+  if (path.startsWith("~/")) return join20(homedir7(), path.slice(2));
   return resolve8(path);
 }
 var DEFAULT_MAX_FILES, DEFAULT_MAX_BYTES, SUPPORTED_EXTENSIONS, DEFAULT_EXCLUDED_DIRS;
@@ -19442,18 +20453,25 @@ __export(config_exports, {
   handler: () => handler23
 });
 import chalk38 from "chalk";
+import ora10 from "ora";
+function secretKeys() {
+  const keys = /* @__PURE__ */ new Set(["license-key", "license-instance-id", "voyage-api-key", "tavily-api-key", "brave-api-key"]);
+  for (const spec of listProviderSpecs()) keys.add(spec.key_config_name);
+  return keys;
+}
 function display(key, value) {
-  return SECRET_KEYS.has(key) ? String(value).slice(0, 10) + "..." : String(value);
+  return secretKeys().has(key) ? String(value).slice(0, 10) + "..." : String(value);
 }
 function secretPromptLabel(key) {
-  if (key === "api-key") return "Anthropic API key";
-  if (key === "openai-api-key") return "OpenAI API key";
+  const spec = findSpecByConfigKey(key);
+  if (spec) return `${spec.label} API key`;
   if (key === "license-key") return "License key";
   return key;
 }
 function usage() {
   console.log(chalk38.dim("  Usage: /config <get|set|list|delete> [key] [value]"));
   console.log(chalk38.dim("  Tip: ") + paint("accent", "/config set api-key") + chalk38.dim(" opens a hidden prompt (no inline paste)."));
+  console.log(chalk38.dim("  Tip: ") + paint("accent", "/connect") + chalk38.dim(" auto-detects the provider from any pasted key."));
 }
 function fail(message, ctx) {
   console.error(chalk38.red(`  ${message}`));
@@ -19485,7 +20503,7 @@ async function handler23(args, ctx) {
         return;
       }
       let value = inlineValue;
-      if (!value && SECRET_KEYS.has(key)) {
+      if (!value && secretKeys().has(key)) {
         try {
           value = await promptSecretValue(key, ctx);
         } catch (err) {
@@ -19505,8 +20523,24 @@ async function handler23(args, ctx) {
       }
       console.log();
       console.log(chalk38.green(`  \u2713 ${key} saved`) + chalk38.dim(` (${display(key, value)})`));
-      if (key === "api-key" || key === "openai-api-key") {
-        console.log("  " + chalk38.dim("Keys enable AI after analysis. Add both to switch engines with /provider."));
+      const spec = findSpecByConfigKey(key);
+      if (spec) {
+        const spinner = ora10({ text: `Discovering ${spec.label} models\u2026`, discardStdin: false }).start();
+        try {
+          const { refreshProviderModels: refreshProviderModels2 } = await Promise.resolve().then(() => (init_discovery(), discovery_exports));
+          const entry = await refreshProviderModels2(spec.id, { apiKey: value, force: true });
+          if (entry) {
+            spinner.succeed(`${spec.label}: ${entry.models.length} chat models available.`);
+            console.log(
+              "  " + chalk38.dim(`high ${entry.tier_stack.high} \xB7 medium ${entry.tier_stack.medium} \xB7 low ${entry.tier_stack.low}`)
+            );
+          } else {
+            spinner.warn(`${spec.label} unreachable \u2014 models will be discovered on first use.`);
+          }
+        } catch {
+          spinner.warn(`${spec.label} unreachable \u2014 models will be discovered on first use.`);
+        }
+        console.log("  " + chalk38.dim("Switch engines with /provider \xB7 browse models with /model list."));
       }
       console.log();
       return;
@@ -19549,15 +20583,14 @@ async function handler23(args, ctx) {
     }
   }
 }
-var SECRET_KEYS;
 var init_config = __esm({
   "src/commands/config.ts"() {
     "use strict";
     init_store();
+    init_providers();
     init_argparse();
     init_prompts();
     init_theme();
-    SECRET_KEYS = /* @__PURE__ */ new Set(["api-key", "openai-api-key", "license-key", "license-instance-id"]);
   }
 });
 
@@ -20246,15 +21279,15 @@ var init_checkout = __esm({
 });
 
 // src/services/setup.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync11, readFileSync as readFileSync11, writeFileSync as writeFileSync14 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync16 } from "fs";
+import { join as join21 } from "path";
 function setupCheck() {
   const home = ntrpHome();
   let writable = false;
   try {
     mkdirSync11(home, { recursive: true });
-    const probe = join19(home, ".write-check");
-    writeFileSync14(probe, "ok\n");
+    const probe = join21(home, ".write-check");
+    writeFileSync16(probe, "ok\n");
     writable = true;
   } catch {
     writable = false;
@@ -20279,7 +21312,8 @@ function setupCheck() {
         tier: llmCfg.tier,
         auto_failover: llmCfg.autoFailover,
         anthropic: llmReady.anthropic,
-        openai: llmReady.openai
+        openai: llmReady.openai,
+        providers: llmReady.providers
       }
     },
     license: {
@@ -20291,7 +21325,7 @@ function setupCheck() {
   };
 }
 function readProfileInput(pathOrDash) {
-  const raw = pathOrDash === "-" ? readFileSync11(0, "utf-8") : readFileSync11(pathOrDash, "utf-8");
+  const raw = pathOrDash === "-" ? readFileSync14(0, "utf-8") : readFileSync14(pathOrDash, "utf-8");
   return JSON.parse(raw);
 }
 function writeAgentProfile(input) {
@@ -20316,11 +21350,15 @@ function writeAgentProfile(input) {
   saveProfile(profile);
   return profile;
 }
-function applyAgentConfig(opts) {
+async function applyAgentConfig(opts) {
   if (opts.defaultFormat) setConfigValue("default-format", opts.defaultFormat);
   if (opts.apiKey) setConfigValue("api-key", opts.apiKey);
   if (opts.openaiApiKey) setConfigValue("openai-api-key", opts.openaiApiKey);
-  if (opts.llmPrimary === "anthropic" || opts.llmPrimary === "openai") {
+  if (opts.llmKey) {
+    const { connectWithKey: connectWithKey2 } = await Promise.resolve().then(() => (init_connect(), connect_exports));
+    await connectWithKey2(opts.llmKey, { providerId: opts.llmProvider });
+  }
+  if (opts.llmPrimary && getProviderSpec(opts.llmPrimary)) {
     setConfigValue("llm-primary", opts.llmPrimary);
   }
   if (opts.licenseKey) setConfigValue("license-key", opts.licenseKey);
@@ -20330,6 +21368,7 @@ var init_setup = __esm({
   "src/services/setup.ts"() {
     "use strict";
     init_repl_api();
+    init_providers();
     init_llm_config();
     init_store();
     init_profile();
@@ -20372,13 +21411,12 @@ async function handler27(args, ctx) {
         console.log(`  Writable: ${result.writable ? "yes" : "no"}`);
         console.log(`  Profile: ${result.profile.exists ? "ready" : "missing"} (${result.profile.path})`);
         const llm = result.config.llm;
-        if (llm) {
-          const engines = (llm.anthropic ? 1 : 0) + (llm.openai ? 1 : 0);
-          console.log(`  Engines: ${engines} \xB7 default ${llm.primary} \xB7 tier ${llm.tier}`);
-          console.log(`    Anthropic: ${llm.anthropic ? "set" : "missing"} \xB7 OpenAI: ${llm.openai ? "set" : "missing"}`);
+        if (llm && llm.providers.length > 0) {
+          console.log(`  Engines: ${llm.providers.length} \xB7 default ${llm.primary} \xB7 tier ${llm.tier}`);
+          console.log(`    Connected: ${llm.providers.join(", ")}`);
           console.log(`    Auto-failover: ${llm.auto_failover ? "on" : "off"}`);
         } else {
-          console.log("  Engines: missing");
+          console.log("  Engines: missing \u2014 run /connect with any provider key");
         }
         console.log(`  License: ${formatLicenseSetupLine(result.license)}`);
         console.log();
@@ -20399,10 +21437,12 @@ async function handler27(args, ctx) {
             sales_motion: getString(flags, "sales-motion")
           };
         }
-        applyAgentConfig({
+        await applyAgentConfig({
           defaultFormat: getString(flags, "default-format"),
           apiKey: getString(flags, "api-key"),
           openaiApiKey: getString(flags, "openai-api-key"),
+          llmKey: getString(flags, "llm-key"),
+          llmProvider: getString(flags, "llm-provider"),
           llmPrimary: getString(flags, "llm-primary"),
           licenseKey: getString(flags, "license-key"),
           exportDir: getString(flags, "export-dir")
@@ -20442,13 +21482,13 @@ var init_setup2 = __esm({
 
 // src/conversation/orchestrator.ts
 import chalk43 from "chalk";
-import { writeFileSync as writeFileSync15 } from "fs";
-import { join as join20 } from "path";
+import { writeFileSync as writeFileSync17 } from "fs";
+import { join as join22 } from "path";
 async function handleExploreWithoutKey(ctx) {
   console.log();
   console.log("  " + chalk43.red("AI interpretation needs an LLM API key saved in config."));
   console.log(
-    "  " + chalk43.dim("Set with: ") + paint("accent", "/config set api-key") + chalk43.dim(" (Anthropic) or ") + paint("accent", "/config set openai-api-key")
+    "  " + chalk43.dim("Run ") + paint("accent", "/connect") + chalk43.dim(" and paste any provider's key (Anthropic, OpenAI, Groq, Gemini, ...).")
   );
   console.log("  " + chalk43.dim("Number crunching works without a key \u2014 only Q&A in the REPL needs one."));
   if (ctx.gapAudit) {
@@ -20620,8 +21660,8 @@ async function callProvider(texts) {
 async function embedText(text) {
   const key = text.trim();
   if (!key) return null;
-  const cached = cache.get(key);
-  if (cached) return cached;
+  const cached2 = cache.get(key);
+  if (cached2) return cached2;
   const result = await callProvider([key]);
   const vec = result?.[0] ?? null;
   if (vec) cache.set(key, vec);
@@ -20631,8 +21671,8 @@ async function embedItems(items) {
   const needing = [];
   const out = items.map((it, index) => {
     if (it.embedding && it.embedding.length > 0) return { ...it };
-    const cached = cache.get(it.text.trim());
-    if (cached) return { ...it, embedding: cached };
+    const cached2 = cache.get(it.text.trim());
+    if (cached2) return { ...it, embedding: cached2 };
     needing.push({ index, text: it.text });
     return { ...it };
   });
@@ -20791,17 +21831,17 @@ var init_retrieval = __esm({
 });
 
 // src/memory/knowledge.ts
-import { existsSync as existsSync17, readFileSync as readFileSync12, appendFileSync as appendFileSync3, readdirSync as readdirSync3 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync15, appendFileSync as appendFileSync3, readdirSync as readdirSync3 } from "fs";
+import { join as join23 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 function knowledgePath() {
-  return join21(getMemoryDir(), KNOWLEDGE_FILE);
+  return join23(getMemoryDir(), KNOWLEDGE_FILE);
 }
 function loadKnowledgeChunks() {
   const path = knowledgePath();
-  if (!existsSync17(path)) return [];
+  if (!existsSync19(path)) return [];
   const out = [];
-  for (const line of readFileSync12(path, "utf-8").split("\n")) {
+  for (const line of readFileSync15(path, "utf-8").split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     try {
@@ -20902,17 +21942,17 @@ __export(store_exports2, {
   rewriteJsonl: () => rewriteJsonl,
   scrubText: () => scrubText
 });
-import { existsSync as existsSync18, readFileSync as readFileSync13, appendFileSync as appendFileSync4, readdirSync as readdirSync4, writeFileSync as writeFileSync16 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync16, appendFileSync as appendFileSync4, readdirSync as readdirSync4, writeFileSync as writeFileSync18 } from "fs";
+import { join as join24 } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 function memPath(file) {
-  return join22(getMemoryDir(), file);
+  return join24(getMemoryDir(), file);
 }
 function readJsonl(file) {
   const path = memPath(file);
-  if (!existsSync18(path)) return [];
+  if (!existsSync20(path)) return [];
   const out = [];
-  for (const line of readFileSync13(path, "utf-8").split("\n")) {
+  for (const line of readFileSync16(path, "utf-8").split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     try {
@@ -20930,7 +21970,7 @@ function appendJsonl(file, obj) {
 }
 function rewriteJsonl(file, rows) {
   try {
-    writeFileSync16(memPath(file), rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length ? "\n" : ""));
+    writeFileSync18(memPath(file), rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length ? "\n" : ""));
   } catch {
   }
 }
@@ -20992,7 +22032,7 @@ function loadWinSnippets() {
     const out = [];
     for (const name of readdirSync4(dir)) {
       if (!name.endsWith(".md") || name.toLowerCase() === "readme.md") continue;
-      const raw = readFileSync13(join22(dir, name), "utf-8");
+      const raw = readFileSync16(join24(dir, name), "utf-8");
       const title = raw.match(/^#\s+(.+)$/m)?.[1]?.trim() ?? name.replace(/\.md$/, "");
       const body = raw.replace(/^#.*$/m, "").replace(/\s+/g, " ").trim().slice(0, 300);
       out.push({ id: `win:${name}`, title, text: `${title}. ${body}` });
@@ -21081,7 +22121,7 @@ var init_store2 = __esm({
 });
 
 // src/services/smoke-protocol.ts
-import { join as join23 } from "path";
+import { join as join25 } from "path";
 function isSmokeProtocolTrigger(input) {
   return normalize(input).includes(SMOKE_TRIGGER_PHRASE);
 }
@@ -21117,7 +22157,7 @@ async function runSmokeProtocol(_input, ctx) {
   });
   const proposalResult = await proposeRepositoryExport({
     target: "markdown",
-    directory: join23(getExportsDir(), "repository-smoke"),
+    directory: join25(getExportsDir(), "repository-smoke"),
     source: "smoke_protocol",
     modelOrFixture: "smoke-protocol-v1"
   });
@@ -21210,13 +22250,13 @@ var init_smoke_protocol = __esm({
 });
 
 // src/cli/nl.ts
-import ora10 from "ora";
+import ora11 from "ora";
 import chalk44 from "chalk";
 async function runNaturalLanguage(input, ctx) {
   if (isSmokeProtocolTrigger(input)) {
     recordMessage(ctx, "user", input);
     console.log();
-    const spinner2 = ora10({ text: "Running smoke protocol\u2026", color: "cyan", discardStdin: false }).start();
+    const spinner2 = ora11({ text: "Running smoke protocol\u2026", color: "cyan", discardStdin: false }).start();
     try {
       const result = await runSmokeProtocol(input, ctx);
       spinner2.succeed("Smoke protocol complete");
@@ -21243,7 +22283,7 @@ async function runNaturalLanguage(input, ctx) {
   let snapshot = ctx.snapshot.computeResult;
   if (!snapshot) {
     const metricsFirst = prefersMetricsFirstContext(ctx);
-    const spinner2 = ora10({
+    const spinner2 = ora11({
       text: metricsFirst ? "Loading session context\u2026" : "Computing vital signs\u2026",
       color: "cyan",
       discardStdin: false
@@ -21268,7 +22308,7 @@ async function runNaturalLanguage(input, ctx) {
   }
   console.log();
   const memoryBlock = await buildMemoryBlock(input).catch(() => "");
-  const spinner = ora10({ text: "Thinking\u2026", color: "cyan", discardStdin: false }).start();
+  const spinner = ora11({ text: "Thinking\u2026", color: "cyan", discardStdin: false }).start();
   let lastAnswer = "";
   let rawHistory = [];
   const toolsUsed = [];
@@ -21559,7 +22599,7 @@ __export(metrics_exports, {
   handler: () => handler29
 });
 import chalk46 from "chalk";
-import ora11 from "ora";
+import ora12 from "ora";
 async function handler29(args, ctx) {
   await hydrateAnalysisFromPersistedState(ctx);
   const { flags } = parseArgs(args, ["findings"]);
@@ -21601,7 +22641,7 @@ async function handler29(args, ctx) {
   await initSchema();
   await autoGenerateSegments();
   printCompanionBanner("metrics", ctx.analysis.primary);
-  const spinner = ora11({
+  const spinner = ora12({
     text: "Computing SaaS metrics\u2026",
     indent: 2,
     discardStdin: false
@@ -21800,7 +22840,7 @@ __export(feedback_exports, {
   handler: () => handler30
 });
 import chalk47 from "chalk";
-import ora12 from "ora";
+import ora13 from "ora";
 async function handler30(args, ctx) {
   const feedbackText = args.join(" ").trim();
   if (!feedbackText) {
@@ -21828,7 +22868,7 @@ async function handler30(args, ctx) {
     console.log();
     return;
   }
-  const spinner = ora12({ text: "Applying feedback\u2026", discardStdin: false }).start();
+  const spinner = ora13({ text: "Applying feedback\u2026", discardStdin: false }).start();
   try {
     const result = await applyFeedback(profile, feedbackText, ctx);
     spinner.succeed("Feedback applied");
@@ -21860,7 +22900,7 @@ var recap_exports = {};
 __export(recap_exports, {
   handler: () => handler31
 });
-import ora13 from "ora";
+import ora14 from "ora";
 import chalk48 from "chalk";
 async function handler31(_args, ctx) {
   if (ctx.messages.length === 0) {
@@ -21897,7 +22937,7 @@ ${companyBlock}` : "",
     const prefix = msg.role === "user" ? "USER" : "ASSISTANT";
     conversationLines.push(`[${prefix}]: ${msg.content}`);
   }
-  const spinner = ora13({ text: "Summarizing session\u2026", color: "cyan", discardStdin: false }).start();
+  const spinner = ora14({ text: "Summarizing session\u2026", color: "cyan", discardStdin: false }).start();
   try {
     const { text: fullText } = await llmStreamText(
       "recap",
@@ -22025,7 +23065,7 @@ var init_recall = __esm({
 
 // src/memory/feedback.ts
 import { appendFileSync as appendFileSync5 } from "fs";
-import { join as join24 } from "path";
+import { join as join26 } from "path";
 import { randomUUID as randomUUID6 } from "crypto";
 function summarize(text) {
   return text.replace(/[#*`>_]/g, "").replace(/\s+/g, " ").trim().slice(0, 200);
@@ -22041,7 +23081,7 @@ function recordFeedback(input) {
     created_at: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
-    appendFileSync5(join24(getMemoryDir(), "feedback.jsonl"), JSON.stringify(entry) + "\n");
+    appendFileSync5(join26(getMemoryDir(), "feedback.jsonl"), JSON.stringify(entry) + "\n");
   } catch {
   }
   if (input.rating === "positive") {
@@ -22132,7 +23172,7 @@ __export(knowledge_exports, {
   handler: () => handler35
 });
 import chalk52 from "chalk";
-import ora14 from "ora";
+import ora15 from "ora";
 async function handler35(args, ctx) {
   const sub = (args[0] ?? "list").toLowerCase();
   if (sub === "add") {
@@ -22144,7 +23184,7 @@ async function handler35(args, ctx) {
       console.log();
       return;
     }
-    const spin = ctx.execution.progress ? ora14({ text: "Ingesting knowledge\u2026", color: "cyan", discardStdin: false }).start() : null;
+    const spin = ctx.execution.progress ? ora15({ text: "Ingesting knowledge\u2026", color: "cyan", discardStdin: false }).start() : null;
     try {
       const result = await addKnowledgeFile(path);
       spin?.succeed(`Indexed "${result.title}"`);
@@ -22454,8 +23494,8 @@ var switch_exports = {};
 __export(switch_exports, {
   handler: () => handler39
 });
-import { join as join25 } from "path";
-import ora15 from "ora";
+import { join as join27 } from "path";
+import ora16 from "ora";
 import chalk56 from "chalk";
 async function handler39(args, ctx) {
   if (args.length === 0) {
@@ -22470,7 +23510,7 @@ async function handler39(args, ctx) {
   }
   const exchangeCount = Math.floor(ctx.messages.length / 2);
   if (exchangeCount > 0) {
-    const spinner = ora15({ text: "Saving current session\u2026", color: "cyan", discardStdin: false }).start();
+    const spinner = ora16({ text: "Saving current session\u2026", color: "cyan", discardStdin: false }).start();
     await closeSession(ctx);
     const fromLabel = ctx.sessionName ? `"${ctx.sessionName}"` : ctx.sessionId.slice(-4);
     spinner.succeed(`Saved ${fromLabel}`);
@@ -22485,7 +23525,7 @@ async function handler39(args, ctx) {
     }
     const context = buildSwitchContext(session);
     const newId = makeSessionId();
-    const newFile = join25(getSessionsDir(), `${newId}.json`);
+    const newFile = join27(getSessionsDir(), `${newId}.json`);
     resetContextForSwitch(ctx, {
       sessionId: newId,
       sessionFile: newFile,
@@ -22511,7 +23551,7 @@ async function handler39(args, ctx) {
     return `Switched to "${targetName}"`;
   } else {
     const newId = makeSessionId();
-    const newFile = join25(getSessionsDir(), `${newId}.json`);
+    const newFile = join27(getSessionsDir(), `${newId}.json`);
     resetContextForSwitch(ctx, {
       sessionId: newId,
       sessionFile: newFile,
@@ -22561,13 +23601,177 @@ var init_switch = __esm({
   }
 });
 
-// src/commands/provider.ts
-var provider_exports = {};
-__export(provider_exports, {
+// src/commands/connect.ts
+var connect_exports2 = {};
+__export(connect_exports2, {
   handler: () => handler40
 });
 import chalk57 from "chalk";
+import ora17 from "ora";
+function usage2() {
+  console.log(chalk57.dim("  Usage: /connect                      paste any provider key"));
+  console.log(chalk57.dim("         /connect <provider>           key for a specific provider (or: ollama)"));
+  console.log(chalk57.dim("         /connect --key <key>          non-interactive (auto-detects provider)"));
+  console.log(chalk57.dim("         /connect --base-url <url> [--id <name>] [--key <key>]   custom endpoint"));
+}
+function printOutcome(outcome, ctx) {
+  console.log();
+  const [headline, ...rest] = describeConnectOutcome(outcome);
+  console.log("  " + paint("success", "\u2713") + " " + chalk57.bold(headline ?? ""));
+  for (const line of rest) {
+    console.log("    " + chalk57.dim(line));
+  }
+  console.log();
+  console.log("  " + chalk57.dim(`Active stack: ${formatActiveStack(ctx)}`));
+  console.log("  " + chalk57.dim("/provider to switch engines \xB7 /model list to browse models"));
+  console.log();
+}
+function printError(err, ctx) {
+  const message = err instanceof Error ? err.message : String(err);
+  console.log();
+  console.log("  " + chalk57.red(message));
+  console.log();
+  if (ctx.oneShot) process.exit(1);
+}
+async function promptKey(session, label) {
+  console.log();
+  console.log(
+    "  " + chalk57.dim("Paste once, press Enter. Stored in ") + paint("accent", "~/.ntrp/config.json") + chalk57.dim(" only.")
+  );
+  return session.askSecret(label, { confirm: false });
+}
 async function handler40(args, ctx) {
+  const { positional, flags } = parseArgs(args);
+  const sub = positional[0]?.toLowerCase();
+  if (sub === "help") {
+    usage2();
+    return;
+  }
+  const inlineKey = getString(flags, "key");
+  const baseUrl = getString(flags, "base-url", "url");
+  const forcedProvider = getString(flags, "provider") ?? (sub && sub !== "help" ? sub : void 0);
+  const customId = getString(flags, "id");
+  const label = getString(flags, "label");
+  const forcedSpec = forcedProvider ? getProviderSpec(forcedProvider) : void 0;
+  if (forcedSpec && !forcedSpec.requires_key && !inlineKey) {
+    const spinner2 = ora17({ text: `Looking for ${forcedSpec.label}\u2026`, discardStdin: false }).start();
+    try {
+      const outcome = await connectKeyless(forcedSpec.id, baseUrl);
+      spinner2.stop();
+      printOutcome(outcome, ctx);
+    } catch (err) {
+      spinner2.stop();
+      printError(err, ctx);
+    }
+    return;
+  }
+  if (baseUrl && !forcedSpec) {
+    const id = customId ?? forcedProvider ?? hostToId(baseUrl);
+    let key2 = inlineKey;
+    if (!key2 && !ctx.oneShot && process.stdin.isTTY) {
+      const session2 = createPromptSession(ctx.rl, ctx);
+      try {
+        const needsKey = await session2.confirm("Does this endpoint need an API key?", false);
+        if (needsKey) key2 = await promptKey(session2, `API key for ${id}`);
+      } finally {
+        session2.close();
+      }
+    }
+    const spinner2 = ora17({ text: `Checking ${baseUrl}\u2026`, discardStdin: false }).start();
+    try {
+      const outcome = await connectCustomEndpoint({ id, baseUrl, key: key2, label });
+      spinner2.stop();
+      printOutcome(outcome, ctx);
+    } catch (err) {
+      spinner2.stop();
+      printError(err, ctx);
+    }
+    return;
+  }
+  if (forcedProvider && !forcedSpec) {
+    console.log();
+    console.log("  " + chalk57.red(`Unknown provider: ${forcedProvider}`));
+    console.log(
+      "  " + chalk57.dim("Built-ins: anthropic, openai, google, groq, mistral, deepseek, xai, openrouter, together, fireworks, ollama")
+    );
+    console.log("  " + chalk57.dim(`Custom endpoint: /connect --base-url <url> --id ${forcedProvider}`));
+    console.log();
+    if (ctx.oneShot) process.exit(1);
+    return;
+  }
+  let key = inlineKey;
+  let session;
+  if (!key) {
+    if (ctx.oneShot || !process.stdin.isTTY) {
+      printError(new ConnectError("Non-interactive mode needs --key <key>."), ctx);
+      usage2();
+      return;
+    }
+    session = createPromptSession(ctx.rl, ctx);
+    key = await promptKey(
+      session,
+      forcedSpec ? `${forcedSpec.label} API key` : "LLM API key (any provider)"
+    );
+  }
+  const spinner = ora17({ text: "Identifying provider\u2026", discardStdin: false }).start();
+  try {
+    const outcome = await connectWithKey(key, {
+      providerId: forcedSpec?.id,
+      callbacks: session ? {
+        confirmDetection: async (providerId) => {
+          spinner.stop();
+          return session.confirm(`Detected ${providerLabel(providerId)} \u2014 connect it?`, true);
+        },
+        chooseProvider: async (accepted) => {
+          spinner.stop();
+          return session.choose(
+            "Multiple providers accepted this key \u2014 which is it?",
+            accepted.map((a) => ({ value: a.provider, label: providerLabel(a.provider) }))
+          );
+        }
+      } : void 0
+    });
+    spinner.stop();
+    printOutcome(outcome, ctx);
+  } catch (err) {
+    spinner.stop();
+    if (err instanceof ConnectCancelled) {
+      console.log("  " + chalk57.dim("Cancelled."));
+      console.log();
+    } else {
+      printError(err, ctx);
+    }
+  } finally {
+    session?.close();
+  }
+}
+function hostToId(url) {
+  try {
+    const host = new URL(url).hostname;
+    return host.replace(/^www\./, "").split(".")[0] ?? "custom";
+  } catch {
+    return "custom";
+  }
+}
+var init_connect2 = __esm({
+  "src/commands/connect.ts"() {
+    "use strict";
+    init_argparse();
+    init_prompts();
+    init_providers();
+    init_session_state();
+    init_connect();
+    init_theme();
+  }
+});
+
+// src/commands/provider.ts
+var provider_exports = {};
+__export(provider_exports, {
+  handler: () => handler41
+});
+import chalk58 from "chalk";
+async function handler41(args, ctx) {
   const { positional, flags } = parseArgs(args, ["default"]);
   const sub = positional[0]?.toLowerCase();
   if (!sub || sub === "list") {
@@ -22579,7 +23783,7 @@ async function handler40(args, ctx) {
     if (!ctx.oneShot) saveSessionState(ctx);
     console.log();
     console.log("  " + paint("success", "\u2713") + " Session engine reset \u2014 using config defaults.");
-    console.log("  " + chalk57.dim(`Default: ${loadLlmConfig().primary}`));
+    console.log("  " + chalk58.dim(`Default: ${loadLlmConfig().primary}`));
     console.log();
     return;
   }
@@ -22592,7 +23796,7 @@ async function handler40(args, ctx) {
       setConfigValue("llm-auto-failover", session.autoFailover ? "on" : "off");
     }
     console.log();
-    console.log("  " + paint("success", "\u2713") + ` Saved ${chalk57.bold(active)} as default engine.`);
+    console.log("  " + paint("success", "\u2713") + ` Saved ${chalk58.bold(active)} as default engine.`);
     console.log();
     return;
   }
@@ -22611,36 +23815,40 @@ async function handler40(args, ctx) {
     }
     console.log();
     console.log(
-      "  " + paint("success", "\u2713") + ` Auto-failover ${session.autoFailover ? chalk57.bold("on") : chalk57.bold("off")} for this session.`
+      "  " + paint("success", "\u2713") + ` Auto-failover ${session.autoFailover ? chalk58.bold("on") : chalk58.bold("off")} for this session.`
     );
-    if (persist) console.log("  " + chalk57.dim("Also saved as config default."));
+    if (persist) console.log("  " + chalk58.dim("Also saved as config default."));
     console.log();
     return;
   }
-  if (!PROVIDERS.includes(sub)) {
+  const spec = getProviderSpec(sub);
+  if (!spec || RESERVED.has(sub)) {
     console.log();
-    console.log("  " + chalk57.red(`Unknown engine: ${sub}`));
-    console.log("  " + chalk57.dim("Usage: /provider [anthropic|openai|list|reset|save|failover on|off]"));
+    console.log("  " + chalk58.red(`Unknown engine: ${sub}`));
+    console.log("  " + chalk58.dim("Usage: /provider [<id>|list|reset|save|failover on|off]"));
+    console.log("  " + chalk58.dim("Connected: ") + (availableEngineLabels().join(", ") || chalk58.dim("none")));
+    console.log("  " + chalk58.dim("Add one with ") + paint("accent", "/connect"));
     console.log();
     return;
   }
-  const provider = sub;
+  const provider = spec.id;
   if (!hasProviderKey(provider)) {
-    const keyHint = provider === "anthropic" ? "api-key" : "openai-api-key";
     console.log();
-    console.log("  " + chalk57.red(`No ${provider} key configured.`));
-    console.log("  " + chalk57.dim(`Run `) + paint("accent", `/config set ${keyHint}`) + chalk57.dim(" to add one."));
+    console.log("  " + chalk58.red(`${spec.label} isn't connected.`));
+    console.log(
+      "  " + chalk58.dim("Run ") + paint("accent", `/connect ${provider}`) + chalk58.dim(" (or ") + paint("accent", `/config set ${spec.key_config_name}`) + chalk58.dim(").")
+    );
     console.log();
     return;
   }
   ensureLlmSession(ctx).provider = provider;
   if (!ctx.oneShot) saveSessionState(ctx);
   console.log();
-  console.log("  " + paint("success", "\u2713") + ` Active engine: ${chalk57.bold(provider)}`);
-  console.log("  " + chalk57.dim(`Stack: ${formatActiveStack(ctx)}`));
+  console.log("  " + paint("success", "\u2713") + ` Active engine: ${chalk58.bold(provider)}`);
+  console.log("  " + chalk58.dim(`Stack: ${formatActiveStack(ctx)}`));
   const others = availableEngineLabels().filter((p) => p !== provider);
   if (others.length > 0) {
-    console.log("  " + chalk57.dim(`Also available: ${others.join(", ")}`));
+    console.log("  " + chalk58.dim(`Also available: ${others.join(", ")}`));
   }
   console.log();
 }
@@ -22651,49 +23859,54 @@ function printStatus(ctx) {
   const autoFailover = resolveAutoFailoverEnabled(ctx);
   const engines = countAvailableEngines();
   console.log();
-  console.log(chalk57.bold("  LLM engines"));
-  console.log(`  Available: ${engines} engine${engines === 1 ? "" : "s"}`);
-  for (const p of PROVIDERS) {
-    const key = hasProviderKey(p) ? paint("success", "\u2713") : chalk57.dim("\xB7");
-    const marker2 = p === active ? paint("accent", " \u25BA active") : "";
-    console.log(`    ${key} ${p}${marker2}`);
+  console.log(chalk58.bold("  LLM engines"));
+  console.log(`  Connected: ${engines} engine${engines === 1 ? "" : "s"}`);
+  const configured = listProviderSpecs().filter((s) => hasProviderKey(s.id));
+  for (const s of configured) {
+    const marker2 = s.id === active ? paint("accent", " \u25BA active") : "";
+    console.log(`    ${paint("success", "\u2713")} ${s.id}${s.custom ? chalk58.dim(" (custom)") : ""}${marker2}`);
+  }
+  if (configured.length === 0) {
+    console.log("    " + chalk58.dim("none \u2014 run /connect and paste any provider key"));
   }
   console.log();
-  console.log(chalk57.bold("  Active stack"));
+  console.log(chalk58.bold("  Active stack"));
   console.log(`  ${formatActiveStack(ctx)}`);
   if (sessionOverride) {
-    console.log(chalk57.dim("  (session override \u2014 /provider reset to use default)"));
+    console.log(chalk58.dim("  (session override \u2014 /provider reset to use default)"));
   } else {
-    console.log(chalk57.dim(`  (config default: ${cfg.primary})`));
+    console.log(chalk58.dim(`  (config default: ${cfg.primary})`));
   }
   console.log();
-  console.log(`  Auto-failover: ${autoFailover ? paint("success", "on") : chalk57.dim("off")}`);
-  console.log(chalk57.dim("  /provider anthropic|openai \u2014 switch engine"));
-  console.log(chalk57.dim("  /provider failover on|off \u2014 rate-limit safety net"));
-  console.log(chalk57.dim("  /provider save \u2014 persist active engine to config"));
+  console.log(`  Auto-failover: ${autoFailover ? paint("success", "on") : chalk58.dim("off")}`);
+  console.log(chalk58.dim(`  /provider <id> \u2014 switch engine (${configured.map((s) => s.id).join(", ") || "none connected"})`));
+  console.log(chalk58.dim("  /provider failover on|off \u2014 rate-limit safety net"));
+  console.log(chalk58.dim("  /provider save \u2014 persist active engine to config"));
+  console.log(chalk58.dim("  /connect \u2014 add another provider (any API key)"));
   console.log();
 }
-var PROVIDERS;
+var RESERVED;
 var init_provider = __esm({
   "src/commands/provider.ts"() {
     "use strict";
     init_argparse();
     init_session_state();
+    init_providers();
     init_llm_config();
     init_store();
     init_context2();
     init_theme();
-    PROVIDERS = ["anthropic", "openai"];
+    RESERVED = /* @__PURE__ */ new Set(["list", "reset", "save", "failover"]);
   }
 });
 
 // src/commands/tier.ts
 var tier_exports = {};
 __export(tier_exports, {
-  handler: () => handler41
+  handler: () => handler42
 });
-import chalk58 from "chalk";
-async function handler41(args, ctx) {
+import chalk59 from "chalk";
+async function handler42(args, ctx) {
   const { positional, flags } = parseArgs(args, ["default"]);
   const sub = positional[0]?.toLowerCase();
   if (!sub || sub === "list") {
@@ -22702,8 +23915,8 @@ async function handler41(args, ctx) {
   }
   if (!TIERS.includes(sub)) {
     console.log();
-    console.log("  " + chalk58.red(`Unknown tier: ${sub}`));
-    console.log("  " + chalk58.dim("Usage: /tier [high|medium|low|list] [--default]"));
+    console.log("  " + chalk59.red(`Unknown tier: ${sub}`));
+    console.log("  " + chalk59.dim("Usage: /tier [high|medium|low|list] [--default]"));
     console.log();
     return;
   }
@@ -22717,40 +23930,48 @@ async function handler41(args, ctx) {
   }
   console.log();
   console.log(
-    "  " + paint("success", "\u2713") + ` Inference tier set to ${chalk58.bold(tier.toUpperCase())}` + (persist ? chalk58.dim(" (saved as default)") : chalk58.dim(" (this session)"))
+    "  " + paint("success", "\u2713") + ` Inference tier set to ${chalk59.bold(tier.toUpperCase())}` + (persist ? chalk59.dim(" (saved as default)") : chalk59.dim(" (this session)"))
   );
-  console.log("  " + chalk58.dim(`Stack: ${formatActiveStack(ctx)}`));
+  console.log("  " + chalk59.dim(`Stack: ${formatActiveStack(ctx)}`));
   console.log();
 }
 function printCatalog(ctx) {
   const cfg = loadLlmConfig();
   const active = resolveModelForActive(ctx, "agentic_investigation");
   const sessionTier = ctx.llm?.tier;
+  const providers = getAvailableProviders();
   console.log();
-  console.log(chalk58.bold("  Inference settings"));
+  console.log(chalk59.bold("  Inference settings"));
   console.log(`  Active: ${paint("accent", formatActiveStack(ctx))}`);
   if (sessionTier) {
-    console.log(chalk58.dim("  (session tier override)"));
+    console.log(chalk59.dim("  (session tier override)"));
   } else {
-    console.log(chalk58.dim(`  Config default tier: ${cfg.tier.toUpperCase()}`));
+    console.log(chalk59.dim(`  Config default tier: ${cfg.tier.toUpperCase()}`));
   }
   console.log();
+  if (providers.length === 0) {
+    console.log("  " + chalk59.dim("No engines connected \u2014 run /connect and paste any provider key."));
+    console.log();
+  }
   for (const tier of TIERS) {
-    console.log(chalk58.bold(`  ${tier.toUpperCase()}`));
-    for (const provider of ["anthropic", "openai"]) {
-      const models = listCatalogEntries(provider).filter((m) => m.tier === tier);
-      for (const m of models) {
-        const isActive = provider === active.provider && tier === active.tier && m.id === active.modelId;
-        const marker2 = isActive ? paint("accent", "\u25BA ") : "  ";
-        const status = m.status === "active" ? "" : chalk58.yellow(` [${m.status}]`);
-        console.log(`${marker2}${provider}/${m.id}${status} \u2014 ${m.display_name}`);
+    console.log(chalk59.bold(`  ${tier.toUpperCase()}`));
+    for (const provider of providers) {
+      const modelId = resolveModelSafe(provider, tier);
+      if (!modelId) {
+        console.log(`  ${provider}/${chalk59.dim("no models \u2014 /model refresh")}`);
+        continue;
       }
+      const isActive = provider === active.provider && tier === active.tier && modelId === active.modelId;
+      const marker2 = isActive ? paint("accent", "\u25BA ") : "  ";
+      const discovered = !!getProviderModels(provider);
+      const source = discovered ? "" : chalk59.dim(" [bundled fallback]");
+      console.log(`${marker2}${provider}/${modelId}${source}`);
     }
     console.log();
   }
-  console.log(chalk58.dim("  /tier high|medium|low \u2014 set tier for this session"));
-  console.log(chalk58.dim("  /tier high --default \u2014 also save as config default"));
-  console.log(chalk58.dim("  /provider anthropic|openai \u2014 switch engine"));
+  console.log(chalk59.dim("  /tier high|medium|low \u2014 set tier for this session"));
+  console.log(chalk59.dim("  /tier high --default \u2014 also save as config default"));
+  console.log(chalk59.dim("  /provider <id> \u2014 switch engine \xB7 /model list \u2014 browse models"));
   console.log();
 }
 var TIERS;
@@ -22759,6 +23980,7 @@ var init_tier = __esm({
     "use strict";
     init_argparse();
     init_catalog();
+    init_models_cache();
     init_session_state();
     init_llm_config();
     init_store();
@@ -22771,12 +23993,21 @@ var init_tier = __esm({
 // src/commands/model.ts
 var model_exports = {};
 __export(model_exports, {
-  handler: () => handler42
+  handler: () => handler43
 });
-import chalk59 from "chalk";
-async function handler42(args, ctx) {
-  const { positional, flags } = parseArgs(args, ["default"]);
+import chalk60 from "chalk";
+import ora18 from "ora";
+async function handler43(args, ctx) {
+  const { positional, flags } = parseArgs(args, ["default", "all"]);
   const sub = positional[0]?.toLowerCase();
+  if (sub === "list") {
+    printModelList(ctx, getBool(flags, "all"));
+    return;
+  }
+  if (sub === "refresh") {
+    await refreshModels(ctx);
+    return;
+  }
   if (sub === "clear") {
     const persist = getBool(flags, "default");
     if (ctx.llm) ctx.llm.modelOverride = void 0;
@@ -22784,7 +24015,7 @@ async function handler42(args, ctx) {
     if (!ctx.oneShot) saveSessionState(ctx);
     console.log();
     console.log("  " + paint("success", "\u2713") + " Model override cleared \u2014 using tier defaults.");
-    console.log("  " + chalk59.dim(`Stack: ${formatActiveStack(ctx)}`));
+    console.log("  " + chalk60.dim(`Stack: ${formatActiveStack(ctx)}`));
     console.log();
     return;
   }
@@ -22792,22 +24023,28 @@ async function handler42(args, ctx) {
     const modelId = positional[1];
     if (!modelId) {
       console.log();
-      console.log("  " + chalk59.red("Usage: /model set <model-id> [--default]"));
+      console.log("  " + chalk60.red("Usage: /model set <model-id> [--default]"));
       console.log();
       return;
     }
     const active = resolveActiveProvider(ctx);
     const providerErr = validateModelForProvider(modelId, active);
-    const entry = getCatalogEntry(modelId);
     if (providerErr) {
       console.log();
-      console.log("  " + chalk59.red(providerErr));
+      console.log("  " + chalk60.red(providerErr));
       console.log();
       return;
     }
-    if (!entry) {
+    const cache2 = getProviderModels(active);
+    const known = cache2?.models.some((m) => m.id === modelId);
+    if (cache2 && !known) {
+      console.log();
+      console.log(
+        "  " + chalk60.yellow("\u26A0") + ` ${modelId} isn't in ${active}'s discovered list (` + paint("accent", "/model list") + `) \u2014 saving anyway.`
+      );
+    } else if (!cache2) {
       console.log();
-      console.log("  " + chalk59.yellow("\u26A0") + ` Unknown model ${modelId} \u2014 saving for active engine anyway.`);
+      console.log("  " + chalk60.yellow("\u26A0") + ` No discovered models for ${active} yet (` + paint("accent", "/model refresh") + `) \u2014 saving anyway.`);
     }
     const persist = getBool(flags, "default");
     if (persist) {
@@ -22818,48 +24055,98 @@ async function handler42(args, ctx) {
     }
     console.log();
     console.log(
-      "  " + paint("success", "\u2713") + ` Model: ${chalk59.bold(modelId)}` + (persist ? chalk59.dim(" (saved as default)") : chalk59.dim(" (this session)"))
+      "  " + paint("success", "\u2713") + ` Model: ${chalk60.bold(modelId)}` + (persist ? chalk60.dim(" (saved as default)") : chalk60.dim(" (this session)"))
     );
-    console.log("  " + chalk59.dim(`Stack: ${formatActiveStack(ctx)}`));
+    console.log("  " + chalk60.dim(`Stack: ${formatActiveStack(ctx)}`));
     console.log();
     return;
   }
   const sessionOverride = ctx.llm?.modelOverride;
   const globalOverride = getConfigValue("llm-model-override");
   console.log();
-  console.log(chalk59.bold("  Model"));
+  console.log(chalk60.bold("  Model"));
   if (sessionOverride) {
     console.log(`  Session override: ${paint("accent", sessionOverride)}`);
   } else if (globalOverride) {
     console.log(`  Config default: ${paint("accent", globalOverride)}`);
   } else {
-    console.log("  " + chalk59.dim("No override \u2014 tier defaults apply."));
+    console.log("  " + chalk60.dim("No override \u2014 tier defaults apply."));
   }
   console.log(`  Active stack: ${formatActiveStack(ctx)}`);
-  console.log(chalk59.dim("  /model set <id> \xB7 /model clear \xB7 /tier list \xB7 /provider list"));
+  console.log(chalk60.dim("  /model list \xB7 /model set <id> \xB7 /model refresh \xB7 /model clear"));
   console.log();
 }
+function tierMarkers(cache2, modelId) {
+  const tiers = Object.entries(cache2.tier_stack).filter(([, id]) => id === modelId).map(([tier]) => tier.toUpperCase());
+  return tiers.length > 0 ? paint("accent", ` \u25C2 ${tiers.join("/")}`) : "";
+}
+function printModelList(ctx, showAll) {
+  const active = resolveActiveProvider(ctx);
+  const cache2 = getProviderModels(active);
+  console.log();
+  console.log(chalk60.bold(`  Models \u2014 ${active}`));
+  if (!cache2) {
+    console.log("  " + chalk60.dim("Nothing discovered yet."));
+    console.log("  " + chalk60.dim("Run ") + paint("accent", "/model refresh") + chalk60.dim(" (or ") + paint("accent", "/connect") + chalk60.dim(" to add the provider)."));
+    console.log();
+    return;
+  }
+  const fetchedAt = cache2.fetched_at.slice(0, 10);
+  console.log("  " + chalk60.dim(`${cache2.models.length} chat models \xB7 discovered ${fetchedAt} \xB7 /model refresh to update`));
+  console.log();
+  const models = showAll ? cache2.models : cache2.models.slice(0, LIST_LIMIT);
+  const noTools = new Set(cache2.quirks?.no_tools ?? []);
+  for (const m of models) {
+    const name = m.display_name && m.display_name !== m.id ? chalk60.dim(` \u2014 ${m.display_name}`) : "";
+    const quirk = noTools.has(m.id) ? chalk60.yellow(" [no tools]") : "";
+    console.log(`    ${m.id}${name}${tierMarkers(cache2, m.id)}${quirk}`);
+  }
+  if (!showAll && cache2.models.length > models.length) {
+    console.log("    " + chalk60.dim(`\u2026 and ${cache2.models.length - models.length} more (/model list --all)`));
+  }
+  console.log();
+  console.log("  " + chalk60.dim("/model set <id> \u2014 pin one for this session (--default to persist)"));
+  console.log();
+}
+async function refreshModels(ctx) {
+  const active = resolveActiveProvider(ctx);
+  const spinner = ora18({ text: `Discovering ${active} models\u2026`, discardStdin: false }).start();
+  const entry = await refreshProviderModels(active, { force: true });
+  if (!entry) {
+    spinner.fail(`Couldn't reach ${active} to refresh models.`);
+    console.log("  " + chalk60.dim("Check your connection and key, then retry. Cached models remain in use."));
+    console.log();
+    return;
+  }
+  spinner.succeed(`${active}: ${entry.models.length} chat models discovered.`);
+  console.log("  " + chalk60.dim(`high ${entry.tier_stack.high} \xB7 medium ${entry.tier_stack.medium} \xB7 low ${entry.tier_stack.low}`));
+  console.log("  " + chalk60.dim(`Stack: ${formatActiveStack(ctx)}`));
+  console.log();
+}
+var LIST_LIMIT;
 var init_model = __esm({
   "src/commands/model.ts"() {
     "use strict";
     init_argparse();
-    init_catalog();
+    init_discovery();
+    init_models_cache();
     init_session_state();
     init_store();
     init_context2();
     init_theme();
+    LIST_LIMIT = 40;
   }
 });
 
 // src/config/update-check.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync12, readFileSync as readFileSync14, unlinkSync as unlinkSync5, writeFileSync as writeFileSync17 } from "fs";
-import { join as join26 } from "path";
-function cachePath() {
-  return join26(ntrpHome(), "update-check.json");
+import { existsSync as existsSync21, mkdirSync as mkdirSync12, readFileSync as readFileSync17, unlinkSync as unlinkSync5, writeFileSync as writeFileSync19 } from "fs";
+import { join as join28 } from "path";
+function cachePath2() {
+  return join28(ntrpHome(), "update-check.json");
 }
 function invalidateUpdateCheckCache() {
-  const path = cachePath();
-  if (existsSync19(path)) {
+  const path = cachePath2();
+  if (existsSync21(path)) {
     unlinkSync5(path);
   }
 }
@@ -22871,17 +24158,17 @@ var init_update_check = __esm({
 });
 
 // src/version.ts
-import { existsSync as existsSync20, readFileSync as readFileSync15 } from "fs";
-import { dirname as dirname4, join as join27 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync18 } from "fs";
+import { dirname as dirname4, join as join29 } from "path";
 import { fileURLToPath } from "url";
 function getInstalledVersion() {
   if (cachedVersion) return cachedVersion;
   const start = dirname4(fileURLToPath(import.meta.url));
   for (const rel of ["../package.json", "../../package.json"]) {
-    const path = join27(start, rel);
-    if (!existsSync20(path)) continue;
+    const path = join29(start, rel);
+    if (!existsSync22(path)) continue;
     try {
-      const pkg = JSON.parse(readFileSync15(path, "utf-8"));
+      const pkg = JSON.parse(readFileSync18(path, "utf-8"));
       if (typeof pkg.version === "string" && pkg.version.length > 0) {
         cachedVersion = pkg.version;
         return cachedVersion;
@@ -22939,10 +24226,10 @@ var init_registry = __esm({
 // src/commands/update.ts
 var update_exports = {};
 __export(update_exports, {
-  handler: () => handler43
+  handler: () => handler44
 });
 import { spawnSync } from "child_process";
-import chalk60 from "chalk";
+import chalk61 from "chalk";
 function tailLines(text, count = 5) {
   return text.split("\n").map((line) => line.trimEnd()).filter((line) => line.length > 0).slice(-count).join("\n");
 }
@@ -22958,19 +24245,19 @@ function runGlobalInstall() {
   const output = [result.stdout, result.stderr].filter(Boolean).join("\n");
   return { ok: result.status === 0, output };
 }
-async function handler43(_args, _ctx) {
+async function handler44(_args, _ctx) {
   const current = getInstalledVersion();
   const latest = await fetchLatestVersion(1e4);
   if (!latest) {
     console.log();
-    console.log(chalk60.yellow("  Could not reach the npm registry."));
-    console.log(chalk60.dim(`  Try manually: npm install -g ${NPM_PACKAGE}`));
+    console.log(chalk61.yellow("  Could not reach the npm registry."));
+    console.log(chalk61.dim(`  Try manually: npm install -g ${NPM_PACKAGE}`));
     console.log();
     return;
   }
   if (!isNewerVersion(latest, current)) {
     console.log();
-    console.log(chalk60.green(`  \u2713 You're on the latest version (v${current})`));
+    console.log(chalk61.green(`  \u2713 You're on the latest version (v${current})`));
     console.log();
     return;
   }
@@ -22979,24 +24266,24 @@ async function handler43(_args, _ctx) {
   const { ok, output } = runGlobalInstall();
   if (ok) {
     invalidateUpdateCheckCache();
-    console.log(chalk60.green(`  \u2713 Updated! Restart NTRP to use v${latest}`));
+    console.log(chalk61.green(`  \u2713 Updated! Restart NTRP to use v${latest}`));
     console.log();
     return;
   }
   const lower = output.toLowerCase();
   if (lower.includes("eacces") || lower.includes("permission denied") || lower.includes("eperm")) {
-    console.log(chalk60.red(`  Could not install ${NPM_PACKAGE} (permission denied).`));
-    console.log(chalk60.dim(`  Try: sudo npm install -g ${NPM_PACKAGE}`));
-    console.log(chalk60.dim(`  Or fix npm global permissions: ${PERMISSIONS_URL}`));
+    console.log(chalk61.red(`  Could not install ${NPM_PACKAGE} (permission denied).`));
+    console.log(chalk61.dim(`  Try: sudo npm install -g ${NPM_PACKAGE}`));
+    console.log(chalk61.dim(`  Or fix npm global permissions: ${PERMISSIONS_URL}`));
     console.log();
     return;
   }
   const detail = tailLines(output);
-  console.log(chalk60.red(`  Could not install ${NPM_PACKAGE}.`));
+  console.log(chalk61.red(`  Could not install ${NPM_PACKAGE}.`));
   if (detail) {
-    console.log(chalk60.dim(`  ${detail.split("\n").join("\n  ")}`));
+    console.log(chalk61.dim(`  ${detail.split("\n").join("\n  ")}`));
   }
-  console.log(chalk60.dim(`  Try manually: npm install -g ${NPM_PACKAGE}`));
+  console.log(chalk61.dim(`  Try manually: npm install -g ${NPM_PACKAGE}`));
   console.log();
 }
 var PERMISSIONS_URL;
@@ -23011,10 +24298,10 @@ var init_update = __esm({
 });
 
 // src/output/progress-report.ts
-import chalk61 from "chalk";
+import chalk62 from "chalk";
 function printCard(title, rows) {
   const inner = CARD_W - 4;
-  const border = chalk61.dim;
+  const border = chalk62.dim;
   console.log();
   console.log(`  ${border(`\u256D${"\u2500".repeat(CARD_W - 2)}\u256E`)}`);
   console.log(`  ${border("\u2502 ")}${padRight(sectionHeading(title), inner)}${border(" \u2502")}`);
@@ -23030,7 +24317,7 @@ function formatTokens(n) {
   return String(n);
 }
 function sparkline(values) {
-  if (values.length === 0) return chalk61.dim("(no activity yet)");
+  if (values.length === 0) return chalk62.dim("(no activity yet)");
   const max = Math.max(...values, 1);
   const blocks = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
   return values.map((v) => {
@@ -23039,7 +24326,7 @@ function sparkline(values) {
   }).join("");
 }
 function formatMemberSince(iso) {
-  if (!iso) return chalk61.dim("\u2014");
+  if (!iso) return chalk62.dim("\u2014");
   const d = new Date(iso);
   return d.toLocaleDateString(void 0, { month: "short", day: "numeric", year: "numeric" });
 }
@@ -23056,49 +24343,49 @@ function renderProgressReport() {
     state.milestones_unlocked.length,
     TIME_MILESTONES.length
   );
-  const { usage: usage2 } = summary;
+  const { usage: usage3 } = summary;
   const nextLabel = bank.next_milestone ? `${formatHoursLabel(bank.total_hours)} \u2192 ${formatHoursLabel(bank.next_milestone.hours)}` : `${formatHoursLabel(bank.total_hours)} saved`;
   const bar = inlineBar(bank.progress_pct, 18);
   printCard("Progress", [
-    `${chalk61.dim("Hours saved")}     ${paint("accent", formatHoursLabel(bank.total_hours))}  ${bar}`,
-    `${chalk61.dim("Next milestone")}  ${bank.next_milestone ? paint("accent", bank.next_milestone.title) : chalk61.dim("top of ladder")}`,
-    `${chalk61.dim("Member since")}    ${formatMemberSince(usage2.first_active_at)}`,
-    `${chalk61.dim("Last active")}     ${formatMemberSince(usage2.last_active_at)}`
+    `${chalk62.dim("Hours saved")}     ${paint("accent", formatHoursLabel(bank.total_hours))}  ${bar}`,
+    `${chalk62.dim("Next milestone")}  ${bank.next_milestone ? paint("accent", bank.next_milestone.title) : chalk62.dim("top of ladder")}`,
+    `${chalk62.dim("Member since")}    ${formatMemberSince(usage3.first_active_at)}`,
+    `${chalk62.dim("Last active")}     ${formatMemberSince(usage3.last_active_at)}`
   ]);
   if (bank.perspective_line) {
-    console.log(`  ${chalk61.dim.italic(bank.perspective_line)}`);
+    console.log(`  ${chalk62.dim.italic(bank.perspective_line)}`);
   }
   printCard("Activity", [
-    `${chalk61.dim("Sessions")}        ${chalk61.bold(String(summary.total_sessions_on_disk))} total \xB7 ${summary.sessions_with_work} with work \xB7 ${usage2.sessions_closed} closed`,
-    `${chalk61.dim("Diagnoses")}       ${chalk61.bold(String(usage2.diagnoses))}`,
-    `${chalk61.dim("Metrics runs")}    ${chalk61.bold(String(usage2.metrics_runs))}`,
-    `${chalk61.dim("Deliverables")}    ${chalk61.bold(String(usage2.deliverables))}`,
-    `${chalk61.dim("AI exchanges")}    ${chalk61.bold(String(usage2.nl_exchanges))}`
+    `${chalk62.dim("Sessions")}        ${chalk62.bold(String(summary.total_sessions_on_disk))} total \xB7 ${summary.sessions_with_work} with work \xB7 ${usage3.sessions_closed} closed`,
+    `${chalk62.dim("Diagnoses")}       ${chalk62.bold(String(usage3.diagnoses))}`,
+    `${chalk62.dim("Metrics runs")}    ${chalk62.bold(String(usage3.metrics_runs))}`,
+    `${chalk62.dim("Deliverables")}    ${chalk62.bold(String(usage3.deliverables))}`,
+    `${chalk62.dim("AI exchanges")}    ${chalk62.bold(String(usage3.nl_exchanges))}`
   ]);
-  const totalTokens = usage2.input_tokens + usage2.output_tokens;
+  const totalTokens = usage3.input_tokens + usage3.output_tokens;
   printCard("AI usage", [
-    `${chalk61.dim("LLM calls")}       ${chalk61.bold(String(usage2.llm_calls))}`,
-    `${chalk61.dim("Tokens")}          ${chalk61.bold(formatTokens(totalTokens))} in+out (${formatTokens(usage2.input_tokens)} in \xB7 ${formatTokens(usage2.output_tokens)} out)`
+    `${chalk62.dim("LLM calls")}       ${chalk62.bold(String(usage3.llm_calls))}`,
+    `${chalk62.dim("Tokens")}          ${chalk62.bold(formatTokens(totalTokens))} in+out (${formatTokens(usage3.input_tokens)} in \xB7 ${formatTokens(usage3.output_tokens)} out)`
   ]);
-  const weeks = [...usage2.weekly].sort((a, b) => a.week.localeCompare(b.week)).slice(-8);
+  const weeks = [...usage3.weekly].sort((a, b) => a.week.localeCompare(b.week)).slice(-8);
   const weekHours = weeks.map((w) => w.minutes_saved / 60);
   const weekLabels = weeks.map((w) => w.week.replace(/^\d{4}-/, ""));
   console.log();
   console.log(`  ${sectionHeading("Weekly hours saved")}`);
   console.log(`  ${sparkline(weekHours)}`);
   if (weeks.length > 0) {
-    console.log(`  ${chalk61.dim(weekLabels.join("  "))}`);
+    console.log(`  ${chalk62.dim(weekLabels.join("  "))}`);
   }
   console.log();
   console.log(`  ${sectionHeading("Milestone ladder")}`);
   for (const m of TIME_MILESTONES) {
     const unlocked = state.milestones_unlocked.includes(m.id);
     const pct = Math.min(100, bank.total_hours / m.hours * 100);
-    const mark = unlocked ? badge("DONE", "success") : bank.total_hours >= m.hours * 0.85 ? badge("NEAR", "warning") : chalk61.dim("\u25CB");
+    const mark = unlocked ? badge("DONE", "success") : bank.total_hours >= m.hours * 0.85 ? badge("NEAR", "warning") : chalk62.dim("\u25CB");
     const barW = 12;
-    const mBar = unlocked ? chalk61.hex("#22c55e")("\u2588".repeat(barW)) : scoreBar(pct, bank.total_hours >= m.hours ? "green" : pct >= 50 ? "yellow" : "red", barW);
+    const mBar = unlocked ? chalk62.hex("#22c55e")("\u2588".repeat(barW)) : scoreBar(pct, bank.total_hours >= m.hours ? "green" : pct >= 50 ? "yellow" : "red", barW);
     const label = `${m.title}`.padEnd(16);
-    console.log(`  ${mark} ${chalk61.dim(label)} ${mBar}  ${chalk61.dim(`${m.hours}h`)}`);
+    console.log(`  ${mark} ${chalk62.dim(label)} ${mBar}  ${chalk62.dim(`${m.hours}h`)}`);
   }
   console.log();
 }
@@ -23120,17 +24407,17 @@ var init_progress_report = __esm({
 // src/commands/progress.ts
 var progress_exports = {};
 __export(progress_exports, {
-  handler: () => handler44
+  handler: () => handler45
 });
-import chalk62 from "chalk";
+import chalk63 from "chalk";
 function printProgressResetPreamble() {
   console.log();
-  console.log("  " + chalk62.yellow.bold("This will permanently remove:"));
-  console.log("  " + chalk62.dim("  \u2022 Hours saved and milestone unlocks"));
-  console.log("  " + chalk62.dim("  \u2022 Usage counters and weekly activity rollups"));
-  console.log("  " + chalk62.dim("  \u2022 Credit history used for dedup"));
+  console.log("  " + chalk63.yellow.bold("This will permanently remove:"));
+  console.log("  " + chalk63.dim("  \u2022 Hours saved and milestone unlocks"));
+  console.log("  " + chalk63.dim("  \u2022 Usage counters and weekly activity rollups"));
+  console.log("  " + chalk63.dim("  \u2022 Credit history used for dedup"));
   console.log();
-  console.log("  " + chalk62.dim("Preserved: install identity (install.json)"));
+  console.log("  " + chalk63.dim("Preserved: install identity (install.json)"));
   console.log();
 }
 function showProgress() {
@@ -23148,7 +24435,7 @@ async function handleReset(ctx, confirmedFlag) {
   const bank = getTimeBankSummary();
   if (bank.total_minutes <= 0) {
     console.log();
-    console.log("  " + chalk62.dim("No progress to reset."));
+    console.log("  " + chalk63.dim("No progress to reset."));
     console.log();
     return "No progress to reset";
   }
@@ -23165,11 +24452,11 @@ async function handleReset(ctx, confirmedFlag) {
   }
   resetProgress();
   console.log();
-  console.log("  " + paint("accent", "\u2713 Progress reset") + chalk62.dim(" \u2014 hours and milestones cleared."));
+  console.log("  " + paint("accent", "\u2713 Progress reset") + chalk63.dim(" \u2014 hours and milestones cleared."));
   console.log();
   return "Progress reset";
 }
-async function handler44(args, ctx) {
+async function handler45(args, ctx) {
   const { positional, flags } = parseArgs(args, ["confirm"]);
   const sub = positional[0]?.toLowerCase();
   if (sub === "reset") {
@@ -23177,7 +24464,7 @@ async function handler44(args, ctx) {
   }
   if (sub && sub !== "reset") {
     console.log();
-    console.log("  " + chalk62.dim("Unknown subcommand. Try ") + paint("accent", "/progress") + chalk62.dim(" or ") + paint("accent", "/progress reset") + chalk62.dim("."));
+    console.log("  " + chalk63.dim("Unknown subcommand. Try ") + paint("accent", "/progress") + chalk63.dim(" or ") + paint("accent", "/progress reset") + chalk63.dim("."));
     console.log();
     return;
   }
@@ -23204,8 +24491,8 @@ init_time_milestones();
 init_time_perspectives();
 init_time_bank();
 init_perspective_rotation();
-import { existsSync as existsSync21, mkdirSync as mkdirSync13, mkdtempSync, rmSync as rmSync4, writeFileSync as writeFileSync18 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync13, mkdtempSync, rmSync as rmSync4, writeFileSync as writeFileSync20 } from "fs";
+import { join as join30 } from "path";
 import { tmpdir } from "os";
 
 // src/workflows/registry.ts
@@ -23259,10 +24546,10 @@ async function resolveHandler(name) {
   try {
     const mod = await importHandler(runtimePath);
     if (!mod) return null;
-    const handler45 = mod.handler;
-    if (typeof handler45 !== "function") return null;
-    entry.handler = handler45;
-    return handler45;
+    const handler46 = mod.handler;
+    if (typeof handler46 !== "function") return null;
+    entry.handler = handler46;
+    return handler46;
   } catch (err) {
     console.error(`Failed to load handler for /${name}:`, err);
     return null;
@@ -23348,6 +24635,8 @@ async function importHandler(runtimePath) {
       return Promise.resolve().then(() => (init_switch(), switch_exports));
     case "../commands/backmeup.js":
       return Promise.resolve().then(() => (init_backmeup(), backmeup_exports));
+    case "../commands/connect.js":
+      return Promise.resolve().then(() => (init_connect2(), connect_exports2));
     case "../commands/provider.js":
       return Promise.resolve().then(() => (init_provider(), provider_exports));
     case "../commands/tier.js":
@@ -23470,7 +24759,9 @@ handler: ../commands/setup.ts
 
 Validate local readiness or configure NTRP non-interactively for automation.
 \`setup check --json\` reports license, profile, API key, database, and writable
-directory state. \`setup agent\` accepts a profile JSON file or direct flags.`
+directory state. \`setup agent\` accepts a profile JSON file or direct flags \u2014
+\`--llm-key <key>\` auto-detects the provider from any pasted key
+(\`--llm-provider <id>\` to force one).`
   },
   {
     name: "update",
@@ -23906,6 +25197,25 @@ handler: ../commands/profile.ts
 
 Choose a sales motion preset (PLG, SMB Velocity, Mid-Market, Enterprise). Each
 preset adjusts the vital-sign thresholds to match your deal cycle.`
+  },
+  {
+    name: "connect",
+    raw: `---
+name: connect
+description: Connect an AI provider (paste any key)
+section: Settings
+args: [provider] [--key <key>] [--base-url <url> --id <name>]
+handler: ../commands/connect.ts
+---
+
+Paste any provider's API key \u2014 NTRP identifies the provider from the key
+format (probing ambiguous ones), validates it, discovers which models the key
+can use, and builds the HIGH/MEDIUM/LOW tier stack automatically.
+
+Works with Anthropic, OpenAI, Google Gemini, Groq, Mistral, DeepSeek, xAI,
+OpenRouter, Together, and Fireworks out of the box. \`/connect ollama\` wires a
+local Ollama; \`/connect --base-url <url> --id <name>\` registers any other
+OpenAI-compatible endpoint.`
   },
   {
     name: "config",
@@ -23918,10 +25228,12 @@ handler: ../commands/config.ts
 ---
 
 Manage CLI configuration stored at \`~/.ntrp/config.json\`. Useful keys:
-\`api-key\` (Anthropic), \`openai-api-key\`, \`llm-primary\` (default engine),
-\`llm-tier\`, \`llm-auto-failover\`, \`default-format\`, \`export-dir\`.
+\`api-key\` (Anthropic), \`openai-api-key\` (and \`groq-api-key\`, \`google-api-key\`, ...),
+\`llm-primary\` (default engine), \`llm-tier\`, \`llm-auto-failover\`,
+\`default-format\`, \`export-dir\`.
 
-\`/config set api-key\` and \`/config set openai-api-key\` open hidden prompts.`
+Setting a provider key opens a hidden prompt and auto-discovers that
+provider's models. Prefer \`/connect\` \u2014 it detects the provider for you.`
   },
   {
     name: "provider",
@@ -23929,13 +25241,14 @@ Manage CLI configuration stored at \`~/.ntrp/config.json\`. Useful keys:
 name: provider
 description: Switch active LLM engine
 section: Settings
-args: [anthropic|openai|list|reset|save|failover on|off]
+args: [<id>|list|reset|save|failover on|off]
 handler: ../commands/provider.ts
 ---
 
-Choose which engine answers this session \u2014 Anthropic or OpenAI when both keys
-are configured. Session-scoped by default; \`/provider save\` writes the default
-to config. \`/provider failover on\` enables rate-limit auto-failover.`
+Choose which connected engine answers this session \u2014 any provider added via
+\`/connect\` (anthropic, openai, groq, google, ollama, custom endpoints, ...).
+Session-scoped by default; \`/provider save\` writes the default to config.
+\`/provider failover on\` enables rate-limit auto-failover.`
   },
   {
     name: "tier",
@@ -23957,12 +25270,14 @@ active stack. Add \`--default\` to persist to config.`
 name: model
 description: Override the active LLM model
 section: Settings
-args: [set <id>|clear] [--default]
+args: [list|set <id>|refresh|clear] [--default]
 handler: ../commands/model.ts
 ---
 
-Pin a catalog model on the **active engine** (e.g. claude-opus-4-6 on anthropic).
-Cross-provider IDs are rejected \u2014 switch with \`/provider\` first.`
+\`/model list\` shows the models discovered for the active engine with their
+tier assignments. \`/model refresh\` re-discovers the live list. \`/model set <id>\`
+pins a model on the **active engine**; cross-provider IDs are rejected \u2014
+switch with \`/provider\` first.`
   },
   {
     name: "activate",
@@ -24032,7 +25347,7 @@ function mockCtx(sessionId = "2026-06-21-test") {
   };
 }
 function withTempHome(run2) {
-  const dir = mkdtempSync(join28(tmpdir(), "ntrp-time-bank-"));
+  const dir = mkdtempSync(join30(tmpdir(), "ntrp-time-bank-"));
   const prev = process.env.NTRP_HOME;
   process.env.NTRP_HOME = dir;
   try {
@@ -24051,7 +25366,7 @@ function withTempHome(run2) {
   }
 }
 async function withTempHomeAsync(run2) {
-  const dir = mkdtempSync(join28(tmpdir(), "ntrp-time-bank-"));
+  const dir = mkdtempSync(join30(tmpdir(), "ntrp-time-bank-"));
   const prev = process.env.NTRP_HOME;
   process.env.NTRP_HOME = dir;
   try {
@@ -24172,7 +25487,7 @@ function testUsageBackfillFromCredits() {
   withTempHome(() => {
     const at = "2026-06-01T12:00:00.000Z";
     const installId = loadProgress().install_id;
-    writeFileSync18(join28(ntrpHome(), "progress.json"), JSON.stringify({
+    writeFileSync20(join30(ntrpHome(), "progress.json"), JSON.stringify({
       schema_version: 2,
       install_id: installId,
       total_minutes_saved: 30,
@@ -24187,14 +25502,14 @@ function testUsageBackfillFromCredits() {
 function testInstallCreatedOnFirstLoad() {
   withTempHome(() => {
     loadProgress();
-    assert(existsSync21(join28(ntrpHome(), "install.json")), "install.json created");
-    assert(existsSync21(join28(ntrpHome(), "progress.json")), "progress.json created");
+    assert(existsSync23(join30(ntrpHome(), "install.json")), "install.json created");
+    assert(existsSync23(join30(ntrpHome(), "progress.json")), "progress.json created");
   });
 }
 function testLegacyStateMigration() {
   withTempHome(() => {
     mkdirSync13(ntrpHome(), { recursive: true });
-    writeFileSync18(join28(ntrpHome(), "state.json"), JSON.stringify({
+    writeFileSync20(join30(ntrpHome(), "state.json"), JSON.stringify({
       schema_version: 1,
       total_minutes_saved: 45,
       credits: [{ action: "onboard", minutes: 45, at: "2026-06-01T12:00:00.000Z" }],
@@ -24202,8 +25517,8 @@ function testLegacyStateMigration() {
     }));
     const state = loadProgress();
     assert(state.total_minutes_saved === 45, "legacy migration preserves hours");
-    assert(existsSync21(join28(ntrpHome(), "progress.json")), "progress.json created from legacy");
-    assert(!existsSync21(join28(ntrpHome(), "state.json")), "legacy state.json moved aside");
+    assert(existsSync23(join30(ntrpHome(), "progress.json")), "progress.json created from legacy");
+    assert(!existsSync23(join30(ntrpHome(), "state.json")), "legacy state.json moved aside");
     assert(state.install_id === getInstallId(), "install_id attached on migration");
   });
 }
@@ -24214,7 +25529,7 @@ async function testProgressSurvivesScratchWipe() {
     assert(loadProgress().total_minutes_saved === 180, "pre-scratch credits");
     await performScratchWipe();
     assert(loadProgress().total_minutes_saved === 180, "post-scratch credits preserved");
-    assert(existsSync21(join28(ntrpHome(), "install.json")), "install survives scratch");
+    assert(existsSync23(join30(ntrpHome(), "install.json")), "install survives scratch");
   });
 }
 function testInstallIdStable() {
@@ -24234,7 +25549,7 @@ function testResetProgressKeepsInstall() {
     resetProgress();
     assert(loadProgress().total_minutes_saved === 0, "reset should clear hours");
     assert(getInstallId() === installId, "reset should keep install_id");
-    assert(existsSync21(join28(ntrpHome(), "install.json")), "install.json should remain");
+    assert(existsSync23(join30(ntrpHome(), "install.json")), "install.json should remain");
   });
 }
 async function testScratchIncludeProgressWipesHours() {
@@ -24243,7 +25558,7 @@ async function testScratchIncludeProgressWipesHours() {
     recordTimeCredit("diagnose", ctx, { silent: true });
     const installId = getInstallId();
     await performScratchWipe({ includeProgress: true });
-    assert(!existsSync21(join28(ntrpHome(), "install.json")), "include-progress should remove install.json");
+    assert(!existsSync23(join30(ntrpHome(), "install.json")), "include-progress should remove install.json");
     const state = loadProgress();
     assert(state.total_minutes_saved === 0, "include-progress should clear hours");
     assert(state.install_id !== installId, "include-progress should issue new install_id");
@@ -24267,8 +25582,8 @@ testInstallIdStable();
 testResetProgressKeepsInstall();
 async function testProgressCommandRegistered() {
   assert(hasCommand("progress"), "/progress should be in workflow registry");
-  const handler45 = await resolveHandler("progress");
-  assert(typeof handler45 === "function", "progress handler should load from importHandler map");
+  const handler46 = await resolveHandler("progress");
+  assert(typeof handler46 === "function", "progress handler should load from importHandler map");
 }
 await testProgressSurvivesScratchWipe();
 await testScratchIncludeProgressWipesHours();