@sonnechasser/ntrp 0.1.8 → 0.2.0

package/dist/index.js

@@ -1755,7 +1755,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,
@@ -1763,7 +1763,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"() {
@@ -2287,48 +2287,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);
@@ -3109,10 +3109,232 @@ var init_context2 = __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 existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "fs";
+import { join as join7 } from "path";
+function providersPath() {
+  return join7(ntrpHome(), "providers.json");
+}
+function loadCustomProviders() {
+  if (cachedEntries) return cachedEntries;
+  const path = providersPath();
+  if (!existsSync7(path)) {
+    cachedEntries = [];
+    return cachedEntries;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync6(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);
+  writeFileSync6(providersPath(), JSON.stringify({ version: 1, providers: entries }, null, 2) + "\n");
+  cachedEntries = entries;
+}
+function removeCustomProvider(id) {
+  const entries = loadCustomProviders().filter((e) => e.id !== id);
+  writeFileSync6(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;
@@ -3120,7 +3342,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;
@@ -3135,30 +3357,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;
     }
   }
@@ -3201,20 +3435,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;
   }
@@ -3644,8 +3878,8 @@ var init_admin_confirm = __esm({
 });
 
 // src/services/scratch-wipe.ts
-import { existsSync as existsSync7, rmSync as rmSync3, unlinkSync as unlinkSync3 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync8, rmSync as rmSync3, unlinkSync as unlinkSync3 } from "fs";
+import { join as join8 } from "path";
 async function performScratchWipe(opts = {}) {
   const home = ntrpHome();
   const removed = [];
@@ -3655,25 +3889,25 @@ async function performScratchWipe(opts = {}) {
   } catch {
   }
   const targets = [
-    { path: join7(home, "config.json"), kind: "file" },
-    { path: join7(home, "profile.json"), kind: "file" },
-    { path: join7(home, "demo-taxonomy.json"), kind: "file" },
-    { path: join7(home, "update-check.json"), kind: "file" },
-    { path: join7(home, "state.json.bak"), kind: "file" },
-    { path: join7(home, "ntrp.duckdb"), kind: "file" },
-    { path: join7(home, "ntrp.duckdb.wal"), kind: "file" },
-    { path: join7(home, "sessions"), kind: "dir" },
-    { path: join7(home, "datasets"), kind: "dir" }
+    { path: join8(home, "config.json"), kind: "file" },
+    { path: join8(home, "profile.json"), kind: "file" },
+    { path: join8(home, "demo-taxonomy.json"), kind: "file" },
+    { path: join8(home, "update-check.json"), kind: "file" },
+    { path: join8(home, "state.json.bak"), kind: "file" },
+    { path: join8(home, "ntrp.duckdb"), kind: "file" },
+    { path: join8(home, "ntrp.duckdb.wal"), kind: "file" },
+    { path: join8(home, "sessions"), kind: "dir" },
+    { path: join8(home, "datasets"), kind: "dir" }
   ];
   if (opts.includeProgress) {
     targets.push(
-      { path: join7(home, "install.json"), kind: "file" },
-      { path: join7(home, "progress.json"), kind: "file" },
-      { path: join7(home, "state.json"), kind: "file" }
+      { path: join8(home, "install.json"), kind: "file" },
+      { path: join8(home, "progress.json"), kind: "file" },
+      { path: join8(home, "state.json"), kind: "file" }
     );
   }
   for (const { path, kind } of targets) {
-    if (!existsSync7(path)) continue;
+    if (!existsSync8(path)) continue;
     try {
       if (kind === "dir") {
         rmSync3(path, { recursive: true, force: true });
@@ -3701,10 +3935,10 @@ var init_scratch_wipe = __esm({
 });
 
 // src/config/profile.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync8, mkdirSync as mkdirSync6 } from "fs";
-import { join as join8 } from "path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync7, existsSync as existsSync9, mkdirSync as mkdirSync6 } from "fs";
+import { join as join9 } from "path";
 function ensureDir5() {
-  if (!existsSync8(NTRP_DIR3)) {
+  if (!existsSync9(NTRP_DIR3)) {
     mkdirSync6(NTRP_DIR3, { recursive: true });
   }
 }
@@ -3712,16 +3946,16 @@ function profilePath() {
   return PROFILE_PATH;
 }
 function profileExists() {
-  return existsSync8(PROFILE_PATH);
+  return existsSync9(PROFILE_PATH);
 }
 function isProfileConfigured(profile = loadProfile()) {
   if (!profile) return false;
   return profile.company_name.trim().length > 0;
 }
 function loadProfile() {
-  if (!existsSync8(PROFILE_PATH)) return null;
+  if (!existsSync9(PROFILE_PATH)) return null;
   try {
-    const parsed = JSON.parse(readFileSync6(PROFILE_PATH, "utf-8"));
+    const parsed = JSON.parse(readFileSync7(PROFILE_PATH, "utf-8"));
     if (!parsed || typeof parsed !== "object") return null;
     return parsed;
   } catch {
@@ -3737,7 +3971,7 @@ function saveProfile(profile) {
     created_at: profile.created_at || now2,
     updated_at: now2
   };
-  writeFileSync6(PROFILE_PATH, JSON.stringify(toWrite, null, 2) + "\n");
+  writeFileSync7(PROFILE_PATH, JSON.stringify(toWrite, null, 2) + "\n");
 }
 function updateProfile(patch) {
   const existing = loadProfile();
@@ -3763,7 +3997,7 @@ var init_profile = __esm({
     "use strict";
     init_store();
     NTRP_DIR3 = ntrpHome();
-    PROFILE_PATH = join8(NTRP_DIR3, "profile.json");
+    PROFILE_PATH = join9(NTRP_DIR3, "profile.json");
   }
 });
 
@@ -4115,7 +4349,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;
@@ -4126,25 +4366,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);
@@ -4157,10 +4393,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, ...).";
   }
 });
 
@@ -4185,18 +4423,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 readFileSync8, writeFileSync as writeFileSync8, existsSync as existsSync10, mkdirSync as mkdirSync7, unlinkSync as unlinkSync4 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 function ensureDir6() {
-  if (!existsSync9(NTRP_DIR4)) {
+  if (!existsSync10(NTRP_DIR4)) {
     mkdirSync7(NTRP_DIR4, { recursive: true });
   }
 }
 function loadCachedTaxonomy(profile) {
-  if (!existsSync9(TAXONOMY_PATH)) return null;
+  if (!existsSync10(TAXONOMY_PATH)) return null;
   try {
-    const parsed = JSON.parse(readFileSync7(TAXONOMY_PATH, "utf-8"));
+    const parsed = JSON.parse(readFileSync8(TAXONOMY_PATH, "utf-8"));
     if (!parsed || typeof parsed !== "object") return null;
     if (parsed.profile_updated_at !== profile.updated_at) return null;
     return parsed;
@@ -4206,10 +4444,10 @@ function loadCachedTaxonomy(profile) {
 }
 function saveCachedTaxonomy(taxonomy) {
   ensureDir6();
-  writeFileSync7(TAXONOMY_PATH, JSON.stringify(taxonomy, null, 2) + "\n");
+  writeFileSync8(TAXONOMY_PATH, JSON.stringify(taxonomy, null, 2) + "\n");
 }
 function invalidateTaxonomy() {
-  if (existsSync9(TAXONOMY_PATH)) {
+  if (existsSync10(TAXONOMY_PATH)) {
     try {
       unlinkSync4(TAXONOMY_PATH);
     } catch {
@@ -4220,8 +4458,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 = join10(homedir3(), ".ntrp");
+    TAXONOMY_PATH = join10(NTRP_DIR4, "demo-taxonomy.json");
   }
 });
 
@@ -4246,6 +4484,12 @@ var init_types = __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;
@@ -4263,6 +4507,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);
   }
@@ -4271,6 +4518,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;
@@ -4285,7 +4537,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") {
@@ -4421,8 +4676,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",
@@ -4491,9 +4753,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,
@@ -4503,7 +4764,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) {
@@ -4514,15 +4775,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,
@@ -4535,68 +4792,118 @@ 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_errors();
   }
 });
 
