@securecoms/agent-runtime 0.4.0 → 0.6.0

package/README.md

@@ -90,7 +90,8 @@ All configuration is via `SECURECOMS_*` environment variables (see
 | `SECURECOMS_LLM_ENDPOINT` | `http://127.0.0.1:11434` | Base URL of an OpenAI-compatible LLM server, with or without a trailing `/v1` |
 | `SECURECOMS_LLM_MODEL` | `llama3` | Model name to request |
 | `SECURECOMS_LLM_API_KEY` | unset | API key for the LLM endpoint, if it requires one |
-| `SECURECOMS_LLM_API_KEY_FILE` | unset (or `--llm-key-file <path>`) | File holding the API key (trimmed on read). Preferred: it wins over `SECURECOMS_LLM_API_KEY`, and it is the only key form the service installer accepts. An unreadable or empty file exits 2 |
+| `SECURECOMS_LLM_API_KEY_FILE` | unset (or `--llm-key-file <path>`) | File holding the API key (trimmed on read). Preferred: it wins over `SECURECOMS_LLM_API_KEY`, and it is the only key form the service installer accepts. An unreadable or empty file, or `--llm-key-file` given anywhere (argv or env), makes the runtime an EXPLICIT source; a resolution failure fails that turn only — the agent boots and logs `llm: source unavailable — <reason>`, it does not exit |
+| `SECURECOMS_LLM_SOURCE` | unset | Any value fails the LLM source closed with no read of the managed files. Reserved for a future bridge-provided source; not a customer-facing setting today |
 | `SECURECOMS_BRAVE_KEY_FILE` | unset (or `--brave-key-file <path>`) | File holding a Brave Search API key. A path, never a value — required for `web_search` |
 | `SECURECOMS_TAVILY_KEY_FILE` | unset (or `--tavily-key-file <path>`) | File holding a Tavily API key. Used only when the Brave key file is absent |
 | `SECURECOMS_SKILLS_DIR` | this package's own `skills/` | Directory of skill manifests to load |
@@ -101,6 +102,21 @@ All configuration is via `SECURECOMS_*` environment variables (see
 | `SECURECOMS_TOOL_DENY` | unset | Comma-separated tool deny-list (wins over allow) |
 | `SECURECOMS_TOOL_DEFAULT` | `deny` | Fallback policy for a tool matched by neither list |
 
+### The LLM source: explicit vs managed
+
+An explicit source (any of `SECURECOMS_LLM_ENDPOINT`, `SECURECOMS_LLM_API_KEY`,
+`SECURECOMS_LLM_API_KEY_FILE`, or `--llm-key-file` on argv) always wins and is
+read once per turn straight from the env/cfg above — the managed files are
+never touched. With none of those set, the runtime instead looks for
+`~/.securecoms/runtime-config/<identityId>/llm-source.json` (`{provider,
+model}`) plus, when that provider needs one, `llm.key` and `llm.key.host`
+beside it — written by the desktop app (or, later, the bridge), never by this
+runtime. The endpoint is always derived from a compiled provider table, never
+read from the managed file, and `llm.key` is refused unless its
+`llm.key.host` sidecar names the same host the provider resolves to. Any
+resolution failure in either tier fails just that turn; it never crashes the
+process.
+
 ## Memory
 
 Memory is local only, never sent anywhere but the configured LLM endpoint,

package/dist/bin.js

@@ -3,9 +3,9 @@
 // src/index.ts
 import { readFileSync as readFileSync9 } from "node:fs";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { dirname as dirname4, join as join8 } from "node:path";
+import { dirname as dirname4, join as join9 } from "node:path";
 import { spawnSync } from "node:child_process";
-import { accessSync, constants, existsSync as existsSync7, mkdirSync as mkdirSync3, realpathSync, rmSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { accessSync, constants, existsSync as existsSync7, mkdirSync as mkdirSync3, realpathSync, rmSync, statSync as statSync2, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir4, userInfo } from "node:os";
 
 // src/config.ts
@@ -88,6 +88,7 @@ function loadConfig(argv, env) {
     llmEndpoint: env.SECURECOMS_LLM_ENDPOINT || "http://127.0.0.1:11434",
     llmModel: env.SECURECOMS_LLM_MODEL || "llama3",
     llmApiKey: env.SECURECOMS_LLM_API_KEY,
+    llmSource: env.SECURECOMS_LLM_SOURCE,
     llmApiKeyFile: parseStringFlag(argv, "--llm-key-file", env, "SECURECOMS_LLM_API_KEY_FILE"),
     braveKeyFile: parseStringFlag(argv, "--brave-key-file", env, "SECURECOMS_BRAVE_KEY_FILE"),
     tavilyKeyFile: parseStringFlag(argv, "--tavily-key-file", env, "SECURECOMS_TAVILY_KEY_FILE"),
@@ -103,25 +104,6 @@ function loadConfig(argv, env) {
   };
 }
 
-// src/llm-key.ts
-var LlmKeyFileError = class extends Error {
-};
-function resolveLlmApiKey(cfg, readFile) {
-  const path = cfg.llmApiKeyFile;
-  if (!path) return cfg.llmApiKey;
-  let raw;
-  try {
-    raw = readFile(path);
-  } catch (e) {
-    throw new LlmKeyFileError(
-      `cannot read LLM key file ${path}: ${e instanceof Error ? e.message : String(e)}`
-    );
-  }
-  const key = raw.trim();
-  if (!key) throw new LlmKeyFileError(`cannot read LLM key file ${path}: file is empty`);
-  return key;
-}
-
 // src/service/args.ts
 function parseVerb(argv) {
   const v = argv[2];
@@ -458,10 +440,16 @@ var LLMDispatcher = class {
   endpoint;
   model;
   apiKey;
+  chatPath;
+  chatAuth;
+  authHeaderName;
   constructor(endpoint, model, opts = {}) {
     this.endpoint = normalizeEndpoint(endpoint);
     this.model = model;
     this.apiKey = opts.apiKey;
+    this.chatPath = opts.chatPath ?? "/v1/chat/completions";
+    this.chatAuth = opts.chatAuth ?? "bearer";
+    this.authHeaderName = opts.authHeaderName ?? "x-api-key";
   }
   async complete(messages, tools) {
     const body = {
@@ -472,10 +460,12 @@ var LLMDispatcher = class {
     if (tools && tools.length > 0) {
       body.tools = tools;
     }
-    const url = `${this.endpoint}/v1/chat/completions`;
+    const url = `${this.endpoint}${this.chatPath}`;
     const headers = { "Content-Type": "application/json" };
-    if (this.apiKey) {
+    if (this.apiKey && this.chatAuth === "bearer") {
       headers.Authorization = `Bearer ${this.apiKey}`;
+    } else if (this.apiKey && this.chatAuth === "x-api-key") {
+      headers[this.authHeaderName] = this.apiKey;
     }
     const resp = await fetch(url, {
       method: "POST",
@@ -499,9 +489,211 @@ var LLMDispatcher = class {
   }
 };
 
+// src/llm-source.ts
+import { join as join2 } from "node:path";
+
+// src/llm-providers.json
+var llm_providers_default = {
+  openrouter: { chat_base: "https://openrouter.ai/api/v1", chat_path: "/v1/chat/completions", chat_auth: "bearer", models_url: "https://openrouter.ai/api/v1/models", models_id_path: "data[].id", validate_url: "https://openrouter.ai/api/v1/key", probe_auth: "bearer", extra_headers: null, catalog_prefix: "self", needs_key: true },
+  openai: { chat_base: "https://api.openai.com/v1", chat_path: "/v1/chat/completions", chat_auth: "bearer", models_url: "https://api.openai.com/v1/models", models_id_path: "data[].id", validate_url: "https://api.openai.com/v1/models", probe_auth: "bearer", extra_headers: null, catalog_prefix: "openai/", needs_key: true },
+  anthropic: { chat_base: "https://api.anthropic.com/v1", chat_path: "/v1/chat/completions", chat_auth: "bearer", models_url: "https://api.anthropic.com/v1/models", models_id_path: "data[].id", validate_url: "https://api.anthropic.com/v1/models", probe_auth: "x-api-key", extra_headers: { "anthropic-version": "2023-06-01" }, catalog_prefix: "anthropic/", needs_key: true },
+  gemini: { chat_base: "https://generativelanguage.googleapis.com/v1beta/openai", chat_path: "/chat/completions", chat_auth: "bearer", models_url: "https://generativelanguage.googleapis.com/v1beta/openai/models", models_id_path: "data[].id", validate_url: "https://generativelanguage.googleapis.com/v1beta/openai/models", probe_auth: "bearer", extra_headers: null, catalog_prefix: "google/", needs_key: true },
+  meta: { chat_base: "https://api.meta.ai/v1", chat_path: "/v1/chat/completions", chat_auth: "bearer", models_url: "https://api.meta.ai/v1/models", models_id_path: "data[].id", validate_url: "https://api.meta.ai/v1/models", probe_auth: "bearer", extra_headers: null, catalog_prefix: null, needs_key: true },
+  xai: { chat_base: "https://api.x.ai/v1", chat_path: "/v1/chat/completions", chat_auth: "bearer", models_url: "https://api.x.ai/v1/models", models_id_path: "data[].id", validate_url: "https://api.x.ai/v1/models", probe_auth: "bearer", extra_headers: null, catalog_prefix: "x-ai/", needs_key: true },
+  local: { chat_base: "http://127.0.0.1:11434", chat_path: "/v1/chat/completions", chat_auth: "none", models_url: "http://127.0.0.1:11434/api/tags", models_id_path: "models[].name", validate_url: null, probe_auth: "none", extra_headers: null, catalog_prefix: null, needs_key: false }
+};
+
+// src/llm-key.ts
+var LlmKeyFileError = class extends Error {
+};
+function resolveLlmApiKey(cfg, readFile) {
+  const path = cfg.llmApiKeyFile;
+  if (!path) return cfg.llmApiKey;
+  let raw;
+  try {
+    raw = readFile(path);
+  } catch (e) {
+    throw new LlmKeyFileError(
+      `cannot read LLM key file ${path}: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+  const key = raw.trim();
+  if (!key) throw new LlmKeyFileError(`cannot read LLM key file ${path}: file is empty`);
+  return key;
+}
+
+// src/llm-source.ts
+var PROVIDER_TABLE = Object.freeze(Object.fromEntries(
+  Object.entries(llm_providers_default).map(([p, e]) => [p, Object.freeze({
+    endpoint: e.chat_base,
+    needsKey: e.needs_key,
+    chatPath: e.chat_path,
+    chatAuth: e.chat_auth
+  })])
+));
+var LlmSourceUnavailableError = class extends Error {
+};
+function providerOrigin(provider) {
+  const entry = PROVIDER_TABLE[provider];
+  if (!entry) throw new LlmSourceUnavailableError(`unknown LLM provider ${JSON.stringify(provider)}`);
+  const u = new URL(entry.endpoint);
+  return `${u.protocol}//${u.host}`.toLowerCase();
+}
+function providerSlug(provider) {
+  return providerOrigin(provider).replace("://", "_").replace(/:/g, "-");
+}
+var explicitEndpointSet = (env) => Boolean(env.SECURECOMS_LLM_ENDPOINT || env.SECURECOMS_LLM_API_KEY_FILE || env.SECURECOMS_LLM_API_KEY);
+function isExplicitSource(cfg, env) {
+  return explicitEndpointSet(env) || Boolean(cfg.llmApiKeyFile) || Boolean(cfg.llmApiKey);
+}
+function resolveLlmSource(cfg, explicit, deps) {
+  if (cfg.llmSource) {
+    throw new LlmSourceUnavailableError(
+      `SECURECOMS_LLM_SOURCE=${JSON.stringify(cfg.llmSource)} is not a supported LLM source`
+    );
+  }
+  if (explicit) {
+    return {
+      endpoint: cfg.llmEndpoint,
+      model: cfg.llmModel,
+      apiKey: resolveLlmApiKey(cfg, deps.readFile),
+      provider: "env",
+      origin: "env",
+      chatPath: "/v1/chat/completions",
+      chatAuth: "bearer"
+    };
+  }
+  const managedDir = join2(deps.home, ".securecoms", "runtime-config", cfg.identityId);
+  const sourcePath = join2(managedDir, "llm-source.json");
+  let raw;
+  try {
+    raw = deps.readFile(sourcePath);
+  } catch (e) {
+    if (e.code !== "ENOENT") {
+      throw new LlmSourceUnavailableError(
+        `cannot read ${sourcePath}: ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+  }
+  if (raw !== void 0) {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (e) {
+      throw new LlmSourceUnavailableError(
+        `invalid JSON in ${sourcePath}: ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+    const { provider, model } = parsed;
+    if (typeof provider !== "string" || typeof model !== "string") {
+      throw new LlmSourceUnavailableError(`${sourcePath} is missing "provider" or "model"`);
+    }
+    if (!Object.hasOwn(llm_providers_default, provider)) {
+      throw new LlmSourceUnavailableError(
+        `unknown LLM provider ${JSON.stringify(provider)} in ${sourcePath}`
+      );
+    }
+    const entry = PROVIDER_TABLE[provider];
+    if (!entry) {
+      throw new LlmSourceUnavailableError(
+        `unknown LLM provider ${JSON.stringify(provider)} in ${sourcePath}`
+      );
+    }
+    let apiKey;
+    if (entry.needsKey) {
+      const expectedOrigin = providerOrigin(provider);
+      const slug = providerSlug(provider);
+      const keyPath = join2(managedDir, `llm.key.${slug}`);
+      const hostPath = join2(managedDir, `llm.key.${slug}.host`);
+      const legacyKey = join2(managedDir, "llm.key");
+      const legacyHost = join2(managedDir, "llm.key.host");
+      const useLegacy = !deps.exists(keyPath) && deps.exists(legacyKey) && deps.exists(legacyHost);
+      const boundKey = useLegacy ? legacyKey : keyPath;
+      const boundHost = useLegacy ? legacyHost : hostPath;
+      if (!deps.exists(boundKey)) {
+        throw new LlmSourceUnavailableError(
+          `${keyPath} does not exist \u2014 no key has been written for this managed source, refusing to read it`
+        );
+      }
+      let mode;
+      try {
+        ({ mode } = deps.statFile(boundKey));
+      } catch (e) {
+        throw new LlmSourceUnavailableError(
+          `cannot stat ${boundKey}: ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+      if ((mode & 63) !== 0) {
+        throw new LlmSourceUnavailableError(
+          `${boundKey} is readable by other users on this machine \u2014 tighten its permissions to owner-only`
+        );
+      }
+      if (!deps.exists(boundHost)) {
+        throw new LlmSourceUnavailableError(
+          `${boundKey} has no ${boundHost} sidecar recording which origin it belongs to \u2014 refusing to send it to ${expectedOrigin}`
+        );
+      }
+      const actualOrigin = deps.readFile(boundHost).trim();
+      if (actualOrigin !== expectedOrigin) {
+        throw new LlmSourceUnavailableError(
+          `${boundHost} is bound to ${actualOrigin}, but provider ${JSON.stringify(provider)} requires ${expectedOrigin} \u2014 refusing to send the key across origins`
+        );
+      }
+      apiKey = resolveLlmApiKey({ llmApiKeyFile: boundKey }, deps.readFile);
+    }
+    return {
+      endpoint: entry.endpoint,
+      model,
+      ...apiKey !== void 0 ? { apiKey } : {},
+      provider,
+      origin: "managed",
+      chatPath: entry.chatPath,
+      chatAuth: entry.chatAuth
+    };
+  }
+  return {
+    endpoint: cfg.llmEndpoint,
+    model: cfg.llmModel,
+    provider: "default",
+    origin: "default",
+    chatPath: "/v1/chat/completions",
+    chatAuth: "bearer"
+  };
+}
+
+// src/llm-shim.ts
+function endpointHost(endpoint) {
+  try {
+    return new URL(endpoint).host;
+  } catch {
+    return "(unparseable endpoint)";
+  }
+}
+function buildLlmShim(cfg, explicit, deps) {
+  return {
+    async complete(messages, tools) {
+      const src = resolveLlmSource(cfg, explicit, deps);
+      const dispatcher = new LLMDispatcher(src.endpoint, src.model, {
+        apiKey: src.apiKey,
+        chatPath: src.chatPath,
+        chatAuth: src.chatAuth
+      });
+      return dispatcher.complete(messages, tools);
+    }
+  };
+}
+function bootLine(cfg, explicit, deps) {
+  try {
+    const src = resolveLlmSource(cfg, explicit, deps);
+    return `securecoms-agent ${cfg.identityId.slice(0, 8)} \u2192 llm source=${src.origin} ${endpointHost(src.endpoint)} (${src.model})`;
+  } catch (e) {
+    return `llm: source unavailable \u2014 ${e instanceof Error ? e.message : String(e)}`;
+  }
+}
+
 // src/memory.ts
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 var MAX_HISTORY = 50;
 var AgentMemory = class {
   history = [];
@@ -566,10 +758,10 @@ ${memories}`;
     }
   }
   get historyPath() {
-    return join2(this.dataDir, "conversation-history.json");
+    return join3(this.dataDir, "conversation-history.json");
   }
   get memoriesPath() {
-    return join2(this.dataDir, "memories.json");
+    return join3(this.dataDir, "memories.json");
   }
   loadHistory() {
     try {
@@ -609,7 +801,7 @@ ${memories}`;
 
 // src/skill-invoker.ts
 import { readFileSync as readFileSync6, readdirSync, existsSync as existsSync5, statSync } from "node:fs";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 
 // src/skill-md.ts
 var SkillMdError = class extends Error {
@@ -770,16 +962,16 @@ import { isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
 // src/config-dirs.ts
 import { existsSync as existsSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 function managedConfigDir(identityId, home = homedir2()) {
-  return join3(home, ".securecoms", "runtime-config", identityId);
+  return join4(home, ".securecoms", "runtime-config", identityId);
 }
 function configSearchPath(identityId, dataDir, home = homedir2()) {
   return [managedConfigDir(identityId, home), dataDir];
 }
 function findConfigFile(name, dirs) {
   for (const dir of dirs) {
-    const path = join3(dir, name);
+    const path = join4(dir, name);
     if (existsSync2(path)) return path;
   }
   return null;
@@ -1118,7 +1310,7 @@ var httpRequest = async (args, ctx) => {
 
 // src/long-term-memory.ts
 import { copyFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 var MEMORY_FILE = "MEMORY.md";
 var MEMORY_MAX_BYTES = 8192;
 var FACT_MAX_CHARS = 300;
@@ -1129,13 +1321,13 @@ function readLongTermMemory(dirs) {
   return body || null;
 }
 function memoryTarget(dirs) {
-  for (const d of dirs) if (existsSync4(join4(d, MEMORY_FILE))) return d;
+  for (const d of dirs) if (existsSync4(join5(d, MEMORY_FILE))) return d;
   for (const d of dirs) if (existsSync4(d)) return d;
   return dirs[dirs.length - 1];
 }
 function migrateMemoryIntoManaged(managedDir, dataDir) {
-  const managed = join4(managedDir, MEMORY_FILE);
-  const local = join4(dataDir, MEMORY_FILE);
+  const managed = join5(managedDir, MEMORY_FILE);
+  const local = join5(dataDir, MEMORY_FILE);
   if (!existsSync4(managedDir) || existsSync4(managed) || !existsSync4(local)) return false;
   copyFileSync(local, managed);
   return true;
@@ -1153,7 +1345,7 @@ function rememberFact(dirs, fact, now) {
 `, "utf8") > MEMORY_MAX_BYTES && lines.length > 1) {
     lines = lines.slice(1);
   }
-  writeFileSync2(join4(dir, MEMORY_FILE), `${lines.join("\n")}
+  writeFileSync2(join5(dir, MEMORY_FILE), `${lines.join("\n")}
 `, { mode: 384 });
   return line;
 }
@@ -1415,11 +1607,11 @@ var SkillInvoker = class {
     const flat = [], manifests = [], skillMds = [];
     for (const entry of readdirSync(this.skillsDir, { withFileTypes: true })) {
       if (entry.isFile() && entry.name.endsWith(".json")) {
-        flat.push(join5(this.skillsDir, entry.name));
+        flat.push(join6(this.skillsDir, entry.name));
       } else if (entry.isDirectory()) {
-        const m = join5(this.skillsDir, entry.name, "manifest.json");
+        const m = join6(this.skillsDir, entry.name, "manifest.json");
         if (existsSync5(m) && statSync(m).isFile()) manifests.push(m);
-        const s = join5(this.skillsDir, entry.name, "SKILL.md");
+        const s = join6(this.skillsDir, entry.name, "SKILL.md");
         if (existsSync5(s) && statSync(s).isFile()) skillMds.push(s);
       }
     }
@@ -1609,7 +1801,7 @@ function createDynamicToolGate(policyFor) {
 import { readFileSync as readFileSync7 } from "node:fs";
 import { WebSocket } from "node:http";
 import { homedir as homedir3 } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 var SEEN_MAX = 5e3;
 function errText(e) {
   return e instanceof Error ? e.message : String(e);
@@ -1652,8 +1844,8 @@ var SecureComsDataPlane = class {
   generation = 0;
   constructor(cfg, onMessage) {
     this.identityId = cfg.identityId;
-    const dir = cfg.connectionsDir ?? join6(homedir3(), ".securecoms", "connections");
-    this.connectionPath = join6(dir, `${cfg.identityId}.json`);
+    const dir = cfg.connectionsDir ?? join7(homedir3(), ".securecoms", "connections");
+    this.connectionPath = join7(dir, `${cfg.identityId}.json`);
     this.establishedMs = cfg.establishedMs ?? 5e3;
     this.initialDelayMs = cfg.initialDelayMs ?? 250;
     this.maxDelayMs = cfg.maxDelayMs ?? 3e4;
@@ -1969,7 +2161,7 @@ ${longTerm}` });
 
 // src/persona.ts
 import { existsSync as existsSync6, readFileSync as readFileSync8, renameSync, unlinkSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname3, join as join7 } from "node:path";
+import { dirname as dirname3, join as join8 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var PERSONA_MAX_BYTES = 8192;
 var PERSONA_SOURCES = [
@@ -1985,7 +2177,7 @@ var SAFETY_PREAMBLE = [
   "- Only use the tools you were given; do not invent capabilities."
 ].join("\n");
 function defaultPersonaDir() {
-  return join7(dirname3(fileURLToPath2(import.meta.url)), "..", "persona");
+  return join8(dirname3(fileURLToPath2(import.meta.url)), "..", "persona");
 }
 function assemblePrompt(parts) {
   return parts.map((p) => `${p.heading}
@@ -2017,11 +2209,11 @@ function systemPromptFor(dirs, fallback) {
 
 ${SAFETY_PREAMBLE}`;
 }
-function writeLocalConfigReport(managedDir, dataDir, now, hasSearchKey) {
+function writeLocalConfigReport(managedDir, dataDir, now, flags) {
   if (!existsSync6(managedDir)) return false;
   const persona = {};
   for (const { file } of PERSONA_SOURCES) {
-    const path2 = join7(dataDir, file);
+    const path2 = join8(dataDir, file);
     if (!existsSync6(path2)) continue;
     try {
       persona[file] = readFileSync8(path2, "utf8").slice(0, PERSONA_MAX_BYTES);
@@ -2031,10 +2223,11 @@ function writeLocalConfigReport(managedDir, dataDir, now, hasSearchKey) {
   const doc = {
     schema: "securecoms.local-config/1",
     written_at: now.toISOString(),
-    has_search_key: hasSearchKey,
+    has_search_key: flags.hasSearchKey,
+    has_llm_key: flags.hasLlmKey,
     persona
   };
-  const path = join7(managedDir, "local-config.json");
+  const path = join8(managedDir, "local-config.json");
   const tmp = `${path}.${process.pid}.tmp`;
   try {
     writeFileSync3(tmp, `${JSON.stringify(doc, null, 2)}
@@ -2053,25 +2246,30 @@ function personaInit(dataDir, defaultsDir, writeFile, exists) {
   const written = [];
   const skipped = [];
   for (const { file } of PERSONA_SOURCES) {
-    const target = join7(dataDir, file);
+    const target = join8(dataDir, file);
     if (exists(target)) {
       skipped.push(target);
       continue;
     }
-    writeFile(target, readFileSync8(join7(defaultsDir, file), "utf8"));
+    writeFile(target, readFileSync8(join8(defaultsDir, file), "utf8"));
     written.push(target);
   }
   return { written, skipped };
 }
 function createLocalConfigReporter(managedDir, dataDir, now) {
   let lastWritten = null;
-  return (hasSearchKey) => {
-    if (lastWritten === hasSearchKey) return false;
-    const wrote = writeLocalConfigReport(managedDir, dataDir, now(), hasSearchKey);
-    if (wrote) lastWritten = hasSearchKey;
+  return (flags) => {
+    if (lastWritten !== null && lastWritten.hasSearchKey === flags.hasSearchKey && lastWritten.hasLlmKey === flags.hasLlmKey) {
+      return false;
+    }
+    const wrote = writeLocalConfigReport(managedDir, dataDir, now(), flags);
+    if (wrote) lastWritten = { ...flags };
     return wrote;
   };
 }
+function hasLlmKeyFor(source) {
+  return source.origin === "managed" && source.apiKey !== void 0;
+}
 
 // src/warning-filter.ts
 function installWarningFilter(proc = process) {
@@ -2086,7 +2284,7 @@ function installWarningFilter(proc = process) {
 
 // src/index.ts
 if (process.argv.includes("--version")) {
-  const pkg = JSON.parse(readFileSync9(join8(dirname4(dirname4(fileURLToPath3(import.meta.url))), "package.json"), "utf8"));
+  const pkg = JSON.parse(readFileSync9(join9(dirname4(dirname4(fileURLToPath3(import.meta.url))), "package.json"), "utf8"));
   console.log(pkg.version);
   process.exit(0);
 }
@@ -2103,12 +2301,13 @@ function makeLogger(cfg) {
 function safeChannelSegment(channelId) {
   return channelId.replace(/[^A-Za-z0-9_-]/g, "_") || "_";
 }
-function endpointHost(endpoint) {
-  try {
-    return new URL(endpoint).host;
-  } catch {
-    return "(unparseable endpoint)";
-  }
+function realLlmSourceDeps() {
+  return {
+    home: homedir4(),
+    readFile: (p) => readFileSync9(p, "utf8"),
+    statFile: (p) => ({ mode: statSync2(p).mode }),
+    exists: (p) => existsSync7(p)
+  };
 }
 function realServiceDeps() {
   return {
@@ -2255,20 +2454,12 @@ async function main() {
     return;
   }
   const log = makeLogger(cfg);
-  let apiKey;
-  try {
-    apiKey = resolveLlmApiKey(cfg, (p) => readFileSync9(p, "utf8"));
-  } catch (e) {
-    console.error(`securecoms-agent: ${e instanceof Error ? e.message : String(e)}`);
-    process.exit(2);
-    return;
-  }
-  const llm = new LLMDispatcher(cfg.llmEndpoint, cfg.llmModel, { apiKey });
+  const llm = buildLlmShim(cfg, isExplicitSource(cfg, process.env), realLlmSourceDeps());
   const memories = /* @__PURE__ */ new Map();
   const memoryFor = (channelId) => {
     let mem = memories.get(channelId);
     if (!mem) {
-      mem = new AgentMemory(join8(cfg.dataDir, "channels", safeChannelSegment(channelId)));
+      mem = new AgentMemory(join9(cfg.dataDir, "channels", safeChannelSegment(channelId)));
       memories.set(channelId, mem);
     }
     return mem;
@@ -2295,9 +2486,16 @@ async function main() {
   };
   const configDirs = configSearchPath(cfg.identityId, cfg.dataDir);
   const hasSearchKey = () => hasReadableKeyFile([keyFilePath("brave"), keyFilePath("tavily")], (p) => readFileSync9(p, "utf8"));
+  const hasLlmKey = () => {
+    try {
+      return hasLlmKeyFor(resolveLlmSource(cfg, isExplicitSource(cfg, process.env), realLlmSourceDeps()));
+    } catch {
+      return false;
+    }
+  };
   migrateMemoryIntoManaged(managedDir, cfg.dataDir);
   const reportLocalConfig = createLocalConfigReporter(managedDir, cfg.dataDir, () => /* @__PURE__ */ new Date());
-  reportLocalConfig(hasSearchKey());
+  reportLocalConfig({ hasSearchKey: hasSearchKey(), hasLlmKey: hasLlmKey() });
   const builtinCtx = {
     dataDir: cfg.dataDir,
     configDirs,
@@ -2321,7 +2519,7 @@ async function main() {
     const sc = currentSkillsConfig();
     const g = createLocalToolGate(policyFor());
     const searchKey = hasSearchKey();
-    reportLocalConfig(searchKey);
+    reportLocalConfig({ hasSearchKey: searchKey, hasLlmKey: hasLlmKey() });
     return skills.available(requiresEnvFrom(sc, searchKey)).filter((t) => g.gate(t.function.name).allowed);
   };
   for (const held of skills.unavailable(requiresEnvFrom(currentSkillsConfig(), hasSearchKey()))) {
@@ -2344,7 +2542,7 @@ async function main() {
     })
   );
   console.log(
-    `securecoms-agent ${cfg.identityId.slice(0, 8)} \u2192 llm ${endpointHost(cfg.llmEndpoint)} (${cfg.llmModel}), ${offeredTools().length} skills, tool gate default=${cfg.toolGate.default}`
+    `${bootLine(cfg, isExplicitSource(cfg, process.env), realLlmSourceDeps())}, ${offeredTools().length} skills, tool gate default=${cfg.toolGate.default}`
   );
   await plane.start();
   const shutdown = () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@securecoms/agent-runtime",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "type": "module",
   "bin": {
     "securecoms-agent": "dist/bin.js"