@sonnechasser/ntrp 0.1.7 → 0.2.0

package/dist/mcp/server.js

@@ -4002,10 +4002,198 @@ var init_health_score = __esm({
   }
 });
 
+// src/ai/llm/providers.ts
+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 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 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`;
+}
+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;
@@ -4013,7 +4201,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;
@@ -4028,30 +4216,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;
     }
   }
@@ -4091,20 +4291,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;
   }
@@ -4122,7 +4322,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;
@@ -4133,25 +4339,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);
@@ -4164,10 +4366,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, ...).";
   }
 });
 
@@ -4212,6 +4416,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;
@@ -4229,6 +4439,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);
   }
@@ -4237,6 +4450,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;
@@ -4251,7 +4469,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") {
@@ -4387,8 +4608,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(tools2) {
   return tools2.map((t) => ({
     type: "function",
@@ -4457,9 +4685,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,
@@ -4469,7 +4696,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) {
@@ -4480,15 +4707,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,
@@ -4501,64 +4724,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 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 existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "fs";
+import { join as join8 } from "path";
+function cachePath() {
+  return join8(ntrpHome(), "models.json");
+}
+function loadFile() {
+  if (cached) return cached;
+  const path = cachePath();
+  if (!existsSync8(path)) {
+    cached = { version: 1, providers: {} };
+    return cached;
   }
-  return id;
+  try {
+    const parsed = JSON.parse(readFileSync7(path, "utf-8"));
+    cached = { version: 1, providers: parsed.providers ?? {} };
+  } catch {
+    cached = { version: 1, providers: {} };
+  }
+  return cached;
+}
+function saveFile(file) {
+  writeFileSync7(cachePath(), JSON.stringify(file, null, 2) + "\n");
+  cached = file;
+}
+function getProviderModels(provider) {
+  return loadFile().providers[provider];
+}
+function setProviderModels(provider, entry) {
+  const file = loadFile();
+  file.providers[provider] = entry;
+  saveFile(file);
+}
+function getCachedTierModel(provider, tier) {
+  return getProviderModels(provider)?.tier_stack?.[tier];
+}
+function findCachedModel(provider, modelId) {
+  return getProviderModels(provider)?.models.find((m) => m.id === modelId);
+}
+function cachedModelProvider(modelId) {
+  const file = loadFile();
+  for (const [provider, entry] of Object.entries(file.providers)) {
+    if (entry.models.some((m) => m.id === modelId)) return provider;
+  }
+  return void 0;
 }
-function cheapestActiveInTier(provider, tier) {
+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}`;
 }
@@ -4566,6 +4843,7 @@ var ENTRIES, byId;
 var init_catalog = __esm({
   "src/ai/llm/catalog.ts"() {
     "use strict";
+    init_models_cache();
     ENTRIES = [
       {
         id: "claude-opus-4-6",
@@ -4638,6 +4916,292 @@ var init_catalog = __esm({
   }
 });
 
+// src/ai/llm/http.ts
+import { readFileSync as readFileSync8 } from "fs";
+function fixtureResponse(url, headers) {
+  try {
+    const raw = readFileSync8(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
+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 display = item.display_name ?? item.name;
+  if (display && display !== id) model.display_name = display;
+  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;
+}
+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];
@@ -4682,7 +5246,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;
 }
@@ -4708,8 +5272,8 @@ 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;
 }
@@ -4723,23 +5287,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,
@@ -4765,70 +5322,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, {
@@ -4837,23 +5466,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;
         }
       }
@@ -4861,10 +5514,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",
@@ -4876,52 +5530,86 @@ 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, ...).";
   }
 });
 
 // src/config/profile.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync7, mkdirSync as mkdirSync6 } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync8, existsSync as existsSync9, mkdirSync as mkdirSync6 } from "fs";