-// 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 existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync9 } from "fs";
+import { join as join11 } from "path";
+function cachePath() {
+  return join11(ntrpHome(), "models.json");
+}
+function loadFile() {
+  if (cached) return cached;
+  const path = cachePath();
+  if (!existsSync11(path)) {
+    cached = { version: 1, providers: {} };
+    return cached;
   }
-  return id;
+  try {
+    const parsed = JSON.parse(readFileSync9(path, "utf-8"));
+    cached = { version: 1, providers: parsed.providers ?? {} };
+  } catch {
+    cached = { version: 1, providers: {} };
+  }
+  return cached;
+}
+function saveFile(file) {
+  writeFileSync9(cachePath(), JSON.stringify(file, null, 2) + "\n");
+  cached = file;
+}
+function getProviderModels(provider) {
+  return loadFile().providers[provider];
+}
+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 cheapestActiveInTier(provider, tier) {
+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}`;
 }
@@ -4604,6 +4911,7 @@ var ENTRIES, byId;
 var init_catalog = __esm({
   "src/ai/llm/catalog.ts"() {
     "use strict";
+    init_models_cache();
     ENTRIES = [
       {
         id: "claude-opus-4-6",
@@ -4676,6 +4984,306 @@ var init_catalog = __esm({
   }
 });
 
+// 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];
@@ -4747,7 +5355,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;
 }
@@ -4769,8 +5377,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) {
@@ -4781,30 +5389,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;
 }
@@ -4818,23 +5426,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,
@@ -4860,70 +5461,142 @@ var init_resolver = __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, {
@@ -4932,23 +5605,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;
         }
       }
@@ -4956,10 +5653,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",
@@ -4971,32 +5669,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_errors();
+    init_heal();
+    init_models_cache();
+    init_providers();
+    init_types();
     init_resolver();
+    NO_PROVIDER_MESSAGE = "No LLM provider configured. Run /connect and paste any API key (Anthropic, OpenAI, Groq, Gemini, ...).";
   }
 });
 
@@ -5657,6 +6389,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, {
@@ -5984,42 +6945,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("  " + chalk8.dim("Onboarding uses AI to draft your profile."));
   console.log(
-    "  " + chalk8.dim("Or run ") + paint("accent", "/config set api-key") + chalk8.dim(" / ") + paint("accent", "/config set openai-api-key") + chalk8.dim(" anytime.")
+    "  " + chalk8.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(
+    "  " + chalk8.dim("NTRP detects the provider and discovers its models. Or run ") + paint("accent", "/connect") + chalk8.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 = ora({ 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("    " + chalk8.dim(line));
+    } catch (err) {
+      spinner.stop();
+      if (!(err instanceof ConnectCancelled2)) {
+        console.log("  " + chalk8.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(
-      "  " + chalk8.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") + " " + chalk8.dim("LLM engines configured. Use /provider to switch."));
 }
@@ -6318,16 +7295,16 @@ async function runGlobalAdminCommand(command, line, ctx) {
   const args = tokens.slice(1);
   switch (command) {
     case "scratch": {
-      const { handler: handler45 } = await Promise.resolve().then(() => (init_scratch(), scratch_exports));
-      return handler45(args, ctx);
+      const { handler: handler46 } = await Promise.resolve().then(() => (init_scratch(), scratch_exports));
+      return handler46(args, ctx);
     }
     case "cleanup": {
-      const { handler: handler45 } = await Promise.resolve().then(() => (init_cleanup(), cleanup_exports));
-      return handler45(args, ctx);
+      const { handler: handler46 } = await Promise.resolve().then(() => (init_cleanup(), cleanup_exports));
+      return handler46(args, ctx);
     }
     case "deactivate-demo": {
-      const { handler: handler45 } = await Promise.resolve().then(() => (init_deactivate_demo(), deactivate_demo_exports));
-      return handler45(args, ctx);
+      const { handler: handler46 } = await Promise.resolve().then(() => (init_deactivate_demo(), deactivate_demo_exports));
+      return handler46(args, ctx);
     }
     default:
       return void 0;
@@ -9218,6 +10195,9 @@ function formatLlmAttribution(meta) {
   return line;
 }
 function printLlmAttribution(meta) {
+  for (const notice of meta.notices ?? []) {
+    console.log(chalk13.dim(`  ${notice}`));
+  }
   const line = formatLlmAttribution(meta);
   if (line) console.log(chalk13.dim(`  ${line}`));
 }
@@ -9535,6 +10515,7 @@ async function renderDiagnoseStream(options) {
     let modelUsed = "";
     let providerUsed;
     let failover;
+    let notices;
     let rawPrompt = "";
     try {
       for await (const event of runFindings(fullResult)) {
@@ -9550,6 +10531,7 @@ async function renderDiagnoseStream(options) {
           modelUsed = event.model_used;
           providerUsed = event.provider_used;
           failover = event.failover;
+          notices = event.usage?.notices;
           rawPrompt = event.raw_prompt;
         }
       }
@@ -9573,7 +10555,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");
@@ -9953,8 +10936,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 = ora3({ text: spinnerText, discardStdin: false }).start();
@@ -10112,7 +11095,7 @@ __export(ingest_exports, {
 });
 import chalk16 from "chalk";
 import ora4 from "ora";
-import { readFileSync as readFileSync8, existsSync as existsSync10 } from "fs";
+import { readFileSync as readFileSync11, existsSync as existsSync12 } from "fs";
 import { basename as basename3 } from "path";
 async function handler7(args, ctx) {
   const { positional, flags } = parseArgs2(args, [
@@ -10136,7 +11119,7 @@ async function handler7(args, ctx) {
     console.error(chalk16.dim("         /ingest --demo [--scenario <name>]"));
     process.exit(1);
   }
-  if (!existsSync10(file)) {
+  if (!existsSync12(file)) {
     console.error(chalk16.red(`  File not found: ${file}`));
     process.exit(1);
   }
@@ -10154,7 +11137,7 @@ async function handler7(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");
@@ -12317,16 +13300,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 {
@@ -12918,7 +13901,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");
@@ -13327,7 +14310,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
       };
     }
   }
@@ -13628,9 +14612,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;
@@ -13645,14 +14629,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;
@@ -13676,7 +14660,7 @@ var init_privacy = __esm({
       "raw_data",
       "metadata"
     ]);
-    AUDIT_DIR = join11(homedir4(), ".ntrp", "audit");
+    AUDIT_DIR = join13(homedir4(), ".ntrp", "audit");
   }
 });
 
@@ -14182,7 +15166,7 @@ __export(ingest_chat_exports, {
   loadDemoFromChat: () => loadDemoFromChat,
   looksLikeFilePath: () => looksLikeFilePath
 });
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { basename as basename4, resolve as resolve4 } from "path";
 import { homedir as homedir5 } from "os";
 import chalk22 from "chalk";
@@ -14202,11 +15186,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;
@@ -14236,12 +15220,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;
@@ -14989,12 +15973,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;
@@ -15387,7 +16371,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) {
@@ -15530,7 +16514,7 @@ async function handler8(args, ctx) {
     console.log();
     console.log("  " + chalk23.red("AI findings run only in the interactive REPL."));
     console.log("  " + chalk23.dim("Vital signs compute without a key \u2014 omit --findings for numbers only."));
-    console.log("  " + chalk23.dim("Start with ") + paint("accent", "ntrp") + chalk23.dim(", set ") + paint("accent", "/config set api-key") + chalk23.dim(" or openai-api-key, then /diagnose --findings."));
+    console.log("  " + chalk23.dim("Start with ") + paint("accent", "ntrp") + chalk23.dim(", run ") + paint("accent", "/connect") + chalk23.dim(" (any provider key), then /diagnose --findings."));
     console.log();
     return;
   }
@@ -15710,7 +16694,7 @@ __export(new_exports, {
   handler: () => handler9
 });
 import chalk24 from "chalk";
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { basename as basename5 } from "path";
 async function handler9(args, ctx) {
   const { positional, flags } = parseArgs2(args, ["demo", "empty", "list-scenarios", "regen-taxonomy"]);
@@ -15732,7 +16716,7 @@ async function handler9(args, ctx) {
     console.error(chalk24.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(chalk24.red(`  File not found: ${source.path}`));
     return;
   }
@@ -15799,11 +16783,11 @@ async function handler9(args, ctx) {
     return "New empty session";
   }
   if (lens === "revenue_metrics") {
-    const ora17 = (await import("ora")).default;
+    const ora20 = (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 : ora17({ text: "Computing SaaS metrics\u2026", indent: 2, discardStdin: false }).start();
+    const spinner = structured ? null : ora20({ text: "Computing SaaS metrics\u2026", indent: 2, discardStdin: false }).start();
     let result;
     try {
       result = await runMetricsAnalysis2({
@@ -16009,7 +16993,7 @@ __export(session_exports, {
   handler: () => handler11
 });
 import chalk26 from "chalk";
-import { join as join12 } from "path";
+import { join as join14 } from "path";
 import ora7 from "ora";
 async function handler11(args, ctx) {
   const sub = args[0];
@@ -16098,7 +17082,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] : [],
@@ -16410,7 +17394,7 @@ __export(report_exports, {
   handler: () => handler12
 });
 import chalk27 from "chalk";
-import { writeFileSync as writeFileSync8 } from "fs";
+import { writeFileSync as writeFileSync10 } from "fs";
 import { dirname as dirname2 } from "path";
 async function handler12(args, ctx) {
   const { flags } = parseArgs2(args);
@@ -16506,7 +17490,7 @@ async function handler12(args, ctx) {
       if (!isInsideNtrp(resolvedOutput)) {
         console.warn(chalk27.yellow(`  Warning: writing report outside ~/.ntrp (${dirname2(resolvedOutput)})`));
       }
-      writeFileSync8(resolvedOutput, rendered);
+      writeFileSync10(resolvedOutput, rendered);
       console.log(chalk27.green(`  Report written to ${resolvedOutput}`));
     } else if (rendered) {
       console.log(rendered);
@@ -16537,8 +17521,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;
@@ -16547,7 +17531,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];
@@ -16636,7 +17620,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) {
@@ -16776,8 +17760,8 @@ __export(backmeup_exports, {
 });
 import chalk29 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;
@@ -16813,7 +17797,7 @@ async function handler14(args, _ctx) {
     if (!isInsideNtrp(baseDir)) {
       console.warn(chalk29.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;
@@ -16828,7 +17812,7 @@ async function handler14(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) => ({
@@ -16838,7 +17822,7 @@ async function handler14(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) {
@@ -16848,7 +17832,7 @@ async function handler14(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(chalk29.green(`
@@ -17042,8 +18026,8 @@ var init_bundle = __esm({
 });
 
 // src/repositories/markdown.ts
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync11 } from "fs";
-import { basename as basename6, dirname as dirname3, join as join15, resolve as resolve6 } from "path";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync13 } from "fs";
+import { basename as basename6, 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";
@@ -17266,9 +18250,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 {
@@ -17572,8 +18556,8 @@ __export(handoff_exports, {
   handler: () => handler16
 });
 import chalk31 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 handler16(args, ctx) {
   const sub = args[0];
   if (!sub) {
@@ -17631,7 +18615,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 });
@@ -17679,8 +18663,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})`));
@@ -18552,24 +19536,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);
@@ -18584,7 +19568,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();
@@ -18631,15 +19615,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) {
@@ -18713,7 +19697,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 basename7, extname as extname2, join as join18, relative, resolve as resolve8, sep as sep3 } from "path";
+import { basename as basename7, 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 ?? (basename7(rootPath) || "local");
@@ -18756,7 +19740,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;
@@ -18820,7 +19804,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;
@@ -19674,18 +20658,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}`));
@@ -19717,7 +20708,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) {
@@ -19737,8 +20728,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;
@@ -19781,15 +20788,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"]);
   }
 });
 
@@ -20571,15 +21577,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;
@@ -20604,7 +21610,8 @@ function setupCheck() {
         tier: llmCfg.tier,
         auto_failover: llmCfg.autoFailover,
         anthropic: llmReady.anthropic,
-        openai: llmReady.openai
+        openai: llmReady.openai,
+        providers: llmReady.providers
       }
     },
     license: {
@@ -20616,7 +21623,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) {
@@ -20641,11 +21648,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);
@@ -20655,6 +21666,7 @@ var init_setup = __esm({
   "src/services/setup.ts"() {
     "use strict";
     init_repl_api();
+    init_providers();
     init_llm_config();
     init_store();
     init_profile();
@@ -20697,13 +21709,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();
@@ -20724,10 +21735,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")
@@ -20767,8 +21780,8 @@ 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";
 function printScopeProposal(ctx) {
   if (!ctx.scope) return;
   const lens = ctx.scope.primary_lens === "revenue_metrics" ? "SaaS metrics" : "pipeline health";
@@ -20926,8 +21939,8 @@ async function handleDeliverFlow(input, ctx) {
     prompts.close();
   }
   const stamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/T/, "-").replace(/:/g, "").slice(0, 15);
-  const out = join20(getExportsDir(), `handoff-${target}-${stamp2}.md`);
-  writeFileSync15(out, draft.markdown, "utf-8");
+  const out = join22(getExportsDir(), `handoff-${target}-${stamp2}.md`);
+  writeFileSync17(out, draft.markdown, "utf-8");
   const d = {
     kind: `prompt:${target}`,
     at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -20951,7 +21964,7 @@ 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) {
@@ -21126,8 +22139,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);
@@ -21137,8 +22150,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 };
   });