+import { join as join9 } from "path";
 function profilePath() {
   return PROFILE_PATH;
 }
 function profileExists() {
-  return existsSync7(PROFILE_PATH);
+  return existsSync9(PROFILE_PATH);
 }
 function isProfileConfigured(profile = loadProfile()) {
   if (!profile) return false;
   return profile.company_name.trim().length > 0;
 }
 function loadProfile() {
-  if (!existsSync7(PROFILE_PATH)) return null;
+  if (!existsSync9(PROFILE_PATH)) return null;
   try {
-    const parsed = JSON.parse(readFileSync6(PROFILE_PATH, "utf-8"));
+    const parsed = JSON.parse(readFileSync9(PROFILE_PATH, "utf-8"));
     if (!parsed || typeof parsed !== "object") return null;
     return parsed;
   } catch {
@@ -4934,21 +5622,21 @@ var init_profile = __esm({
     "use strict";
     init_store();
     NTRP_DIR3 = ntrpHome();
-    PROFILE_PATH = join7(NTRP_DIR3, "profile.json");
+    PROFILE_PATH = join9(NTRP_DIR3, "profile.json");
   }
 });
 
 // src/data/playbook.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7, appendFileSync } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync10, appendFileSync } from "fs";
+import { join as join10 } from "path";
 function playsPath() {
-  return join8(getMemoryDir(), PLAYS_FILE);
+  return join10(getMemoryDir(), PLAYS_FILE);
 }
 function getCustomPlays() {
   const path = playsPath();
-  if (!existsSync8(path)) return [];
+  if (!existsSync10(path)) return [];
   const out = [];
-  for (const line of readFileSync7(path, "utf-8").split("\n")) {
+  for (const line of readFileSync10(path, "utf-8").split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     try {
@@ -5395,7 +6083,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
       };
     }
   }
@@ -5696,9 +6385,9 @@ var init_tool_schemas = __esm({
 });
 
 // src/ai/privacy.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync7, appendFileSync as appendFileSync2 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync7, appendFileSync as appendFileSync2 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join9 } from "path";
+import { join as join11 } from "path";
 function stripPII(obj) {
   if (obj === null || obj === void 0) return obj;
   if (typeof obj !== "object") return obj;
@@ -5713,14 +6402,14 @@ function stripPII(obj) {
   return out;
 }
 function ensureAuditDir() {
-  if (!existsSync9(AUDIT_DIR)) {
+  if (!existsSync11(AUDIT_DIR)) {
     mkdirSync7(AUDIT_DIR, { recursive: true });
   }
 }
 function logToolCall(entry) {
   ensureAuditDir();
   const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const path = join9(AUDIT_DIR, `agentic-${date}.jsonl`);
+  const path = join11(AUDIT_DIR, `agentic-${date}.jsonl`);
   appendFileSync2(path, JSON.stringify(entry) + "\n");
 }
 var PII_FIELDS, AUDIT_DIR;
@@ -5744,7 +6433,7 @@ var init_privacy = __esm({
       "raw_data",
       "metadata"
     ]);
-    AUDIT_DIR = join9(homedir3(), ".ntrp", "audit");
+    AUDIT_DIR = join11(homedir3(), ".ntrp", "audit");
   }
 });
 
@@ -7982,7 +8671,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");
@@ -8337,6 +9026,9 @@ function formatLlmAttribution(meta) {
   return line;
 }
 function printLlmAttribution(meta) {
+  for (const notice of meta.notices ?? []) {
+    console.log(chalk8.dim(`  ${notice}`));
+  }
   const line = formatLlmAttribution(meta);
   if (line) console.log(chalk8.dim(`  ${line}`));
 }
@@ -8609,6 +9301,7 @@ async function renderDiagnoseStream(options) {
     let modelUsed = "";
     let providerUsed;
     let failover;
+    let notices;
     let rawPrompt = "";
     try {
       for await (const event of runFindings(fullResult)) {
@@ -8624,6 +9317,7 @@ async function renderDiagnoseStream(options) {
           modelUsed = event.model_used;
           providerUsed = event.provider_used;
           failover = event.failover;
+          notices = event.usage?.notices;
           rawPrompt = event.raw_prompt;
         }
       }
@@ -8647,7 +9341,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");
@@ -9070,7 +9765,7 @@ async function handler(args, ctx) {
     console.log();
     console.log("  " + chalk11.red("AI findings run only in the interactive REPL."));
     console.log("  " + chalk11.dim("Vital signs compute without a key \u2014 omit --findings for numbers only."));
-    console.log("  " + chalk11.dim("Start with ") + paint("accent", "ntrp") + chalk11.dim(", set ") + paint("accent", "/config set api-key") + chalk11.dim(" or openai-api-key, then /diagnose --findings."));
+    console.log("  " + chalk11.dim("Start with ") + paint("accent", "ntrp") + chalk11.dim(", run ") + paint("accent", "/connect") + chalk11.dim(" (any provider key), then /diagnose --findings."));
     console.log();
     return;
   }
@@ -12075,18 +12770,18 @@ var init_generator = __esm({
 });
 
 // src/demo/taxonomy-cache.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync7, existsSync as existsSync10, mkdirSync as mkdirSync8, unlinkSync as unlinkSync3 } from "fs";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync9, existsSync as existsSync12, mkdirSync as mkdirSync8, unlinkSync as unlinkSync3 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join10 } from "path";
+import { join as join12 } from "path";
 function ensureDir5() {
-  if (!existsSync10(NTRP_DIR4)) {
+  if (!existsSync12(NTRP_DIR4)) {
     mkdirSync8(NTRP_DIR4, { recursive: true });
   }
 }
 function loadCachedTaxonomy(profile) {
-  if (!existsSync10(TAXONOMY_PATH)) return null;
+  if (!existsSync12(TAXONOMY_PATH)) return null;
   try {
-    const parsed = JSON.parse(readFileSync8(TAXONOMY_PATH, "utf-8"));
+    const parsed = JSON.parse(readFileSync11(TAXONOMY_PATH, "utf-8"));
     if (!parsed || typeof parsed !== "object") return null;
     if (parsed.profile_updated_at !== profile.updated_at) return null;
     return parsed;
@@ -12096,14 +12791,14 @@ function loadCachedTaxonomy(profile) {
 }
 function saveCachedTaxonomy(taxonomy) {
   ensureDir5();
-  writeFileSync7(TAXONOMY_PATH, JSON.stringify(taxonomy, null, 2) + "\n");
+  writeFileSync9(TAXONOMY_PATH, JSON.stringify(taxonomy, null, 2) + "\n");
 }
 var NTRP_DIR4, TAXONOMY_PATH;
 var init_taxonomy_cache = __esm({
   "src/demo/taxonomy-cache.ts"() {
     "use strict";
-    NTRP_DIR4 = join10(homedir4(), ".ntrp");
-    TAXONOMY_PATH = join10(NTRP_DIR4, "demo-taxonomy.json");
+    NTRP_DIR4 = join12(homedir4(), ".ntrp");
+    TAXONOMY_PATH = join12(NTRP_DIR4, "demo-taxonomy.json");
   }
 });
 
@@ -12432,8 +13127,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 = ora4({ text: spinnerText, discardStdin: false }).start();
@@ -12536,7 +13231,7 @@ __export(ingest_exports, {
 });
 import chalk15 from "chalk";
 import ora5 from "ora";
-import { readFileSync as readFileSync9, existsSync as existsSync11 } from "fs";
+import { readFileSync as readFileSync12, existsSync as existsSync13 } from "fs";
 import { basename as basename2 } from "path";
 async function handler3(args, ctx) {
   const { positional, flags } = parseArgs(args, [
@@ -12560,7 +13255,7 @@ async function handler3(args, ctx) {
     console.error(chalk15.dim("         /ingest --demo [--scenario <name>]"));
     process.exit(1);
   }
-  if (!existsSync11(file)) {
+  if (!existsSync13(file)) {
     console.error(chalk15.red(`  File not found: ${file}`));
     process.exit(1);
   }
@@ -12578,7 +13273,7 @@ async function handler3(args, ctx) {
   try {
     await initSchema();
     spinner.text = "Parsing CSV...";
-    const content = readFileSync9(file, "utf-8");
+    const content = readFileSync12(file, "utf-8");
     const { rows, headers } = parseCSV(content);
     if (rows.length === 0) {
       spinner.fail("CSV is empty");
@@ -12694,7 +13389,7 @@ __export(ingest_chat_exports, {
   loadDemoFromChat: () => loadDemoFromChat,
   looksLikeFilePath: () => looksLikeFilePath
 });
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import { basename as basename3, resolve as resolve4 } from "path";
 import { homedir as homedir5 } from "os";
 import chalk16 from "chalk";
@@ -12714,11 +13409,11 @@ function extractFilePath(input) {
     const m = trimmed.match(re);
     if (m?.[1]) {
       const p = expandPath(m[1]);
-      if (existsSync12(p)) return p;
+      if (existsSync14(p)) return p;
     }
     if (!m?.[1] && re.test(trimmed) && trimmed.toLowerCase().endsWith(".csv")) {
       const p = expandPath(trimmed.replace(/^["']|["']$/g, ""));
-      if (existsSync12(p)) return p;
+      if (existsSync14(p)) return p;
     }
   }
   return null;
@@ -12748,12 +13443,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: readFileSync15 } = await import("fs");
+  const { readFileSync: readFileSync18 } = 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 = readFileSync15(filePath, "utf-8");
+    const raw = readFileSync18(filePath, "utf-8");
     const { headers } = parseCSV2(raw);
     const detected = detectEntityType2(headers, "unknown");
     if (!detected) headerCheckFailed = true;
@@ -13892,7 +14587,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) {
@@ -14100,24 +14795,24 @@ JSON SHAPE:
 
 // src/strategies/readers.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync13 } from "fs";
 import { extname, resolve as resolve5 } 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 = resolve5(pathOrDash);
-  if (!existsSync13(sourcePath)) {
+  if (!existsSync15(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);
@@ -14132,7 +14827,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();
@@ -14179,15 +14874,15 @@ var init_readers = __esm({
 });
 
 // src/strategies/library.ts
-import { writeFileSync as writeFileSync8 } from "fs";
-import { join as join11 } from "path";
+import { writeFileSync as writeFileSync10 } from "fs";
+import { join as join13 } from "path";
 import { stringify as stringifyYaml } from "yaml";
 function strategyLibraryPath(slug) {
-  return join11(getStrategiesDir(), `${slug}.md`);
+  return join13(getStrategiesDir(), `${slug}.md`);
 }
 function writeStrategyMarkdown(strategy) {
   const path = strategyLibraryPath(strategy.slug);
-  writeFileSync8(path, renderStrategyMarkdown(strategy), "utf-8");
+  writeFileSync10(path, renderStrategyMarkdown(strategy), "utf-8");
   return path;
 }
 function renderStrategyMarkdown(strategy) {
@@ -14261,7 +14956,7 @@ var init_library = __esm({
 // src/strategies/connectors.ts
 import { readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import { homedir as homedir6 } from "os";
-import { basename as basename4, extname as extname2, join as join12, relative, resolve as resolve6, sep as sep2 } from "path";
+import { basename as basename4, extname as extname2, join as join14, relative, resolve as resolve6, sep as sep2 } from "path";
 function createLocalFolderConnector(options) {
   const rootPath = resolveUserPath(options.rootPath);
   const name = options.name ?? (basename4(rootPath) || "local");
@@ -14304,7 +14999,7 @@ function createLocalFolderConnector(options) {
 }
 function walkLocalFolder(rootPath, currentPath, refs, opts) {
   for (const entry of readdirSync2(currentPath, { withFileTypes: true })) {
-    const absolutePath = join12(currentPath, entry.name);
+    const absolutePath = join14(currentPath, entry.name);
     const relativePath = normalizePath(relative(rootPath, absolutePath));
     if (entry.isDirectory()) {
       if (shouldSkipDirectory(entry.name) || matchesAny(relativePath, opts.excludePatterns)) continue;
@@ -14368,7 +15063,7 @@ function normalizePath(path) {
 }
 function resolveUserPath(path) {
   if (path === "~") return homedir6();
-  if (path.startsWith("~/")) return join12(homedir6(), path.slice(2));
+  if (path.startsWith("~/")) return join14(homedir6(), path.slice(2));
   return resolve6(path);
 }
 var DEFAULT_MAX_FILES, DEFAULT_MAX_BYTES, SUPPORTED_EXTENSIONS, DEFAULT_EXCLUDED_DIRS;
@@ -14613,8 +15308,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);
@@ -14624,8 +15319,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 };
   });
@@ -14784,17 +15479,17 @@ var init_retrieval = __esm({
 });
 
 // src/memory/knowledge.ts
-import { existsSync as existsSync14, readFileSync as readFileSync11, appendFileSync as appendFileSync3, readdirSync as readdirSync3 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync14, appendFileSync as appendFileSync3, readdirSync as readdirSync3 } from "fs";
+import { join as join17 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 function knowledgePath() {
-  return join15(getMemoryDir(), KNOWLEDGE_FILE);
+  return join17(getMemoryDir(), KNOWLEDGE_FILE);
 }
 function loadKnowledgeChunks() {
   const path = knowledgePath();
-  if (!existsSync14(path)) return [];
+  if (!existsSync16(path)) return [];
   const out = [];
-  for (const line of readFileSync11(path, "utf-8").split("\n")) {
+  for (const line of readFileSync14(path, "utf-8").split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     try {
@@ -14827,17 +15522,17 @@ __export(store_exports2, {
   rewriteJsonl: () => rewriteJsonl,
   scrubText: () => scrubText
 });
-import { existsSync as existsSync15, readFileSync as readFileSync12, appendFileSync as appendFileSync4, readdirSync as readdirSync4, writeFileSync as writeFileSync10 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync15, appendFileSync as appendFileSync4, readdirSync as readdirSync4, writeFileSync as writeFileSync12 } from "fs";
+import { join as join18 } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 function memPath(file) {
-  return join16(getMemoryDir(), file);
+  return join18(getMemoryDir(), file);
 }
 function readJsonl(file) {
   const path = memPath(file);
-  if (!existsSync15(path)) return [];
+  if (!existsSync17(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 {
@@ -14855,7 +15550,7 @@ function appendJsonl(file, obj) {
 }
 function rewriteJsonl(file, rows) {
   try {
-    writeFileSync10(memPath(file), rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length ? "\n" : ""));
+    writeFileSync12(memPath(file), rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length ? "\n" : ""));
   } catch {
   }
 }
@@ -14917,7 +15612,7 @@ function loadWinSnippets() {
     const out = [];
     for (const name of readdirSync4(dir)) {
       if (!name.endsWith(".md") || name.toLowerCase() === "readme.md") continue;
-      const raw = readFileSync12(join16(dir, name), "utf-8");
+      const raw = readFileSync15(join18(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}` });
@@ -15091,7 +15786,7 @@ init_session_analysis();
 init_queries();
 init_diagnosis();
 init_strategy();
-import { join as join14 } from "path";
+import { join as join16 } from "path";
 
 // src/services/publish.ts
 init_queries();
@@ -15256,8 +15951,8 @@ function buildSections(input) {
 
 // src/repositories/markdown.ts
 init_formatters();
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
-import { basename as basename5, dirname as dirname2, join as join13, resolve as resolve7 } from "path";
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync11 } from "fs";
+import { basename as basename5, dirname as dirname2, join as join15, resolve as resolve7 } from "path";
 import { stringify as stringifyYaml2 } from "yaml";
 var markdownRepositoryAdapter = {
   kind: "markdown",
@@ -15282,9 +15977,9 @@ var markdownRepositoryAdapter = {
     mkdirSync9(root, { recursive: true });
     const written = [];
     for (const file of files) {
-      const absolutePath = join13(root, file.relativePath);
+      const absolutePath = join15(root, file.relativePath);
       mkdirSync9(dirname2(absolutePath), { recursive: true });
-      writeFileSync9(absolutePath, file.contents, "utf-8");
+      writeFileSync11(absolutePath, file.contents, "utf-8");
       written.push(absolutePath);
     }
     return {
@@ -15600,7 +16295,7 @@ async function runSmokeProtocol(_input, ctx) {
   });
   const proposalResult = await proposeRepositoryExport({
     target: "markdown",
-    directory: join14(getExportsDir(), "repository-smoke"),
+    directory: join16(getExportsDir(), "repository-smoke"),
     source: "smoke_protocol",
     modelOrFixture: "smoke-protocol-v1"
   });
@@ -15764,11 +16459,12 @@ async function runAsk(question, ctx) {
 
 // src/services/setup.ts
 init_repl_api();
+init_providers();
 init_llm_config();
 init_store();
 init_profile();
-import { existsSync as existsSync16, mkdirSync as mkdirSync10, readFileSync as readFileSync13, writeFileSync as writeFileSync11 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync10, readFileSync as readFileSync16, writeFileSync as writeFileSync13 } from "fs";
+import { join as join19 } from "path";
 
 // src/license/verify.ts
 init_store();
@@ -15965,8 +16661,8 @@ function setupCheck() {
   let writable = false;
   try {
     mkdirSync10(home, { recursive: true });
-    const probe = join17(home, ".write-check");
-    writeFileSync11(probe, "ok\n");
+    const probe = join19(home, ".write-check");
+    writeFileSync13(probe, "ok\n");
     writable = true;
   } catch {
     writable = false;
@@ -15991,7 +16687,8 @@ function setupCheck() {
         tier: llmCfg.tier,
         auto_failover: llmCfg.autoFailover,
         anthropic: llmReady.anthropic,
-        openai: llmReady.openai
+        openai: llmReady.openai,
+        providers: llmReady.providers
       }
     },
     license: {
@@ -16010,18 +16707,18 @@ init_serialize();
 init_errors2();
 
 // src/version.ts
-import { existsSync as existsSync17, readFileSync as readFileSync14 } from "fs";
-import { dirname as dirname3, join as join18 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync17 } from "fs";
+import { dirname as dirname3, join as join20 } from "path";
 import { fileURLToPath } from "url";
 var cachedVersion;
 function getInstalledVersion() {
   if (cachedVersion) return cachedVersion;
   const start = dirname3(fileURLToPath(import.meta.url));
   for (const rel of ["../package.json", "../../package.json"]) {
-    const path = join18(start, rel);
-    if (!existsSync17(path)) continue;
+    const path = join20(start, rel);
+    if (!existsSync19(path)) continue;
     try {
-      const pkg = JSON.parse(readFileSync14(path, "utf-8"));
+      const pkg = JSON.parse(readFileSync17(path, "utf-8"));
       if (typeof pkg.version === "string" && pkg.version.length > 0) {
         cachedVersion = pkg.version;
         return cachedVersion;
@@ -16097,10 +16794,13 @@ async function callTool(name, input) {
     case "ntrp_setup_check":
       return toolContent(setupCheck());
     case "ntrp_diagnose": {
+      const wantsFindings = Boolean(input.findings || input.deep);
       const result = await runDiagnosis({
-        findings: Boolean(input.findings || input.deep),
+        findings: wantsFindings,
         deep: Boolean(input.deep),
-        segment: typeof input.segment === "string" ? input.segment : void 0
+        segment: typeof input.segment === "string" ? input.segment : void 0,
+        // Without a ctx, canUseReplAi() rejects AI findings even with stored keys.
+        ...wantsFindings ? { ctx: await initHeadlessAgentContext() } : {}
       });
       return toolContent({
         health: serializeHealth(result.health),