@@ -21297,17 +22310,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 {
@@ -21408,17 +22421,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 {
@@ -21436,7 +22449,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 {
   }
 }
@@ -21498,7 +22511,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}` });
@@ -21587,7 +22600,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);
 }
@@ -21623,7 +22636,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"
   });
@@ -21720,13 +22733,13 @@ var nl_exports = {};
 __export(nl_exports, {
   runNaturalLanguage: () => runNaturalLanguage
 });
-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");
@@ -21753,7 +22766,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
@@ -21778,7 +22791,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 = [];
@@ -22069,7 +23082,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 } = parseArgs2(args, ["findings"]);
@@ -22111,7 +23124,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
@@ -22310,7 +23323,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) {
@@ -22338,7 +23351,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");
@@ -22370,7 +23383,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) {
@@ -22407,7 +23420,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",
@@ -22535,7 +23548,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);
@@ -22551,7 +23564,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") {
@@ -22642,7 +23655,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") {
@@ -22654,7 +23667,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}"`);
@@ -22964,8 +23977,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) {
@@ -22980,7 +23993,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}`);
@@ -22995,7 +24008,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,
@@ -23021,7 +24034,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,
@@ -23071,13 +24084,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 } = parseArgs2(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 } = parseArgs2(args, ["default"]);
   const sub = positional[0]?.toLowerCase();
   if (!sub || sub === "list") {
@@ -23089,7 +24266,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;
   }
@@ -23102,7 +24279,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;
   }
@@ -23121,36 +24298,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();
 }
@@ -23161,49 +24342,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 } = parseArgs2(args, ["default"]);
   const sub = positional[0]?.toLowerCase();
   if (!sub || sub === "list") {
@@ -23212,8 +24398,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;
   }
@@ -23227,40 +24413,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;
@@ -23269,6 +24463,7 @@ var init_tier = __esm({
     "use strict";
     init_argparse();
     init_catalog();
+    init_models_cache();
     init_session_state();
     init_llm_config();
     init_store();
@@ -23281,12 +24476,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 } = parseArgs2(args, ["default"]);
+import chalk60 from "chalk";
+import ora18 from "ora";
+async function handler43(args, ctx) {
+  const { positional, flags } = parseArgs2(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;
@@ -23294,7 +24498,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;
   }
@@ -23302,22 +24506,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("  " + chalk59.yellow("\u26A0") + ` Unknown model ${modelId} \u2014 saving for active engine anyway.`);
+      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("  " + chalk60.yellow("\u26A0") + ` No discovered models for ${active} yet (` + paint("accent", "/model refresh") + `) \u2014 saving anyway.`);
     }
     const persist = getBool(flags, "default");
     if (persist) {
@@ -23328,36 +24538,86 @@ 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;
   }
 });
 
@@ -23369,22 +24629,22 @@ __export(update_check_exports, {
   loadUpdateCheckCache: () => loadUpdateCheckCache,
   saveUpdateCheckCache: () => saveUpdateCheckCache
 });
-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 ensureDir7() {
   const dir = ntrpHome();
-  if (!existsSync19(dir)) {
+  if (!existsSync21(dir)) {
     mkdirSync12(dir, { recursive: true });
   }
 }
 function loadUpdateCheckCache() {
-  const path = cachePath();
-  if (!existsSync19(path)) return null;
+  const path = cachePath2();
+  if (!existsSync21(path)) return null;
   try {
-    const parsed = JSON.parse(readFileSync14(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync17(path, "utf-8"));
     if (!parsed || typeof parsed !== "object" || typeof parsed.lastCheck !== "number" || typeof parsed.latestVersion !== "string") {
       return null;
     }
@@ -23395,39 +24655,39 @@ function loadUpdateCheckCache() {
 }
 function saveUpdateCheckCache(cache2) {
   ensureDir7();
-  writeFileSync17(cachePath(), JSON.stringify(cache2, null, 2) + "\n");
+  writeFileSync19(cachePath2(), JSON.stringify(cache2, null, 2) + "\n");
 }
-function isCacheFresh(cache2, ttlMs = CACHE_TTL_MS) {
+function isCacheFresh(cache2, ttlMs = CACHE_TTL_MS2) {
   if (!cache2) return false;
   return Date.now() - cache2.lastCheck < ttlMs;
 }
 function invalidateUpdateCheckCache() {
-  const path = cachePath();
-  if (existsSync19(path)) {
+  const path = cachePath2();
+  if (existsSync21(path)) {
     unlinkSync5(path);
   }
 }
-var CACHE_TTL_MS;
+var CACHE_TTL_MS2;
 var init_update_check = __esm({
   "src/config/update-check.ts"() {
     "use strict";
     init_store();
-    CACHE_TTL_MS = 864e5;
+    CACHE_TTL_MS2 = 864e5;
   }
 });
 
 // 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;
@@ -23493,14 +24753,14 @@ function buildResult(current, latest) {
 async function checkForUpdate(options) {
   const current = getInstalledVersion();
   const timeoutMs = options?.timeoutMs ?? 5e3;
-  const cached = loadUpdateCheckCache();
-  if (!options?.force && isCacheFresh(cached)) {
-    return buildResult(current, cached.latestVersion);
+  const cached2 = loadUpdateCheckCache();
+  if (!options?.force && isCacheFresh(cached2)) {
+    return buildResult(current, cached2.latestVersion);
   }
   const latest = await fetchLatestVersion(timeoutMs);
   if (!latest) {
-    if (cached?.latestVersion) {
-      return buildResult(current, cached.latestVersion);
+    if (cached2?.latestVersion) {
+      return buildResult(current, cached2.latestVersion);
     }
     return null;
   }
@@ -23521,10 +24781,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");
 }
@@ -23540,19 +24800,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;
   }
@@ -23561,24 +24821,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;
@@ -23593,10 +24853,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")}`);
@@ -23612,7 +24872,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) => {
@@ -23621,7 +24881,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" });
 }
@@ -23638,49 +24898,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();
 }
@@ -23702,17 +24962,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() {
@@ -23730,7 +24990,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";
   }
@@ -23747,11 +25007,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 } = parseArgs2(args, ["confirm"]);
   const sub = positional[0]?.toLowerCase();
   if (sub === "reset") {
@@ -23759,7 +25019,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;
   }
@@ -23866,10 +25126,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;
@@ -23955,6 +25215,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":
@@ -24082,7 +25344,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",
@@ -24518,6 +25782,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",
@@ -24530,10 +25813,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",
@@ -24541,13 +25826,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",
@@ -24569,12 +25855,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",
@@ -24633,7 +25921,7 @@ paragraph that flows into all AI surfaces.`
 });
 
 // src/license/activation.ts
-import chalk63 from "chalk";
+import chalk64 from "chalk";
 function hasValidLicense() {
   return checkLicense().valid;
 }
@@ -24641,10 +25929,10 @@ async function ensureLicenseActivated(ctx) {
   if (hasValidLicense()) return false;
   if (!process.stdin.isTTY) {
     console.error();
-    console.error(chalk63.red("  A license key is required."));
-    console.error(chalk63.dim(`  Sign up: ${getCheckoutUrl()}`));
-    console.error(chalk63.dim("  Then run: ntrp activate <key>"));
-    console.error(chalk63.dim("  Or set NTRP_LICENSE_KEY for headless use."));
+    console.error(chalk64.red("  A license key is required."));
+    console.error(chalk64.dim(`  Sign up: ${getCheckoutUrl()}`));
+    console.error(chalk64.dim("  Then run: ntrp activate <key>"));
+    console.error(chalk64.dim("  Or set NTRP_LICENSE_KEY for headless use."));
     console.error();
     process.exit(1);
   }
@@ -24654,7 +25942,7 @@ async function ensureLicenseActivated(ctx) {
   }
   printCenteredLogo();
   console.log("  " + bold("Activate your license"));
-  console.log("  " + chalk63.dim("Don't have a key yet? Sign up (free trial or Pro), then paste it below."));
+  console.log("  " + chalk64.dim("Don't have a key yet? Sign up (free trial or Pro), then paste it below."));
   console.log();
   await promptOpenCheckout(ctx);
   return promptForLicenseKey(ctx);
@@ -24681,6 +25969,7 @@ var init_gate2 = __esm({
     UNGATED_COMMANDS = /* @__PURE__ */ new Set([
       "activate",
       "config",
+      "connect",
       "profile",
       "onboard",
       "setup",
@@ -24705,7 +25994,7 @@ var router_exports = {};
 __export(router_exports, {
   conversationRouter: () => conversationRouter
 });
-import chalk64 from "chalk";
+import chalk65 from "chalk";
 async function conversationRouter(input, ctx) {
   if (ctx.oneShot || (ctx.wizardDepth ?? 0) > 0) {
     return { handled: false };
@@ -24715,7 +26004,7 @@ async function conversationRouter(input, ctx) {
   if (FRESH_START_RE.test(line)) {
     console.log();
     console.log(
-      "  " + chalk64.dim("Start a fresh analysis? This keeps prior sessions \u2014 say ") + chalk64.cyan("yes") + chalk64.dim(" to confirm or ") + chalk64.cyan("/home") + chalk64.dim(" for the dashboard.")
+      "  " + chalk65.dim("Start a fresh analysis? This keeps prior sessions \u2014 say ") + chalk65.cyan("yes") + chalk65.dim(" to confirm or ") + chalk65.cyan("/home") + chalk65.dim(" for the dashboard.")
     );
     console.log();
     return { handled: true };
@@ -24749,7 +26038,7 @@ async function conversationRouter(input, ctx) {
   }
   if (phase === "compute") {
     console.log();
-    console.log("  " + chalk64.dim("Analysis running \u2014 wait for it to finish before typing another question."));
+    console.log("  " + chalk65.dim("Analysis running \u2014 wait for it to finish before typing another question."));
     console.log();
     return { handled: true };
   }
@@ -24789,7 +26078,7 @@ var init_router = __esm({
 });
 
 // src/cli/dispatch.ts
-import chalk65 from "chalk";
+import chalk66 from "chalk";
 function printLicenseRequired(command) {
   printLicenseBlocked(command);
 }
@@ -24855,7 +26144,7 @@ async function dispatch(input, ctx) {
   if (tokens.length === 1) {
     if (/^\d$/.test(first)) {
       console.log(
-        "  " + chalk65.dim("Looks like a menu pick \u2014 run ") + paint("accent", "/new") + chalk65.dim(" to start (pick Demo, then choose your analysis type).")
+        "  " + chalk66.dim("Looks like a menu pick \u2014 run ") + paint("accent", "/new") + chalk66.dim(" to start (pick Demo, then choose your analysis type).")
       );
       return { kind: "handled" };
     }
@@ -24878,22 +26167,22 @@ async function dispatch(input, ctx) {
       return { kind: "handled", summary };
     }
     console.log(
-      "  " + chalk65.dim("Not in Q&A yet \u2014 confirm scope, load data, and run analysis first. Type ") + paint("accent", "/home") + chalk65.dim(" for status.")
+      "  " + chalk66.dim("Not in Q&A yet \u2014 confirm scope, load data, and run analysis first. Type ") + paint("accent", "/home") + chalk66.dim(" for status.")
     );
     return { kind: "handled" };
   }
   console.log(
-    "  " + chalk65.dim("Natural-language questions run in the interactive REPL. Start with ") + paint("accent", "ntrp") + chalk65.dim(" and ask after analysis.")
+    "  " + chalk66.dim("Natural-language questions run in the interactive REPL. Start with ") + paint("accent", "ntrp") + chalk66.dim(" and ask after analysis.")
   );
   return { kind: "handled" };
 }
 async function runSlashCommand(name, args, ctx) {
-  const handler45 = await resolveHandler(name);
-  if (!handler45) {
-    console.error(chalk65.red(`  Unknown command: /${name}`));
+  const handler46 = await resolveHandler(name);
+  if (!handler46) {
+    console.error(chalk66.red(`  Unknown command: /${name}`));
     return void 0;
   }
-  const result = await handler45(args, ctx);
+  const result = await handler46(args, ctx);
   return result ?? void 0;
 }
 async function runNaturalLanguage2(input, ctx) {
@@ -24922,7 +26211,7 @@ __export(welcome_exports, {
   GRADIENT: () => GRADIENT,
   printWelcome: () => printWelcome
 });
-import chalk66 from "chalk";
+import chalk67 from "chalk";
 function resolveSessionSummary(input) {
   if (input.scope?.intent_summary?.trim()) return input.scope.intent_summary.trim();
   if (input.summary?.trim()) return input.summary.trim();
@@ -24956,19 +26245,19 @@ function sessionSummaryText(s) {
     summary: s.summary,
     dataset: s.dataset
   });
-  return summary === NO_SUMMARY ? chalk66.dim(summary) : summary;
+  return summary === NO_SUMMARY ? chalk67.dim(summary) : summary;
 }
 function formatLastSessionLine(s, colW, ctx, opts) {
   const phase = sessionPhaseLabel(s, ctx);
-  const current = opts?.markCurrent && s.id === ctx?.sessionId ? chalk66.dim(" \xB7 current") : "";
-  const meta = `${formatSessionId(s.id, s.name)} ${chalk66.dim("\xB7")} ${chalk66.dim(lensBadgeLabel(s.analysis))} ${chalk66.dim("\xB7")} ${paint("accent", phase)} ${chalk66.dim("\xB7")} ${sessionSummaryText(s)}${current}`;
+  const current = opts?.markCurrent && s.id === ctx?.sessionId ? chalk67.dim(" \xB7 current") : "";
+  const meta = `${formatSessionId(s.id, s.name)} ${chalk67.dim("\xB7")} ${chalk67.dim(lensBadgeLabel(s.analysis))} ${chalk67.dim("\xB7")} ${paint("accent", phase)} ${chalk67.dim("\xB7")} ${sessionSummaryText(s)}${current}`;
   return truncateVisible(`  ${meta}`, colW);
 }
 function formatActiveSessionLine(s, colW, ctx, opts) {
   const indent = "  ";
   const idPart = formatSessionId(s.id, s.name);
-  const status = chalk66.dim(` \xB7 ${sessionStatusSuffix(s)}`);
-  const current = opts?.markCurrent && s.id === ctx?.sessionId ? chalk66.dim(" \xB7 current") : "";
+  const status = chalk67.dim(` \xB7 ${sessionStatusSuffix(s)}`);
+  const current = opts?.markCurrent && s.id === ctx?.sessionId ? chalk67.dim(" \xB7 current") : "";
   const suffix = `${status}${current}`;
   const summaryBudget = Math.max(8, colW - visibleWidth(indent) - visibleWidth(idPart) - visibleWidth(suffix) - 2);
   const summaryPart = truncateVisible(sessionSummaryText(s), summaryBudget);
@@ -25005,13 +26294,13 @@ function buildSystemLines(colW, statusRows, recent) {
   const lines = [""];
   lines.push(sectionHeading("System"));
   for (const item of statusRows) {
-    const label = chalk66.dim(padRight(item.label, 8));
+    const label = chalk67.dim(padRight(item.label, 8));
     const state = padRight(item.state, 10);
     const detailW = Math.max(1, colW - 21);
-    lines.push(`${label} ${state} ${chalk66.dim(truncateVisible(item.detail, detailW))}`);
+    lines.push(`${label} ${state} ${chalk67.dim(truncateVisible(item.detail, detailW))}`);
   }
   if (recent) {
-    lines.push(`${chalk66.dim(padRight("last used", 8))} ${chalk66.dim(recent)}`);
+    lines.push(`${chalk67.dim(padRight("last used", 8))} ${chalk67.dim(recent)}`);
   }
   return lines;
 }
@@ -25021,7 +26310,7 @@ function buildHelpLines(colW, unfinishedCount) {
     lines.push(sectionHeading(section.heading));
     for (const entry of section.entries) {
       const desc = entry.dynamicDescription ? entry.dynamicDescription(unfinishedCount) : entry.description;
-      const text = `  ${paint("accent", entry.command)}  ${chalk66.dim(desc)}`;
+      const text = `  ${paint("accent", entry.command)}  ${chalk67.dim(desc)}`;
       lines.push(truncateVisible(text, colW));
     }
   }
@@ -25031,10 +26320,10 @@ function buildLastSessionLines(colW, ctx, lastSession, nextAction, emptyDataHint
   const lines = [""];
   lines.push(sectionHeading("Last Session"));
   if (!lastSession) {
-    lines.push(`  ${chalk66.dim("(none yet)")}`);
+    lines.push(`  ${chalk67.dim("(none yet)")}`);
     lines.push(
       truncateVisible(
-        `  ${nextAction.command ? actionHint(nextAction.label, nextAction.command, nextAction.detail) : `${chalk66.dim(nextAction.label)} ${chalk66.dim(nextAction.detail)}`}`,
+        `  ${nextAction.command ? actionHint(nextAction.label, nextAction.command, nextAction.detail) : `${chalk67.dim(nextAction.label)} ${chalk67.dim(nextAction.detail)}`}`,
         colW
       )
     );
@@ -25045,7 +26334,7 @@ function buildLastSessionLines(colW, ctx, lastSession, nextAction, emptyDataHint
   if (!isCurrent) {
     lines.push(
       truncateVisible(
-        `  ${chalk66.dim("Resume:")} ${paint("accent", `/session ${lastSession.id.slice(-4)}`)}`,
+        `  ${chalk67.dim("Resume:")} ${paint("accent", `/session ${lastSession.id.slice(-4)}`)}`,
         colW
       )
     );
@@ -25054,7 +26343,7 @@ function buildLastSessionLines(colW, ctx, lastSession, nextAction, emptyDataHint
       truncateVisible(`  ${actionHint(nextAction.label, nextAction.command, nextAction.detail)}`, colW)
     );
   } else {
-    lines.push(truncateVisible(`  ${chalk66.dim(nextAction.label)} ${chalk66.dim(nextAction.detail)}`, colW));
+    lines.push(truncateVisible(`  ${chalk67.dim(nextAction.label)} ${chalk67.dim(nextAction.detail)}`, colW));
   }
   if (isCurrent && emptyDataHint) {
     lines.push(truncateVisible(`  ${emptyDataHint}`, colW));
@@ -25065,14 +26354,14 @@ function buildActiveSessionsLines(colW, ctx, activeSessions) {
   const lines = [""];
   lines.push(sectionHeading("Active Sessions"));
   if (activeSessions.length === 0) {
-    lines.push(`  ${chalk66.dim("(none in progress)")}`);
+    lines.push(`  ${chalk67.dim("(none in progress)")}`);
     return lines;
   }
   for (const s of activeSessions.slice(0, 5)) {
     lines.push(formatActiveSessionLine(s, colW, ctx, { markCurrent: true }));
   }
   if (activeSessions.length > 5) {
-    lines.push(`  ${chalk66.dim(`+${activeSessions.length - 5} more \xB7 `)}${paint("accent", "/session")}`);
+    lines.push(`  ${chalk67.dim(`+${activeSessions.length - 5} more \xB7 `)}${paint("accent", "/session")}`);
   }
   return lines;
 }
@@ -25080,7 +26369,7 @@ function buildProgressLines(colW) {
   const summary = getTimeBankSummary();
   const lines = [""];
   const heading = sectionHeading("Progress");
-  const hint = `${paint("accent", "/progress")}${chalk66.dim(" for usage metrics")}`;
+  const hint = `${paint("accent", "/progress")}${chalk67.dim(" for usage metrics")}`;
   const gap = colW - visibleWidth(heading) - visibleWidth(hint);
   if (gap > 2) {
     lines.push(truncateVisible(`${heading}${" ".repeat(gap)}${hint}`, colW));
@@ -25090,7 +26379,7 @@ function buildProgressLines(colW) {
   if (summary.total_minutes <= 0) {
     lines.push(
       truncateVisible(
-        `  ${chalk66.dim("Run /diagnose or ask a question to start banking hours.")}`,
+        `  ${chalk67.dim("Run /diagnose or ask a question to start banking hours.")}`,
         colW
       )
     );
@@ -25101,7 +26390,7 @@ function buildProgressLines(colW) {
   const bar = inlineBar(summary.progress_pct, 16);
   lines.push(truncateVisible(`  ${bar}  ${nextLabel}`, colW));
   if (summary.perspective_line) {
-    lines.push(truncateVisible(`  ${chalk66.dim.italic(summary.perspective_line)}`, colW));
+    lines.push(truncateVisible(`  ${chalk67.dim.italic(summary.perspective_line)}`, colW));
   }
   return lines;
 }
@@ -25111,7 +26400,7 @@ async function printWelcome(ctx, version) {
   const innerW = cardW - 2;
   const contentW = innerW - 2;
   const outerPad = " ".repeat(Math.max(0, Math.floor((width - cardW) / 2)));
-  const border = (ch) => chalk66.dim(ch);
+  const border = (ch) => chalk67.dim(ch);
   const push = (line) => console.log(outerPad + line);
   const fitCell = (content, width2) => {
     if (visibleWidth(content) > width2) return truncateVisible(content, width2);
@@ -25149,11 +26438,9 @@ async function printWelcome(ctx, version) {
     (s) => s.id !== ctx.sessionId && (s.exchange_count > 0 || s.stage === "analyzed" || s.stage === "delivered" || !!s.dataset?.label)
   );
   const datasetDetail = hasData ? ctx.dataset?.label ?? countStr : savedSessions.length > 0 ? `none loaded \xB7 ${savedSessions.length} saved` : "none loaded";
-  const { describeLlmReadiness: describeLlmReadiness2 } = await Promise.resolve().then(() => (init_repl_api(), repl_api_exports));
   const { countAvailableEngines: countAvailableEngines2, formatActiveStack: formatActiveStack2, availableEngineLabels: availableEngineLabels2 } = await Promise.resolve().then(() => (init_session_state(), session_state_exports));
-  const llmReady = describeLlmReadiness2();
   const engineCount = countAvailableEngines2();
-  const llmDetail = engineCount === 0 ? "needs key" : engineCount === 1 ? `1 engine \xB7 ${availableEngineLabels2()[0]}` : `${engineCount} engines`;
+  const llmDetail = engineCount === 0 ? "run /connect (any key)" : engineCount === 1 ? `1 engine \xB7 ${availableEngineLabels2()[0]}` : `${engineCount} engines \xB7 ${availableEngineLabels2().slice(0, 3).join(", ")}${engineCount > 3 ? ", \u2026" : ""}`;
   const llmState = engineCount >= 2 ? badge("READY", "success") : engineCount === 1 ? badge("READY", "success") : badge("MISSING", "warning");
   const inferenceDetail = engineCount > 0 ? `active: ${formatActiveStack2(ctx)}` : "not configured";
   const license = checkLicense();
@@ -25209,7 +26496,7 @@ async function printWelcome(ctx, version) {
     ctx,
     unfinishedCount: unfinishedSessions.length
   });
-  const emptyDataHint = !hasData ? savedSessions.length > 0 ? chalk66.dim("Run ") + paint("accent", "/session") + chalk66.dim(" to resume a saved analysis, or ") + paint("accent", "/new") + chalk66.dim(" for a fresh start") : chalk66.dim("Run ") + paint("accent", "/new") + chalk66.dim(" \u2192 pick Demo to explore sample data") : null;
+  const emptyDataHint = !hasData ? savedSessions.length > 0 ? chalk67.dim("Run ") + paint("accent", "/session") + chalk67.dim(" to resume a saved analysis, or ") + paint("accent", "/new") + chalk67.dim(" for a fresh start") : chalk67.dim("Run ") + paint("accent", "/new") + chalk67.dim(" \u2192 pick Demo to explore sample data") : null;
   const colW = useWideLayout ? leftW : contentW;
   const rightColW = useWideLayout ? rightW : contentW;
   const systemLines = buildSystemLines(colW, statusRows, recent);
@@ -25225,14 +26512,14 @@ async function printWelcome(ctx, version) {
     const logoOffset = " ".repeat(Math.max(0, Math.floor((cardW - maxLogoW) / 2)));
     for (const line of logo) push(logoOffset + line);
     const taglineOffset = " ".repeat(Math.max(0, Math.floor((cardW - visibleWidth(TAGLINE)) / 2)));
-    push(taglineOffset + chalk66.dim(TAGLINE));
+    push(taglineOffset + chalk67.dim(TAGLINE));
     push("");
   }
   const versionTag = ` v${version} `;
   const gap = Math.max(0, innerW - versionTag.length);
   const gapL = Math.floor(gap / 2);
   push(
-    border(`\u256D${"\u2500".repeat(gapL)}`) + chalk66.dim(versionTag) + border(`${"\u2500".repeat(gap - gapL)}\u256E`)
+    border(`\u256D${"\u2500".repeat(gapL)}`) + chalk67.dim(versionTag) + border(`${"\u2500".repeat(gap - gapL)}\u256E`)
   );
   if (useWideLayout) {
     const leftLines = [...systemLines, ...helpLines];
@@ -25332,8 +26619,8 @@ __export(repl_exports, {
 });
 import { createInterface as createInterface2 } from "readline/promises";
 import { clearLine as clearLine2, cursorTo as cursorTo2 } from "readline";
-import ora16 from "ora";
-import chalk67 from "chalk";
+import ora19 from "ora";
+import chalk68 from "chalk";
 function buildPrompt(ctx) {
   return buildConversationPrompt(ctx);
 }
@@ -25370,12 +26657,12 @@ function renderInlineSuggestion(rl, prompt) {
   const suffix = cursor === line.length ? inlineCommandSuggestion(line) : null;
   clearLine2(process.stdout, 0);
   cursorTo2(process.stdout, 0);
-  process.stdout.write(prompt + line + (suffix ? chalk67.dim(suffix) : ""));
+  process.stdout.write(prompt + line + (suffix ? chalk68.dim(suffix) : ""));
   cursorTo2(process.stdout, visibleLength(prompt) + cursor);
 }
 function appendTurnLine(current, promptLabel, currentSummary) {
-  const currentLine = currentSummary ? `${promptLabel} ${current} ${chalk67.white("\u2192")} ${currentSummary}` : `${promptLabel} ${current}`;
-  console.log("  " + chalk67.dim(currentLine));
+  const currentLine = currentSummary ? `${promptLabel} ${current} ${chalk68.white("\u2192")} ${currentSummary}` : `${promptLabel} ${current}`;
+  console.log("  " + chalk68.dim(currentLine));
   console.log();
 }
 async function goHome(ctx, version, history, opts) {
@@ -25385,7 +26672,7 @@ async function goHome(ctx, version, history, opts) {
   process.stdout.write("\x1B[2J\x1B[H");
   if (opts?.banner) {
     console.log();
-    console.log("  " + paint("accent", "\u2713") + " " + chalk67.dim(opts.banner));
+    console.log("  " + paint("accent", "\u2713") + " " + chalk68.dim(opts.banner));
   }
   await printWelcome(ctx, version);
 }
@@ -25408,11 +26695,11 @@ async function handleDispatchResult(result, ctx, version, history) {
     case "unknown":
       if (result.suggestion) {
         console.log(
-          "  " + chalk67.red(`Unknown command: ${result.token}.`) + chalk67.dim("  Did you mean ") + paint("accent", result.suggestion) + chalk67.dim("?")
+          "  " + chalk68.red(`Unknown command: ${result.token}.`) + chalk68.dim("  Did you mean ") + paint("accent", result.suggestion) + chalk68.dim("?")
         );
       } else {
         console.log(
-          "  " + chalk67.red(`Unknown command: ${result.token}`) + chalk67.dim("  Type ") + paint("accent", "/help") + chalk67.dim(" to see available commands.")
+          "  " + chalk68.red(`Unknown command: ${result.token}`) + chalk68.dim("  Type ") + paint("accent", "/help") + chalk68.dim(" to see available commands.")
         );
       }
       break;
@@ -25436,7 +26723,7 @@ async function runRepl(ctx, version) {
   ctx.rl = rl;
   console.log();
   console.log(
-    "  " + chalk67.dim("What do you want to look at? ") + chalk67.dim('(e.g. "pipeline health", "is NRR real?", "board deck on Q3")')
+    "  " + chalk68.dim("What do you want to look at? ") + chalk68.dim('(e.g. "pipeline health", "is NRR real?", "board deck on Q3")')
   );
   console.log();
   if (ctx.pendingUpdateCheck) {
@@ -25466,7 +26753,7 @@ async function runRepl(ctx, version) {
       return;
     }
     sigintPrimed = true;
-    console.log("\n  " + chalk67.dim("Type /exit to quit, or press Ctrl+C again."));
+    console.log("\n  " + chalk68.dim("Type /exit to quit, or press Ctrl+C again."));
   };
   rl.on("SIGINT", sigintHandler);
   function shutdownRepl() {
@@ -25537,7 +26824,7 @@ async function runRepl(ctx, version) {
           }
         }
       } else {
-        console.error("  " + chalk67.red("Error: " + String(err.message ?? err)));
+        console.error("  " + chalk68.red("Error: " + String(err.message ?? err)));
       }
     }
     history.push({ input: line, summary });
@@ -25545,7 +26832,7 @@ async function runRepl(ctx, version) {
   shutdownRepl();
   const exchangeCount = Math.floor(ctx.messages.length / 2);
   if (exchangeCount > 0) {
-    const spinner = ora16({ text: "Saving session\u2026", color: "cyan", discardStdin: false }).start();
+    const spinner = ora19({ text: "Saving session\u2026", color: "cyan", discardStdin: false }).start();
     const summary = await closeSession(ctx);
     if (summary) {
       spinner.succeed(`Session saved (${summary})`);
@@ -25555,7 +26842,7 @@ async function runRepl(ctx, version) {
   } else {
     await closeSession(ctx);
   }
-  console.log("  " + chalk67.dim(randomGoodbye()));
+  console.log("  " + chalk68.dim(randomGoodbye()));
 }
 function printHelpOneShot() {
   printHelp();
@@ -25563,10 +26850,10 @@ function printHelpOneShot() {
 function printHelp() {
   console.log();
   console.log("  " + sectionHeading("Conversation"));
-  console.log("  " + chalk67.dim("Type what you want to investigate \u2014 no slash needed."));
-  console.log("  " + chalk67.dim("Paste a CSV path or say ") + paint("accent", '"use demo data"') + chalk67.dim(" to load data."));
-  console.log("  " + chalk67.dim("After analysis, ask questions in plain English."));
-  console.log("  " + chalk67.dim("Say ") + paint("accent", '"ship a board deck"') + chalk67.dim(" to draft a handoff prompt."));
+  console.log("  " + chalk68.dim("Type what you want to investigate \u2014 no slash needed."));
+  console.log("  " + chalk68.dim("Paste a CSV path or say ") + paint("accent", '"use demo data"') + chalk68.dim(" to load data."));
+  console.log("  " + chalk68.dim("After analysis, ask questions in plain English."));
+  console.log("  " + chalk68.dim("Say ") + paint("accent", '"ship a board deck"') + chalk68.dim(" to draft a handoff prompt."));
   console.log();
   console.log("  " + sectionHeading("Shortcuts"));
   const shortcuts = [
@@ -25581,7 +26868,7 @@ function printHelp() {
   ];
   const maxW = Math.max(...shortcuts.map(([c]) => c.length)) + 2;
   for (const [cmd, desc] of shortcuts) {
-    console.log(`    ${paint("accent", padRight(cmd, maxW))}  ${chalk67.dim(desc)}`);
+    console.log(`    ${paint("accent", padRight(cmd, maxW))}  ${chalk68.dim(desc)}`);
   }
   console.log();
   console.log("  " + sectionHeading("Admin"));
@@ -25592,10 +26879,10 @@ function printHelp() {
   ];
   const adminMaxW = Math.max(...admin.map(([c]) => c.length)) + 2;
   for (const [cmd, desc] of admin) {
-    console.log(`    ${paint("accent", padRight(cmd, adminMaxW))}  ${chalk67.dim(desc)}`);
+    console.log(`    ${paint("accent", padRight(cmd, adminMaxW))}  ${chalk68.dim(desc)}`);
   }
   console.log();
-  console.log("  " + chalk67.dim("Power-user commands (") + paint("accent", "/new") + chalk67.dim(", ") + paint("accent", "/diagnose") + chalk67.dim(", ") + paint("accent", "/metrics") + chalk67.dim(") remain available."));
+  console.log("  " + chalk68.dim("Power-user commands (") + paint("accent", "/new") + chalk68.dim(", ") + paint("accent", "/diagnose") + chalk68.dim(", ") + paint("accent", "/metrics") + chalk68.dim(") remain available."));
   console.log();
 }
 var REPL_BUILTINS, ANSI_PATTERN, GOODBYES;
@@ -25678,7 +26965,7 @@ init_emit();
 init_errors2();
 init_types2();
 init_version();
-import chalk68 from "chalk";
+import chalk69 from "chalk";
 var VERSION = getInstalledVersion();
 var UNGATED = UNGATED_COMMANDS;
 var DB_COMMANDS = /* @__PURE__ */ new Set(["actions", "ask", "backmeup", "demo", "diagnose", "export", "handoff", "ingest", "metrics", "new", "playbook", "publish", "report", "reset", "segment", "session", "status", "strategy"]);
@@ -25705,7 +26992,7 @@ async function main() {
     quiet: args.globals.quiet
   });
   if (!ctx.execution.color) {
-    chalk68.level = 0;
+    chalk69.level = 0;
   }
   if (args.globals.stdin) {
     args.input = (await readStdin()).trim();
@@ -25718,16 +27005,16 @@ async function main() {
         if (isStructuredOutput(ctx.execution)) {
           emitError(cmd || "ntrp", new NtrpError("license_invalid", lic2.message, 3 /* Auth */));
         }
-        console.error(chalk68.red(`
+        console.error(chalk69.red(`
   ${lic2.message}`));
-        console.error(chalk68.dim("  Trial's over \u2014 /upgrade and paste your key.\n"));
+        console.error(chalk69.dim("  Trial's over \u2014 /upgrade and paste your key.\n"));
         process.exit(1);
       }
     }
-    const PROFILE_HINT_SKIP = /* @__PURE__ */ new Set(["onboard", "setup", "config", "activate", "help", "home", "exit", "quit", "clear", "profile", "progress"]);
+    const PROFILE_HINT_SKIP = /* @__PURE__ */ new Set(["onboard", "setup", "config", "connect", "activate", "help", "home", "exit", "quit", "clear", "profile", "progress"]);
     if (!isProfileConfigured() && !PROFILE_HINT_SKIP.has(cmd) && !ctx.execution.quiet) {
       console.error(
-        "  " + chalk68.dim("Tip: run ") + paint("accent", "ntrp") + chalk68.dim(" interactively to set up your company profile for richer answers.")
+        "  " + chalk69.dim("Tip: run ") + paint("accent", "ntrp") + chalk69.dim(" interactively to set up your company profile for richer answers.")
       );
     }
     const result = await dispatch(args.input, ctx);
@@ -25739,12 +27026,12 @@ async function main() {
         }
         if (result.suggestion) {
           console.error(
-            chalk68.red(`  Unknown command: ${result.token}.`) + chalk68.dim(" Did you mean ") + paint("accent", result.suggestion) + chalk68.dim("?")
+            chalk69.red(`  Unknown command: ${result.token}.`) + chalk69.dim(" Did you mean ") + paint("accent", result.suggestion) + chalk69.dim("?")
           );
         } else {
-          console.error(chalk68.red(`  Unknown command: ${result.token}`));
+          console.error(chalk69.red(`  Unknown command: ${result.token}`));
         }
-        console.error(chalk68.dim("  Run 'ntrp' for the interactive prompt."));
+        console.error(chalk69.dim("  Run 'ntrp' for the interactive prompt."));
         process.exit(1);
         break;
       case "help":
@@ -25771,6 +27058,7 @@ async function main() {
     const { printTrialNudge: printTrialNudge2 } = await Promise.resolve().then(() => (init_upgrade(), upgrade_exports));
     printTrialNudge2(lic);
   }
+  void Promise.resolve().then(() => (init_discovery(), discovery_exports)).then((m) => m.refreshStaleProviderCaches()).catch(() => void 0);
   if (!isProfileConfigured()) {
     try {
       const { handler: onboard } = await Promise.resolve().then(() => (init_onboard(), onboard_exports));