switchroom 0.19.0 → 0.19.2

package/dist/cli/switchroom.js

@@ -2120,7 +2120,7 @@ var init_esm = __esm(() => {
 });
 
 // src/build-info.ts
-var VERSION = "0.19.0", COMMIT_SHA = "9709a540";
+var VERSION = "0.19.2", COMMIT_SHA = "1fa69736";
 
 // src/cli/resolve-version.ts
 import { existsSync, readFileSync } from "node:fs";
@@ -15452,14 +15452,27 @@ __export(exports_atomic, {
   atomicWriteFileSync: () => atomicWriteFileSync
 });
 import { randomBytes } from "node:crypto";
-import { closeSync as closeSync2, constants, fsyncSync, openSync as openSync2, renameSync, rmSync, writeSync } from "node:fs";
-function atomicWriteFileSync(destPath, contents, mode = 384) {
+import { closeSync as closeSync2, constants, fchmodSync, fchownSync, fsyncSync, openSync as openSync2, renameSync, rmSync, writeSync } from "node:fs";
+function atomicWriteFileSync(destPath, contents, modeOrOpts = 384) {
+  const opts = typeof modeOrOpts === "number" ? { mode: modeOrOpts } : modeOrOpts;
+  const mode = opts.mode ?? 384;
   const tmp = `${destPath}.tmp-${process.pid}-${randomBytes(4).toString("hex")}`;
   const buf = typeof contents === "string" ? Buffer.from(contents, "utf-8") : contents;
   let fd = null;
   try {
     fd = openSync2(tmp, TMP_OPEN_FLAGS, mode);
     writeSync(fd, buf, 0, buf.length, 0);
+    fchmodSync(fd, mode);
+    if (opts.uid !== undefined) {
+      try {
+        fchownSync(fd, opts.uid, opts.gid ?? opts.uid);
+      } catch (chownErr) {
+        if (opts.onChownError)
+          opts.onChownError(chownErr);
+        else
+          throw chownErr;
+      }
+    }
     fsyncSync(fd);
     closeSync2(fd);
     fd = null;
@@ -15655,6 +15668,53 @@ function resolveHindsightLlm(llm, litellm) {
   const model = llm?.model?.trim() || (litellm ? litellm.model ?? HINDSIGHT_DEFAULT_LITELLM_MODEL : HINDSIGHT_DEFAULT_MODEL);
   return { provider, model };
 }
+function isLoopbackHttpUrl(url) {
+  try {
+    const u = new URL(url.includes("://") ? url : `http://${url}`);
+    const h = (u.hostname || "").toLowerCase();
+    return h === "localhost" || h === "127.0.0.1" || h === "::1";
+  } catch {
+    return false;
+  }
+}
+function collectHindsightLlmBaseUrls(llm, litellm) {
+  const out = [];
+  const seen = new Set;
+  const push = (raw) => {
+    const v = raw?.trim();
+    if (!v || seen.has(v))
+      return;
+    seen.add(v);
+    out.push(v);
+  };
+  push(litellm?.baseUrl);
+  for (const [k, v] of resolveHindsightPerOpLlm(llm)) {
+    if (k.endsWith("_BASE_URL"))
+      push(v);
+  }
+  return out;
+}
+function hindsightNeedsHostNetwork(llm, litellm) {
+  if (litellm?.baseUrl?.trim())
+    return true;
+  return collectHindsightLlmBaseUrls(llm).some(isLoopbackHttpUrl);
+}
+function pickHindsightLiteLlmProbeUrl(llm, litellm) {
+  return collectHindsightLlmBaseUrls(llm, litellm)[0];
+}
+function buildLiteLlmAwareHealthPy(apiPort, litellmBaseUrl) {
+  let host = "127.0.0.1";
+  let port = "80";
+  try {
+    const u = new URL(litellmBaseUrl.includes("://") ? litellmBaseUrl : `http://${litellmBaseUrl}`);
+    host = u.hostname || host;
+    port = u.port || (u.protocol === "https:" ? "443" : "80");
+  } catch {}
+  return `import socket,urllib.request,sys;` + `r=urllib.request.urlopen('http://localhost:${apiPort}/health',timeout=4);` + `(r.getcode()==200) or sys.exit(1);` + `s=socket.create_connection(('${host}',${Number(port)}),2);s.close()`;
+}
+function buildLiteLlmAwareHealthCmd(apiPort, litellmBaseUrl) {
+  return `python3 -c "${buildLiteLlmAwareHealthPy(apiPort, litellmBaseUrl)}"`;
+}
 function startHindsight(ports, litellm, imageTag, llm, mirrorDir) {
   const apiPort = ports?.apiPort ?? HINDSIGHT_DEFAULT_API_PORT;
   const uiPort = ports?.uiPort ?? HINDSIGHT_DEFAULT_UI_PORT;
@@ -15687,7 +15747,9 @@ function startHindsight(ports, litellm, imageTag, llm, mirrorDir) {
     "-e",
     `HINDSIGHT_API_CONSOLIDATION_LLM_PARALLELISM=${HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_PARALLELISM}`,
     "-e",
-    `HINDSIGHT_API_CONSOLIDATION_MAX_MEMORIES_PER_ROUND=${HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND}`
+    `HINDSIGHT_API_CONSOLIDATION_MAX_MEMORIES_PER_ROUND=${HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND}`,
+    "-e",
+    `HINDSIGHT_API_WORKER_ID=${HINDSIGHT_DEFAULT_WORKER_ID}`
   ];
   if (llmProvider === "claude-code") {
     envArgs.push("-e", `ANTHROPIC_MODEL=${llmModel}`);
@@ -15710,8 +15772,15 @@ x-litellm-tags: service:hindsight`);
     `--memory-reservation=${HINDSIGHT_DEFAULT_MEM_RESERVATION}`,
     `--pids-limit=${HINDSIGHT_DEFAULT_PIDS_LIMIT}`,
     `--shm-size=${HINDSIGHT_DEFAULT_SHM_SIZE}`,
-    "--health-cmd",
-    litellm ? `python3 -c 'import urllib.request,sys; sys.exit(0 if urllib.request.urlopen("http://localhost:${apiPort}/health",timeout=4).getcode()==200 else 1)'` : HINDSIGHT_HEALTHCHECK_CMD,
+    ...(() => {
+      const hostNet = hindsightNeedsHostNetwork(llm, litellm);
+      const healthApiPort = hostNet ? apiPort : 8888;
+      const probe = pickHindsightLiteLlmProbeUrl(llm, litellm);
+      return [
+        "--health-cmd",
+        probe ? buildLiteLlmAwareHealthCmd(healthApiPort, probe) : HINDSIGHT_HEALTHCHECK_CMD
+      ];
+    })(),
     "--health-interval",
     "30s",
     "--health-timeout",
@@ -15721,8 +15790,11 @@ x-litellm-tags: service:hindsight`);
     "--health-start-period",
     "60s"
   ];
-  if (litellm) {
+  if (hindsightNeedsHostNetwork(llm, litellm)) {
     args.push("--network", "host");
+    if (!litellm) {
+      envArgs.push("-e", `HINDSIGHT_API_PORT=${apiPort}`, "-e", `HINDSIGHT_CP_DATAPLANE_API_URL=http://localhost:${apiPort}`);
+    }
   } else {
     args.push("-p", `127.0.0.1:${apiPort}:8888`, "-p", `127.0.0.1:${uiPort}:9999`);
   }
@@ -15744,13 +15816,40 @@ x-litellm-tags: service:hindsight`);
   }
   execFileSync("docker", args, { stdio: "pipe" });
 }
-function stopHindsight() {
-  try {
-    execFileSync("docker", ["stop", "switchroom-hindsight"], { stdio: "pipe" });
-  } catch {}
+function listHindsightDataVolumeMounts(exec = (cmd, args) => execFileSync(cmd, args, { stdio: "pipe", encoding: "utf-8" })) {
   try {
-    execFileSync("docker", ["rm", "switchroom-hindsight"], { stdio: "pipe" });
-  } catch {}
+    const out = exec("docker", [
+      "ps",
+      "-a",
+      "--filter",
+      `volume=${HINDSIGHT_DATA_VOLUME}`,
+      "--format",
+      "{{.Names}}"
+    ]);
+    return out.split(`
+`).map((l) => l.trim()).filter((n) => n.length > 0);
+  } catch {
+    return [];
+  }
+}
+function stopHindsight(exec = (cmd, args) => {
+  execFileSync(cmd, args, { stdio: "pipe" });
+}, listMounts = () => listHindsightDataVolumeMounts()) {
+  const names = new Set([HINDSIGHT_DEFAULT_WORKER_ID, ...listMounts()]);
+  for (const name of names) {
+    if (name !== HINDSIGHT_DEFAULT_WORKER_ID) {
+      console.error(`stopHindsight: removing hindsight data-volume twin ${name} (not the canonical ${HINDSIGHT_DEFAULT_WORKER_ID})`);
+    }
+    try {
+      exec("docker", ["update", "--restart=no", name]);
+    } catch {}
+    try {
+      exec("docker", ["stop", name]);
+    } catch {}
+    try {
+      exec("docker", ["rm", "-f", name]);
+    } catch {}
+  }
 }
 function pullHindsightImage(imageTag) {
   execFileSync("docker", ["pull", hindsightImageRef(imageTag)], { stdio: "inherit" });
@@ -15808,17 +15907,30 @@ function getHindsightStatus() {
     return null;
   }
 }
-function generateHindsightComposeSnippet(llm, mirrorDir) {
-  const { provider: llmProvider, model: llmModel } = resolveHindsightLlm(llm);
+function generateHindsightComposeSnippet(llm, mirrorDir, litellm) {
+  const { provider: llmProvider, model: llmModel } = resolveHindsightLlm(llm, litellm);
   const perOpLlm = resolveHindsightPerOpLlm(llm);
+  const hostNetwork = hindsightNeedsHostNetwork(llm, litellm);
+  const apiPort = HINDSIGHT_DEFAULT_API_PORT;
+  const internalApiPort = hostNetwork ? apiPort : 8888;
+  const probeUrl = pickHindsightLiteLlmProbeUrl(llm, litellm);
+  const healthPy = probeUrl ? buildLiteLlmAwareHealthPy(internalApiPort, probeUrl) : HINDSIGHT_HEALTHCHECK_PY;
   const environment = [
     `      - HINDSIGHT_API_MAX_OBSERVATIONS_PER_SCOPE=${HINDSIGHT_DEFAULT_MAX_OBSERVATIONS_PER_SCOPE}`,
     `      - HINDSIGHT_API_LLM_PROVIDER=${llmProvider}`,
     `      - HINDSIGHT_API_LLM_MODEL=${llmModel}`,
     ...perOpLlm.map(([k, v]) => `      - ${k}=${v}`),
     ...llmProvider === "claude-code" ? [`      - ANTHROPIC_MODEL=${llmModel}`] : [],
-    `      - HINDSIGHT_CP_DATAPLANE_API_URL=http://localhost:8888`
+    ...hostNetwork ? [
+      `      - HINDSIGHT_API_PORT=${apiPort}`,
+      `      - HINDSIGHT_CP_DATAPLANE_API_URL=http://localhost:${apiPort}`
+    ] : [`      - HINDSIGHT_CP_DATAPLANE_API_URL=http://localhost:8888`]
   ];
+  if (litellm?.baseUrl?.trim() && litellm.apiKey?.trim()) {
+    const litellmRoot = litellm.baseUrl.replace(/\/+$/, "");
+    const anthropicBaseUrl = isClaudeModel(llmModel) ? `${litellmRoot}/anthropic` : litellmRoot;
+    environment.push(`      - ANTHROPIC_BASE_URL=${anthropicBaseUrl}`, `      - ANTHROPIC_CUSTOM_HEADERS=x-litellm-api-key: Bearer ${litellm.apiKey}\\nx-litellm-customer-id: hindsight\\nx-litellm-tags: service:hindsight`);
+  }
   const initService = mirrorDir ? [
     "  switchroom-hindsight-creds-init:",
     `    image: ${HINDSIGHT_IMAGE}`,
@@ -15835,6 +15947,13 @@ function generateHindsightComposeSnippet(llm, mirrorDir) {
     "      switchroom-hindsight-creds-init:",
     "        condition: service_completed_successfully"
   ] : [];
+  const networkOrPorts = hostNetwork ? [
+    "    network_mode: host"
+  ] : [
+    "    ports:",
+    `      - "127.0.0.1:${HINDSIGHT_DEFAULT_API_PORT}:8888"`,
+    '      - "127.0.0.1:19999:9999"'
+  ];
   return [
     "services:",
     ...initService,
@@ -15842,9 +15961,7 @@ function generateHindsightComposeSnippet(llm, mirrorDir) {
     `    image: ${HINDSIGHT_IMAGE}`,
     "    container_name: switchroom-hindsight",
     ...dependsOn,
-    "    ports:",
-    `      - "127.0.0.1:${HINDSIGHT_DEFAULT_API_PORT}:8888"`,
-    '      - "127.0.0.1:19999:9999"',
+    ...networkOrPorts,
     "    environment:",
     ...environment,
     `      - HINDSIGHT_API_MCP_STATELESS=${HINDSIGHT_DEFAULT_MCP_STATELESS}`,
@@ -15857,12 +15974,13 @@ function generateHindsightComposeSnippet(llm, mirrorDir) {
     `      - HINDSIGHT_API_WORKER_CONSOLIDATION_MAX_SLOTS=${HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_SLOTS}`,
     `      - HINDSIGHT_API_CONSOLIDATION_LLM_PARALLELISM=${HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_PARALLELISM}`,
     `      - HINDSIGHT_API_CONSOLIDATION_MAX_MEMORIES_PER_ROUND=${HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND}`,
+    `      - HINDSIGHT_API_WORKER_ID=${HINDSIGHT_DEFAULT_WORKER_ID}`,
     `    mem_limit: ${HINDSIGHT_DEFAULT_MEM_LIMIT}`,
     `    mem_reservation: ${HINDSIGHT_DEFAULT_MEM_RESERVATION}`,
     `    pids_limit: ${HINDSIGHT_DEFAULT_PIDS_LIMIT}`,
     `    shm_size: ${HINDSIGHT_DEFAULT_SHM_SIZE}`,
     "    healthcheck:",
-    `      test: ${JSON.stringify(["CMD", "python3", "-c", HINDSIGHT_HEALTHCHECK_PY])}`,
+    `      test: ${JSON.stringify(["CMD", "python3", "-c", healthPy])}`,
     "      interval: 30s",
     "      timeout: 5s",
     "      retries: 3",
@@ -15946,7 +16064,7 @@ async function ensureHindsightConsumer(configPath, account, uid = HINDSIGHT_DEFA
   atomicWriteFileSync2(configPath, tail, mode);
   return { added: true, reason: "added" };
 }
-var HINDSIGHT_DEFAULT_API_PORT = 18888, HINDSIGHT_DEFAULT_UI_PORT = 9999, HINDSIGHT_DEFAULT_MCP_URL, HINDSIGHT_DEFAULT_API_BASE_URL, HINDSIGHT_DEFAULT_MAX_OBSERVATIONS_PER_SCOPE = 1000, HINDSIGHT_CONSUMER_NAME = "hindsight", HINDSIGHT_DEFAULT_UID = 11000, HINDSIGHT_IMAGE_REPO = "ghcr.io/switchroom/switchroom-hindsight", HINDSIGHT_IMAGE, HINDSIGHT_DEFAULT_MODEL = "claude-sonnet-5", HINDSIGHT_DEFAULT_LITELLM_MODEL = "openrouter/google/gemini-3.1-flash-lite", HINDSIGHT_DEFAULT_MCP_STATELESS = true, HINDSIGHT_BROKER_SOCK_VOLUME, HINDSIGHT_CREDS_MIRROR_VOLUME, HINDSIGHT_CRED_DIR = "/run/claude-creds", HINDSIGHT_DEFAULT_RERANKER_BUCKET_BATCHING = "true", HINDSIGHT_DEFAULT_RERANKER_MAX_CANDIDATES = 150, HINDSIGHT_DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT = 4, HINDSIGHT_DEFAULT_RECALL_MAX_CONCURRENT = 8, HINDSIGHT_DEFAULT_REFLECT_WALL_TIMEOUT_S = 600, HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_BATCH_SIZE = 12, HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_SLOTS = 1, HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_PARALLELISM = 2, HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND = 100, HINDSIGHT_DEFAULT_MEM_LIMIT = "8g", HINDSIGHT_DEFAULT_MEM_RESERVATION = "4g", HINDSIGHT_DEFAULT_PIDS_LIMIT = 1000, HINDSIGHT_DEFAULT_SHM_SIZE = "2g", HINDSIGHT_HEALTHCHECK_PY = 'import urllib.request,sys; sys.exit(0 if urllib.request.urlopen("http://localhost:8888/health",timeout=4).getcode()==200 else 1)', HINDSIGHT_HEALTHCHECK_CMD, HINDSIGHT_LLM_OPS;
+var HINDSIGHT_DEFAULT_API_PORT = 18888, HINDSIGHT_DEFAULT_UI_PORT = 9999, HINDSIGHT_DEFAULT_MCP_URL, HINDSIGHT_DEFAULT_API_BASE_URL, HINDSIGHT_DEFAULT_MAX_OBSERVATIONS_PER_SCOPE = 1000, HINDSIGHT_CONSUMER_NAME = "hindsight", HINDSIGHT_DEFAULT_WORKER_ID = "switchroom-hindsight", HINDSIGHT_DATA_VOLUME = "switchroom-hindsight-data", HINDSIGHT_DEFAULT_UID = 11000, HINDSIGHT_IMAGE_REPO = "ghcr.io/switchroom/switchroom-hindsight", HINDSIGHT_IMAGE, HINDSIGHT_DEFAULT_MODEL = "claude-sonnet-5", HINDSIGHT_DEFAULT_LITELLM_MODEL = "openrouter/google/gemini-3.1-flash-lite", HINDSIGHT_DEFAULT_MCP_STATELESS = true, HINDSIGHT_BROKER_SOCK_VOLUME, HINDSIGHT_CREDS_MIRROR_VOLUME, HINDSIGHT_CRED_DIR = "/run/claude-creds", HINDSIGHT_DEFAULT_RERANKER_BUCKET_BATCHING = "true", HINDSIGHT_DEFAULT_RERANKER_MAX_CANDIDATES = 150, HINDSIGHT_DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT = 4, HINDSIGHT_DEFAULT_RECALL_MAX_CONCURRENT = 8, HINDSIGHT_DEFAULT_REFLECT_WALL_TIMEOUT_S = 600, HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_BATCH_SIZE = 12, HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_SLOTS = 1, HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_PARALLELISM = 2, HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND = 100, HINDSIGHT_DEFAULT_MEM_LIMIT = "8g", HINDSIGHT_DEFAULT_MEM_RESERVATION = "4g", HINDSIGHT_DEFAULT_PIDS_LIMIT = 1000, HINDSIGHT_DEFAULT_SHM_SIZE = "2g", HINDSIGHT_HEALTHCHECK_PY = 'import urllib.request,sys; sys.exit(0 if urllib.request.urlopen("http://localhost:8888/health",timeout=4).getcode()==200 else 1)', HINDSIGHT_HEALTHCHECK_CMD, HINDSIGHT_LLM_OPS;
 var init_hindsight = __esm(() => {
   init_model_command();
   HINDSIGHT_DEFAULT_MCP_URL = `http://127.0.0.1:${HINDSIGHT_DEFAULT_API_PORT}/mcp/`;
@@ -16509,7 +16627,7 @@ var HINDSIGHT_SHIM_CLI_PATH = "/usr/local/bin/switchroom", HINDSIGHT_SHIM_AGENT_
 var init_hindsight2 = __esm(() => {
   init_users();
   init_hindsight();
-  DEFAULT_RETAIN_MISSION = "Extract user preferences, ongoing projects, recurring commitments, " + "important context, and durable facts that should help across future " + "conversations. Skip one-off chatter and temporary task noise.";
+  DEFAULT_RETAIN_MISSION = "Extract user preferences, ongoing projects, recurring commitments, " + "important context, and durable facts that should help across future " + "conversations. Skip one-off chatter and temporary task noise, " + "including in-flight workflow/process narration (a sub-task started, " + "paused, or is still running) \u2014 only retain the outcome once a task " + "actually completes or a decision is made.";
   PROFILE_MEMORY_DEFAULTS = {
     "health-coach": {
       disposition: { skepticism: 2, literalism: 2, empathy: 5 },
@@ -30033,11 +30151,25 @@ function generateCompose(opts) {
     lines.push(`      SWITCHROOM_CONFIG: /state/config/switchroom.yaml`);
   }
   lines.push(`      SWITCHROOM_AUTH_BROKER_STATE_DIR: /state/auth-broker`);
+  let authBrokerNeedsHostGateway = false;
+  {
+    const llBase = config.litellm?.base_url;
+    if (typeof llBase === "string" && llBase.trim()) {
+      const raw = llBase.trim().replace(/\/+$/, "");
+      const bridged = raw.replace(/^http:\/\/127\.0\.0\.1(?=[:/]|$)/i, "http://host.docker.internal").replace(/^http:\/\/localhost(?=[:/]|$)/i, "http://host.docker.internal").replace(/^https:\/\/127\.0\.0\.1(?=[:/]|$)/i, "https://host.docker.internal").replace(/^https:\/\/localhost(?=[:/]|$)/i, "https://host.docker.internal");
+      lines.push(`      SWITCHROOM_LITELLM_BASE: ${JSON.stringify(bridged)}`);
+      authBrokerNeedsHostGateway = true;
+    }
+  }
   lines.push(`      SWITCHROOM_ACCOUNTS_DIR: /state/accounts`);
   lines.push(`      SWITCHROOM_AGENTS_DIR: /state/agents`);
   if (opts.operatorUid !== undefined) {
     lines.push(`      SWITCHROOM_AUTH_BROKER_OPERATOR_UID: "${opts.operatorUid}"`);
   }
+  if (authBrokerNeedsHostGateway) {
+    lines.push(`    extra_hosts:`);
+    lines.push(`      - "host.docker.internal:host-gateway"`);
+  }
   lines.push(`    volumes:`);
   for (const a of describeAgents(config, opts.litellmConfirmedAgents)) {
     lines.push(`      - auth-broker-${a.name}-sock:/run/switchroom/auth-broker/${a.name}`);
@@ -32692,7 +32824,7 @@ function decodeResponse2(line) {
   }
   return ResponseSchema2.parse(parsed);
 }
-var MAX_FRAME_BYTES2, PROTOCOL_VERSION = 1, ProviderNameSchema, GetCredentialsRequestSchema, ListStateRequestSchema, SetActiveRequestSchema, MarkExhaustedRequestSchema, MarkThrottledRequestSchema, RefreshAccountRequestSchema, AnthropicCredentialsSchema, GoogleCredentialsSchema, MicrosoftCredentialsSchema, ProviderCredentialsSchema, AddAccountRequestSchema, RmAccountRequestSchema, SetOverrideRequestSchema, ListGoogleAccountsRequestSchema, ListMicrosoftAccountsRequestSchema, ProbeQuotaRequestSchema, ClaimNotificationRequestSchema, RequestSchema2, GetCredentialsDataSchema, AccountStateSchema, AgentStateSchema, ConsumerStateSchema, ListStateDataSchema, SetActiveDataSchema, MarkExhaustedDataSchema, MarkThrottledDataSchema, RefreshAccountDataSchema, AddAccountDataSchema, RmAccountDataSchema, SetOverrideDataSchema, ClaimNotificationDataSchema, GoogleAccountStateSchema, ListGoogleAccountsDataSchema, MicrosoftAccountStateSchema, ListMicrosoftAccountsDataSchema, ErrorBodySchema, SuccessResponseSchema, ErrorResponseSchema2, ResponseSchema2;
+var MAX_FRAME_BYTES2, PROTOCOL_VERSION = 1, ProviderNameSchema, GetCredentialsRequestSchema, ListStateRequestSchema, SetActiveRequestSchema, MarkExhaustedRequestSchema, MarkThrottledRequestSchema, RefreshAccountRequestSchema, AnthropicCredentialsSchema, GoogleCredentialsSchema, MicrosoftCredentialsSchema, ProviderCredentialsSchema, AddAccountRequestSchema, RmAccountRequestSchema, SetOverrideRequestSchema, ListGoogleAccountsRequestSchema, ListMicrosoftAccountsRequestSchema, ProbeQuotaRequestSchema, ClaimNotificationRequestSchema, GetExternalSpendRequestSchema, RequestSchema2, GetCredentialsDataSchema, AccountStateSchema, AgentStateSchema, ConsumerStateSchema, ListStateDataSchema, SetActiveDataSchema, MarkExhaustedDataSchema, MarkThrottledDataSchema, RefreshAccountDataSchema, AddAccountDataSchema, RmAccountDataSchema, SetOverrideDataSchema, ClaimNotificationDataSchema, GetExternalSpendDataSchema, GoogleAccountStateSchema, ListGoogleAccountsDataSchema, MicrosoftAccountStateSchema, ListMicrosoftAccountsDataSchema, ErrorBodySchema, SuccessResponseSchema, ErrorResponseSchema2, ResponseSchema2;
 var init_protocol2 = __esm(() => {
   init_zod();
   MAX_FRAME_BYTES2 = 64 * 1024;
@@ -32823,6 +32955,12 @@ var init_protocol2 = __esm(() => {
     key: exports_external.string().min(1).max(512),
     windowMs: exports_external.number().int().positive().max(86400000)
   });
+  GetExternalSpendRequestSchema = exports_external.object({
+    v: exports_external.literal(PROTOCOL_VERSION),
+    op: exports_external.literal("get-external-spend"),
+    id: exports_external.string().min(1),
+    forceLive: exports_external.boolean().optional()
+  });
   RequestSchema2 = exports_external.discriminatedUnion("op", [
     GetCredentialsRequestSchema,
     ListStateRequestSchema,
@@ -32836,7 +32974,8 @@ var init_protocol2 = __esm(() => {
     ListGoogleAccountsRequestSchema,
     ListMicrosoftAccountsRequestSchema,
     ProbeQuotaRequestSchema,
-    ClaimNotificationRequestSchema
+    ClaimNotificationRequestSchema,
+    GetExternalSpendRequestSchema
   ]);
   GetCredentialsDataSchema = exports_external.object({
     account: exports_external.string(),
@@ -32903,6 +33042,18 @@ var init_protocol2 = __esm(() => {
   ClaimNotificationDataSchema = exports_external.object({
     granted: exports_external.boolean()
   });
+  GetExternalSpendDataSchema = exports_external.object({
+    available: exports_external.boolean(),
+    day24hUsd: exports_external.number().optional(),
+    day7dUsd: exports_external.number().optional(),
+    top: exports_external.array(exports_external.object({
+      label: exports_external.string(),
+      usd: exports_external.number()
+    })).optional(),
+    capturedAtMs: exports_external.number().int().nonnegative().optional(),
+    served: exports_external.enum(["live", "cache"]).optional(),
+    reason: exports_external.string().optional()
+  });
   GoogleAccountStateSchema = exports_external.object({
     account: exports_external.string(),
     expiresAt: exports_external.number(),
@@ -33073,6 +33224,15 @@ class AuthBrokerClient {
     }
     return parsed;
   }
+  async getExternalSpend(forceLive) {
+    const data = await this.send({
+      v: PROTOCOL_VERSION,
+      id: randomUUID(),
+      op: "get-external-spend",
+      ...forceLive ? { forceLive: true } : {}
+    });
+    return data;
+  }
   async setActive(account) {
     const data = await this.send({
       v: PROTOCOL_VERSION,
@@ -41964,9 +42124,124 @@ function classifyAutohealStatus(logs) {
   }
   return { name: "hindsight autoheal", status: "ok", detail: "no auto-restarts" };
 }
+function classifyLlmVerification(logs) {
+  const latestFailed = new Map;
+  const failDetail = new Map;
+  let sawAny = false;
+  for (const line of logs.split(`
+`)) {
+    const fail3 = line.match(/LLM connection verification failed for '([^']+)' config:\s*(.*?)(?:\.\s*Server will start|$)/);
+    if (fail3) {
+      sawAny = true;
+      const cfg = fail3[1];
+      latestFailed.set(cfg, true);
+      failDetail.set(cfg, (fail3[2] ?? "").trim());
+      continue;
+    }
+    if (/connection verified successfully/.test(line) || /LLM verification passed/.test(line)) {
+      sawAny = true;
+      latestFailed.set("default", false);
+    }
+  }
+  if (!sawAny)
+    return null;
+  const failedConfigs = [...latestFailed.entries()].filter(([, failed]) => failed).map(([cfg]) => cfg);
+  if (failedConfigs.length === 0) {
+    return {
+      name: "hindsight LLM verification",
+      status: "ok",
+      detail: "boot LLM connection verified"
+    };
+  }
+  const named = failedConfigs.map((cfg) => {
+    const err = failDetail.get(cfg);
+    return err ? `'${cfg}' (${err})` : `'${cfg}'`;
+  }).join(", ");
+  return {
+    name: "hindsight LLM verification",
+    status: "fail",
+    detail: `boot LLM connection verification FAILED for config(s): ${named} \u2014 ` + `hindsight is serving but every LLM-dependent op (retain/reflect/` + `consolidation extraction) for that config will fail silently until the ` + `provider is reachable`,
+    fix: "Almost always a model-name drift: the pinned `hindsight.llm.*.model` no " + "longer exists in the LiteLLM proxy's model_list (run `switchroom doctor` " + "\u2014 the LiteLLM model-routing check names the exact missing model), or the " + "provider is down. Fix the model reference (or the proxy), then " + "`switchroom memory --restart` so hindsight re-verifies."
+  };
+}
+function classifyHindsightDataVolumeMounts(names) {
+  const uniq = [...new Set(names.filter(Boolean))];
+  if (uniq.length === 0) {
+    return {
+      name: "hindsight data-volume exclusive",
+      status: "ok",
+      detail: "no container currently mounts the live data volume"
+    };
+  }
+  const twins = uniq.filter((n) => n !== HINDSIGHT_DEFAULT_WORKER_ID);
+  if (uniq.length === 1 && uniq[0] === HINDSIGHT_DEFAULT_WORKER_ID) {
+    return {
+      name: "hindsight data-volume exclusive",
+      status: "ok",
+      detail: `only ${HINDSIGHT_DEFAULT_WORKER_ID} mounts ${HINDSIGHT_DATA_VOLUME}`
+    };
+  }
+  if (twins.length > 0) {
+    return {
+      name: "hindsight data-volume exclusive",
+      status: "fail",
+      detail: `multiple containers mount ${HINDSIGHT_DATA_VOLUME}: [${uniq.join(", ")}] \u2014 ` + `dual postmasters corrupt the embedded PG checkpoint`,
+      fix: "`switchroom memory --restart` (stopHindsight now disables restart + removes " + "every volume twin), or manually `docker update --restart=no <twin> && " + "docker rm -f <twin>` before starting the live container."
+    };
+  }
+  return {
+    name: "hindsight data-volume exclusive",
+    status: "warn",
+    detail: `unexpected volume mount set: [${uniq.join(", ")}]`
+  };
+}
+function classifyHindsightNetworkMode(networkMode, litellmConfigured) {
+  if (!litellmConfigured) {
+    return {
+      name: "hindsight network mode",
+      status: "ok",
+      detail: networkMode ? `${networkMode} (LiteLLM not configured)` : "unknown (LiteLLM not configured)"
+    };
+  }
+  const mode = (networkMode ?? "").trim() || "unknown";
+  if (mode === "host") {
+    return {
+      name: "hindsight network mode",
+      status: "ok",
+      detail: "host \u2014 LiteLLM 127.0.0.1 reachable"
+    };
+  }
+  return {
+    name: "hindsight network mode",
+    status: "fail",
+    detail: `NetworkMode=${mode} while LiteLLM routing is configured \u2014 retains will die with ` + `"Connection error" to 127.0.0.1:4010 while /health stays green`,
+    fix: "`switchroom memory --restart` so startHindsight recreates with --network host. " + "Do not `docker start` a bridge/mis-networked container."
+  };
+}
+function classifyLiteLlmReachability(reachable, endpoint) {
+  if (reachable === null)
+    return null;
+  if (reachable) {
+    return {
+      name: "hindsight LiteLLM reachability",
+      status: "ok",
+      detail: `TCP ok to ${endpoint}`
+    };
+  }
+  return {
+    name: "hindsight LiteLLM reachability",
+    status: "fail",
+    detail: `cannot TCP-connect to ${endpoint} \u2014 hindsight LLM ops will fail`,
+    fix: "Start/fix the LiteLLM proxy (host :4010), then `switchroom memory --restart` " + "if hindsight was started while it was down."
+  };
+}
 function checkHindsightContainerHealth(opts) {
   const name = opts?.containerName ?? "switchroom-hindsight";
-  const exec = opts?.exec ?? ((cmd, args) => execFileSync18(cmd, args, { stdio: ["ignore", "pipe", "ignore"], timeout: 8000 }).toString());
+  const exec = opts?.exec ?? ((cmd, args) => execFileSync18(cmd, args, {
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: 8000,
+    maxBuffer: 16 * 1024 * 1024
+  }).toString());
   const results = [];
   let shmRaw;
   try {
@@ -41978,6 +42253,29 @@ function checkHindsightContainerHealth(opts) {
   if (Number.isFinite(shmBytes) && shmBytes > 0) {
     results.push(classifyShmSize(shmBytes));
   }
+  try {
+    const startedAt = exec("docker", [
+      "inspect",
+      name,
+      "--format",
+      "{{.State.StartedAt}}"
+    ]).trim();
+    const startMs = Date.parse(startedAt);
+    if (Number.isFinite(startMs)) {
+      const untilIso = new Date(startMs + 10 * 60000).toISOString();
+      const bootLogs = exec("docker", [
+        "logs",
+        "--since",
+        startedAt,
+        "--until",
+        untilIso,
+        name
+      ]);
+      const verifyRow = classifyLlmVerification(bootLogs);
+      if (verifyRow)
+        results.push(verifyRow);
+    }
+  } catch {}
   try {
     const logs = exec("docker", ["logs", "--since", "10m", name]);
     results.push(classifyExtractionLogs(logs));
@@ -41986,6 +42284,69 @@ function checkHindsightContainerHealth(opts) {
     const autohealLogs = exec("docker", ["logs", "--since", "1h", "switchroom-hindsight-autoheal"]);
     results.push(classifyAutohealStatus(autohealLogs));
   } catch {}
+  try {
+    const mounts = listHindsightDataVolumeMounts(exec);
+    results.push(classifyHindsightDataVolumeMounts(mounts));
+  } catch {}
+  try {
+    const netMode = exec("docker", [
+      "inspect",
+      name,
+      "--format",
+      "{{.HostConfig.NetworkMode}}"
+    ]).trim();
+    const envBlob = exec("docker", [
+      "inspect",
+      name,
+      "--format",
+      "{{range .Config.Env}}{{println .}}{{end}}"
+    ]);
+    const perOpBasePresent = /HINDSIGHT_API_(RETAIN|REFLECT|CONSOLIDATION)_LLM_BASE_URL=/.test(envBlob);
+    const anthropicBaseMatch = envBlob.match(/(?:^|\n)ANTHROPIC_BASE_URL=(\S+)/);
+    const anthropicLooksLikeLiteLlm = (() => {
+      const raw = anthropicBaseMatch?.[1]?.trim();
+      if (!raw)
+        return false;
+      try {
+        const u = new URL(raw.includes("://") ? raw : `http://${raw}`);
+        const port = u.port || (u.protocol === "https:" ? "443" : "80");
+        const path5 = (u.pathname || "").replace(/\/+$/, "");
+        if (port === "4010")
+          return true;
+        if (/\/anthropic$/i.test(path5))
+          return true;
+        if (/litellm/i.test(u.hostname || ""))
+          return true;
+        return false;
+      } catch {
+        return false;
+      }
+    })();
+    const litellmConfigured = perOpBasePresent || anthropicLooksLikeLiteLlm;
+    results.push(classifyHindsightNetworkMode(netMode, litellmConfigured));
+    if (litellmConfigured) {
+      const m = envBlob.match(/HINDSIGHT_API_RETAIN_LLM_BASE_URL=(\S+)/) ?? envBlob.match(/HINDSIGHT_API_REFLECT_LLM_BASE_URL=(\S+)/) ?? envBlob.match(/HINDSIGHT_API_CONSOLIDATION_LLM_BASE_URL=(\S+)/) ?? (anthropicLooksLikeLiteLlm ? anthropicBaseMatch : null);
+      let endpoint = "127.0.0.1:4010";
+      if (m) {
+        try {
+          const u = new URL(m[1].includes("://") ? m[1] : `http://${m[1]}`);
+          endpoint = `${u.hostname || "127.0.0.1"}:${u.port || "80"}`;
+        } catch {}
+      }
+      const [host, portStr] = endpoint.split(":");
+      const port = Number(portStr) || 80;
+      let reachable = null;
+      try {
+        exec("bash", ["-c", `echo > /dev/tcp/${host}/${port}`]);
+        reachable = true;
+      } catch {
+        reachable = false;
+      }
+      const row = classifyLiteLlmReachability(reachable, endpoint);
+      if (row)
+        results.push(row);
+    }
+  } catch {}
   return results;
 }
 function classifyHindsightHealthProbe(status, port) {
@@ -42076,9 +42437,142 @@ function classifyToolContract(advertised) {
 var MIN_HINDSIGHT_SHM_BYTES, CONSOLIDATION_BACKLOG_WARN = 25, CONSOLIDATION_BACKLOG_FAIL = 200;
 var init_doctor_memory = __esm(() => {
   init_hindsight_tools();
+  init_hindsight();
   MIN_HINDSIGHT_SHM_BYTES = 1024 * 1024 * 1024;
 });
 
+// src/litellm/model-validation.ts
+function isExplicitLitellmRoute(model) {
+  return model.includes("/");
+}
+function collectReferencedModels(config) {
+  const refs = [];
+  const litellmEnabled = config.litellm?.enabled === true;
+  if (!litellmEnabled)
+    return refs;
+  const llm = config.hindsight?.llm;
+  if (llm) {
+    const push = (model, consumer) => {
+      if (model)
+        refs.push({ model, consumer });
+    };
+    push(llm.model, "hindsight.llm.model (global)");
+    push(llm.retain?.model, "hindsight.llm.retain");
+    push(llm.reflect?.model, "hindsight.llm.reflect");
+    push(llm.consolidation?.model, "hindsight.llm.consolidation");
+  }
+  for (const [name, agent] of Object.entries(config.agents ?? {})) {
+    if (!agent)
+      continue;
+    const agentRoutes = agent.litellm?.enabled !== false;
+    if (!agentRoutes)
+      continue;
+    if (agent.model && isExplicitLitellmRoute(agent.model)) {
+      refs.push({ model: agent.model, consumer: `agents.${name}.model` });
+    }
+    if (agent.fallback_model && isExplicitLitellmRoute(agent.fallback_model)) {
+      refs.push({ model: agent.fallback_model, consumer: `agents.${name}.fallback_model` });
+    }
+  }
+  return refs;
+}
+function validateModelReferences(refs, proxyModels) {
+  const missing = new Map;
+  for (const { model, consumer } of refs) {
+    if (proxyModels.has(model))
+      continue;
+    const list = missing.get(model);
+    if (list) {
+      if (!list.includes(consumer))
+        list.push(consumer);
+    } else {
+      missing.set(model, [consumer]);
+    }
+  }
+  return [...missing.entries()].map(([model, consumers]) => ({ model, consumers }));
+}
+async function fetchProxyModels(baseUrl, apiKey, fetchFn = fetch, timeoutMs = 8000) {
+  const url = `${baseUrl.replace(/\/+$/, "")}/v1/models`;
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetchFn(url, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${apiKey}` },
+      ...{ signal: controller.signal }
+    });
+    if (!res.ok) {
+      return { kind: "unreachable", msg: `proxy returned HTTP ${res.status} for ${url}` };
+    }
+    const body = await res.json();
+    const data = body?.data;
+    if (!Array.isArray(data)) {
+      return { kind: "unreachable", msg: `proxy ${url} response had no model \`data\` array` };
+    }
+    const models = data.map((m) => m?.id).filter((id) => typeof id === "string");
+    return { kind: "ok", models };
+  } catch (err) {
+    return { kind: "unreachable", msg: err.message ?? String(err) };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function classifyModelReferences(missing, refCount) {
+  if (missing.length === 0) {
+    return {
+      name: "litellm model routing",
+      status: "ok",
+      detail: `all ${refCount} referenced model(s) present in the proxy model_list`
+    };
+  }
+  const detail = missing.map((m) => `\`${m.model}\` (referenced by ${m.consumers.join(", ")})`).join("; ");
+  return {
+    name: "litellm model routing",
+    status: "fail",
+    detail: `${missing.length} model reference(s) NOT in the LiteLLM proxy model_list: ` + `${detail} \u2014 every LLM call from that consumer will 400 ("Invalid model ` + `name") until the proxy lists it or the reference is corrected`,
+    fix: "Either add the missing model group back to the LiteLLM proxy config " + "(the operator-maintained `litellm-config.yaml` `model_list`) and redeploy " + "the proxy, or repoint the consumer at a model the proxy DOES route " + "(`switchroom doctor` lists them via the proxy `/v1/models`). For " + "hindsight, then `switchroom memory --restart` so it re-verifies."
+  };
+}
+async function runLitellmModelChecks(config, opts) {
+  const refs = collectReferencedModels(config);
+  if (refs.length === 0)
+    return [];
+  const litellm = config.litellm;
+  const baseUrl = litellm?.base_url;
+  const adminKeyRef = litellm?.admin_key;
+  if (!baseUrl || !adminKeyRef) {
+    return [
+      {
+        name: "litellm model routing",
+        status: "warn",
+        detail: `${refs.length} model reference(s) to validate but litellm ` + `${!baseUrl ? "base_url" : "admin_key"} is unresolved \u2014 cannot query ` + `the proxy model_list`
+      }
+    ];
+  }
+  const apiKey = opts.resolveSecret(adminKeyRef);
+  if (!apiKey) {
+    return [
+      {
+        name: "litellm model routing",
+        status: "warn",
+        detail: `could not resolve the litellm admin_key (\`${adminKeyRef}\`) to query ` + `the proxy model_list \u2014 ${refs.length} model reference(s) left unverified`
+      }
+    ];
+  }
+  const probe2 = await fetchProxyModels(baseUrl, apiKey, opts.fetchFn);
+  if (probe2.kind === "unreachable") {
+    return [
+      {
+        name: "litellm model routing",
+        status: "warn",
+        detail: `LiteLLM proxy unreachable (${probe2.msg}) \u2014 ${refs.length} model ` + `reference(s) left unverified; not failing on an environment limitation`
+      }
+    ];
+  }
+  const missing = validateModelReferences(refs, new Set(probe2.models));
+  return [classifyModelReferences(missing, refs.length)];
+}
+
 // src/cli/doctor-docker.ts
 import { readFileSync as readFileSync56 } from "node:fs";
 import { spawnSync as spawnSync8 } from "node:child_process";
@@ -45289,6 +45783,7 @@ __export(exports_doctor, {
   checkTelegram: () => checkTelegram,
   checkTcp: () => checkTcp,
   checkStartShStale: () => checkStartShStale,
+  checkStartShSessionModelCarrier: () => checkStartShSessionModelCarrier,
   checkSkillsPrerequisites: () => checkSkillsPrerequisites,
   checkRepoHygiene: () => checkRepoHygiene,
   checkPendingRetainsQueues: () => checkPendingRetainsQueues,
@@ -46362,6 +46857,53 @@ function checkStartShStale(agentName, startShPath) {
   }
   return { name: label, status: "ok", detail: "supervisor block present" };
 }
+function checkStartShSessionModelCarrier(agentName, startShPath) {
+  const label = `${agentName}: start.sh /model session carrier`;
+  if (!existsSync66(startShPath)) {
+    return {
+      name: label,
+      status: "warn",
+      detail: `${startShPath} not found`,
+      fix: `Run \`switchroom apply\` to scaffold start.sh (rev5 \`.session-model\` carrier).`
+    };
+  }
+  let content;
+  try {
+    content = readFileSync59(startShPath, "utf-8");
+  } catch (err) {
+    return {
+      name: label,
+      status: "skip",
+      detail: `unreadable from host (${err.message}) \u2014 agent-UID-owned; the session-model carrier block can't be checked from the operator UID`,
+      fix: `Verify in-agent: docker exec switchroom-${agentName} sh -c 'grep -E "\\[ -f .*\\.session-model\\" \\]" /state/agent/start.sh && echo ok'`
+    };
+  }
+  const fileTestPaths = [...content.matchAll(/\[\s*-f\s+([^\]]+?)\s*\]/g)].map((m) => m[1].replace(/["']/g, "").trim());
+  const hasBareSessionModelTest = fileTestPaths.some((p) => /(?:^|\/)\.session-model$/.test(p));
+  const hasJsonCarrierParse = /configuredDefaultAtWrite/.test(content) || /session-model-boot-attempts/.test(content);
+  if (hasBareSessionModelTest && hasJsonCarrierParse) {
+    return {
+      name: label,
+      status: "ok",
+      detail: "rev5 `.session-model` consume-once carrier present"
+    };
+  }
+  if (hasBareSessionModelTest && !hasJsonCarrierParse) {
+    return {
+      name: label,
+      status: "fail",
+      detail: "start.sh tests `.session-model` but lacks rev5 JSON apply (`configuredDefaultAtWrite` / boot-attempts) \u2014 /model switches may not stick",
+      fix: "Run `switchroom apply` to regenerate start.sh from profiles/_base/start.sh.hbs (rev5 carrier). Takes effect on the next agent restart (no need to bounce until release)."
+    };
+  }
+  const legacyOnly = /\.session-model-override/.test(content) && !hasBareSessionModelTest;
+  return {
+    name: label,
+    status: "fail",
+    detail: legacyOnly ? "start.sh only reads legacy `.session-model-override`; gateway writes rev5 `.session-model` \u2014 Telegram /model relaunches boot the yaml pin (silent miss)" : "start.sh missing rev5 `.session-model` carrier file test \u2014 Telegram /model cannot apply session overrides across relaunch",
+    fix: "Run `switchroom apply` to regenerate start.sh from the latest template (rev5 `.session-model` carrier). The rewrite is on disk immediately; session switches apply on the next agent restart/release bounce."
+  };
+}
 function checkLeakedHomeSwitchroom(agentName, agentDir) {
   const label = `${agentName}: $HOME/.switchroom symlink (#910)`;
   const path5 = join67(agentDir, "home", ".switchroom");
@@ -46491,6 +47033,7 @@ function checkAgents(config, configPath) {
       });
     }
     results.push(checkStartShStale(name, join67(agentDir, "start.sh")));
+    results.push(checkStartShSessionModelCarrier(name, join67(agentDir, "start.sh")));
     results.push(checkLeakedHomeSwitchroom(name, agentDir));
     const status = statuses[name];
     const active = status?.active ?? "unknown";
@@ -47174,6 +47717,22 @@ function registerDoctorCommand(program3) {
       },
       { title: "Vault access", results: await runSecretAccessChecks(config) },
       { title: "Memory (Hindsight)", results: await checkHindsight(config) },
+      {
+        title: "LiteLLM model routing (#3407)",
+        results: await runLitellmModelChecks(config, {
+          resolveSecret: (ref) => {
+            if (!isVaultReference(ref))
+              return ref;
+            if (!passphrase || !existsSync66(vaultPath))
+              return null;
+            try {
+              return getStringSecret(passphrase, vaultPath, parseVaultReference(ref));
+            } catch {
+              return null;
+            }
+          }
+        })
+      },
       { title: "Telegram", results: await checkTelegram(config) },
       { title: "Agents", results: checkAgents(config, configPath) },
       {
@@ -47292,6 +47851,7 @@ var init_doctor = __esm(() => {
   init_hindsight2();
   init_hindsight();
   init_doctor_memory();
+  init_resolver();
   init_doctor_docker();
   init_doctor_auth_broker();
   init_doctor_hostd();
@@ -48117,6 +48677,10 @@ function installUpdatePromptHook(agentDir) {
 var HOOK_FILENAME = "update-card-on-prompt.sh", CONTAINER_AGENT_DIR = "/state/agent";
 var init_update_prompt_hook = () => {};
 
+// src/litellm/external-spend.ts
+var LITELLM_MASTER_KEY_STATE_BASENAME = "litellm-master-key";
+var init_external_spend = () => {};
+
 // src/cli/install-detect.ts
 import * as fs5 from "node:fs";
 import * as path8 from "node:path";
@@ -48594,6 +49158,7 @@ __export(exports_apply, {
   provisionLiteLLMKeys: () => provisionLiteLLMKeys,
   probeVaultProvisioning: () => probeVaultProvisioning,
   parseComposeServiceNames: () => parseComposeServiceNames,
+  materializeLitellmMasterKeyForBroker: () => materializeLitellmMasterKeyForBroker,
   isInAgentContainer: () => isInAgentContainer,
   inspectVaultBindMountDir: () => inspectVaultBindMountDir,
   formatScaffoldFailureResolution: () => formatScaffoldFailureResolution,
@@ -48606,7 +49171,7 @@ __export(exports_apply, {
   DEFAULT_COMPOSE_PATH: () => DEFAULT_COMPOSE_PATH2,
   COMPOSE_PROJECT: () => COMPOSE_PROJECT2
 });
-import { accessSync as accessSync3, chownSync as chownSync8, constants as fsConstants6, copyFileSync as copyFileSync12, existsSync as existsSync86, mkdirSync as mkdirSync49, readFileSync as readFileSync74, readdirSync as readdirSync30, renameSync as renameSync20, statSync as statSync47, writeFileSync as writeFileSync31 } from "node:fs";
+import { accessSync as accessSync3, chmodSync as chmodSync14, chownSync as chownSync8, constants as fsConstants6, copyFileSync as copyFileSync12, existsSync as existsSync86, mkdirSync as mkdirSync49, readFileSync as readFileSync74, readdirSync as readdirSync30, renameSync as renameSync20, statSync as statSync47, writeFileSync as writeFileSync31 } from "node:fs";
 import { mkdir as mkdir2 } from "node:fs/promises";
 import { spawnSync as childSpawnSync } from "node:child_process";
 import readline from "node:readline";
@@ -48629,6 +49194,21 @@ async function resolveOperatorVaultPassphrase(home2) {
     return null;
   }
 }
+function materializeLitellmMasterKeyForBroker(masterKey, home2 = process.env.HOME ?? "/root") {
+  try {
+    const stateDir = join86(home2, ".switchroom", "state", "auth-broker");
+    mkdirSync49(stateDir, { recursive: true, mode: 448 });
+    const path9 = join86(stateDir, LITELLM_MASTER_KEY_STATE_BASENAME);
+    writeFileSync31(path9, masterKey.trim() + `
+`, { mode: 384 });
+    try {
+      chmodSync14(path9, 384);
+    } catch {}
+    return { ok: true, path: path9 };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
 async function provisionLiteLLMKeys(config, agentNames, switchroomConfigPath, ctx) {
   const { writeOut, failures } = ctx;
   const optedIn = [];
@@ -48644,6 +49224,7 @@ async function provisionLiteLLMKeys(config, agentNames, switchroomConfigPath, ct
   const needsHindsight = config.litellm?.enabled === true && config.memory?.backend === "hindsight";
   if (optedIn.length === 0 && !needsHindsight)
     return;
+  let brokerKeyMaterialized = false;
   const [{ getViaBrokerStructured: getViaBrokerStructured2, putViaBroker: putViaBroker2 }, { ensureTeam: ensureTeam2, ensureKey: ensureKey2, validateKey: validateKey2, bindKeyToTeam: bindKeyToTeam2 }, { addAgentSecret: addAgentSecret2 }] = await Promise.all([
     Promise.resolve().then(() => (init_client(), exports_client)),
     Promise.resolve().then(() => (init_provision(), exports_provision)),
@@ -48753,6 +49334,14 @@ async function provisionLiteLLMKeys(config, agentNames, switchroomConfigPath, ct
           masterKey = resolved.entry.value;
         }
       }
+      if (masterKey && !brokerKeyMaterialized) {
+        const mat = materializeLitellmMasterKeyForBroker(masterKey, ctx.home ?? homedir49());
+        brokerKeyMaterialized = true;
+        if (!mat.ok) {
+          ctx.writeErr(source_default.yellow(`  ! litellm: could not materialize master key for auth-broker external-spend (${mat.error})
+`));
+        }
+      }
       if (existing.kind === "ok") {
         const storedKey = existing.entry.kind === "string" ? existing.entry.value : null;
         let driftReprovision = false;
@@ -49782,6 +50371,7 @@ var init_apply = __esm(() => {
   init_connection_health();
   init_update_prompt_hook();
   init_compose();
+  init_external_spend();
   init_write_compose();
   init_profiles();
   init_install_detect();
@@ -64018,6 +64608,12 @@ var init_mapping = __esm(() => {
       severity: 1,
       job_spec: "feel-like-a-colleague",
       signature: "represent:obligation-escalation"
+    },
+    "litellm-header-passthrough-misconfig": {
+      failure_mode: "constraint-violation",
+      severity: 3,
+      job_spec: "keep-my-subscription-honest",
+      signature: "litellm-header-passthrough:oauth-leak-scope"
     }
   };
   ALL_JOB_SPECS = [
@@ -64208,6 +64804,122 @@ var init_test_agents = __esm(() => {
   ];
 });
 
+// src/litellm/header-passthrough-guard.ts
+function isClaudeAllowlistedGroup(name) {
+  if (name.endsWith("-openrouter"))
+    return false;
+  return name.startsWith("claude-") || name === "sonnet" || name === "fable";
+}
+function flagTruthy(v) {
+  return v === true || v === "true";
+}
+function* iterGroups(mgs) {
+  if (!mgs || typeof mgs !== "object")
+    return;
+  if (Array.isArray(mgs)) {
+    for (const entry of mgs) {
+      if (!entry || typeof entry !== "object")
+        continue;
+      const e = entry;
+      const name = typeof e.model_group === "string" && e.model_group || typeof e.group_name === "string" && e.group_name || typeof e.model_name === "string" && e.model_name || null;
+      if (name)
+        yield [name, e];
+    }
+    return;
+  }
+  for (const [name, settings] of Object.entries(mgs)) {
+    if (settings && typeof settings === "object") {
+      yield [name, settings];
+    }
+  }
+}
+function detectHeaderMisconfig(parsed) {
+  const violations = [];
+  if (!parsed || typeof parsed !== "object")
+    return violations;
+  const root = parsed;
+  const ls = root.litellm_settings;
+  if (ls && typeof ls === "object" && flagTruthy(ls[FORWARD_HEADERS_FLAG])) {
+    violations.push({
+      scope: "global",
+      detail: `${FORWARD_HEADERS_FLAG}: true under litellm_settings \u2014 the GLOBAL ` + `master switch forwards the subscription OAuth Authorization header ` + `to EVERY upstream (OpenRouter/OpenAI included). Scope it to Claude ` + `groups only.`
+    });
+  }
+  for (const [group, settings] of iterGroups(root.model_group_settings)) {
+    if (flagTruthy(settings[FORWARD_HEADERS_FLAG]) && !isClaudeAllowlistedGroup(group)) {
+      violations.push({
+        scope: "model_group",
+        group,
+        detail: `${FORWARD_HEADERS_FLAG}: true on non-Claude group '${group}' \u2014 ` + `forwards the subscription OAuth Authorization header to a ` + `non-subscription upstream. Remove it from this group.`
+      });
+    }
+  }
+  return violations;
+}
+function parseLitellmConfig(text) {
+  try {
+    return import_yaml26.parse(text);
+  } catch {
+    return null;
+  }
+}
+var import_yaml26, FORWARD_HEADERS_FLAG = "forward_client_headers_to_llm_api", DEFAULT_LITELLM_CONFIG_PATH = "/data/coolify/services/vhz4jc1tzvk6gdql8jueiwq4/litellm-config.yaml";
+var init_header_passthrough_guard = __esm(() => {
+  import_yaml26 = __toESM(require_dist(), 1);
+});
+
+// src/fleet-health/litellm-config-sensor.ts
+import { readFileSync as readFileSync85, existsSync as existsSync98 } from "node:fs";
+function resolveLitellmConfigPath(explicit) {
+  return explicit ?? process.env.LITELLM_CONFIG_PATH ?? DEFAULT_LITELLM_CONFIG_PATH;
+}
+function scanLitellmConfig(opts = {}) {
+  const path9 = resolveLitellmConfigPath(opts.path);
+  const exists = opts.existsFn ?? existsSync98;
+  const read = opts.readFn ?? ((p) => readFileSync85(p, "utf-8"));
+  const log = opts.log ?? (() => {});
+  const nowIso = opts.nowIso ?? new Date().toISOString();
+  if (!exists(path9)) {
+    log(`fleet-health: litellm-config sensor SKIPPED \u2014 config file absent at ${path9} ` + `(set LITELLM_CONFIG_PATH if it moved; hermetic CI/dev expected to skip)`);
+    return { status: "skipped", path: path9, findings: [] };
+  }
+  let text;
+  try {
+    text = read(path9);
+  } catch (e) {
+    log(`fleet-health: litellm-config sensor SKIPPED \u2014 ${path9} unreadable: ${String(e)}`);
+    return { status: "skipped", path: path9, findings: [] };
+  }
+  const parsed = parseLitellmConfig(text);
+  if (parsed == null) {
+    log(`fleet-health: litellm-config sensor SKIPPED \u2014 ${path9} unparseable YAML`);
+    return { status: "skipped", path: path9, findings: [] };
+  }
+  const violations = detectHeaderMisconfig(parsed);
+  if (violations.length === 0) {
+    log(`fleet-health: litellm-config sensor OK \u2014 header passthrough correctly scoped (${path9})`);
+    return { status: "ok", path: path9, findings: [] };
+  }
+  const findings = violations.map((v, i) => {
+    const where = v.scope === "global" ? "litellm_settings (global)" : `group '${v.group}'`;
+    return {
+      signal: "litellm-header-passthrough-misconfig",
+      agent: LITELLM_PROXY_PSEUDO_AGENT,
+      turn_id: `litellm-config:${v.scope}:${v.group ?? "global"}`,
+      log_pointer: `${path9}: ${where} \u2014 ${v.detail}`,
+      ts: nowIso
+    };
+  });
+  for (const f of findings) {
+    log(`fleet-health: litellm-config sensor VIOLATION \u2014 ${f.log_pointer}`);
+  }
+  return { status: "violation", path: path9, findings };
+}
+var LITELLM_PROXY_PSEUDO_AGENT = "litellm-proxy";
+var init_litellm_config_sensor = __esm(() => {
+  init_header_passthrough_guard();
+});
+
 // src/fleet-health/scan.ts
 var exports_scan = {};
 __export(exports_scan, {
@@ -64219,9 +64931,9 @@ __export(exports_scan, {
   ledgerPathForBase: () => ledgerPathForBase
 });
 import {
-  readFileSync as readFileSync85,
+  readFileSync as readFileSync86,
   readdirSync as readdirSync38,
-  existsSync as existsSync98,
+  existsSync as existsSync99,
   mkdirSync as mkdirSync56,
   writeFileSync as writeFileSync37
 } from "node:fs";
@@ -64232,7 +64944,7 @@ function resolveSwitchroomBase(home2 = process.env.SWITCHROOM_HOME ?? process.en
 }
 function listAgents(base) {
   const dir = resolve57(base, "agents");
-  if (!existsSync98(dir))
+  if (!existsSync99(dir))
     return [];
   try {
     return readdirSync38(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
@@ -64261,16 +64973,16 @@ function runScan(opts = {}) {
     let gwText = "";
     let sawArtifact = false;
     try {
-      if (existsSync98(turnsPath)) {
-        turnsText = readFileSync85(turnsPath, "utf-8");
+      if (existsSync99(turnsPath)) {
+        turnsText = readFileSync86(turnsPath, "utf-8");
         sawArtifact = true;
       }
     } catch (e) {
       log(`fleet-health: WARN skipping ${agent} turns.jsonl unreadable: ${String(e)}`);
     }
     try {
-      if (existsSync98(gwPath)) {
-        gwText = readFileSync85(gwPath, "utf-8");
+      if (existsSync99(gwPath)) {
+        gwText = readFileSync86(gwPath, "utf-8");
         sawArtifact = true;
       }
     } catch (e) {
@@ -64292,6 +65004,8 @@ function runScan(opts = {}) {
       skipped.push(agent);
     }
   }
+  const litellm = scanLitellmConfig({ path: opts.litellmConfigPath, log });
+  findings.push(...litellm.findings);
   const prior = readLedgerIfPresent(base);
   const ledger = buildLedger(findings, {
     ownerAgent: opts.ownerAgent,
@@ -64310,9 +65024,9 @@ function runScan(opts = {}) {
 function readLedgerIfPresent(base) {
   const path9 = ledgerPathForBase(base);
   try {
-    if (!existsSync98(path9))
+    if (!existsSync99(path9))
       return null;
-    return JSON.parse(readFileSync85(path9, "utf-8"));
+    return JSON.parse(readFileSync86(path9, "utf-8"));
   } catch {
     return null;
   }
@@ -64332,6 +65046,7 @@ var init_scan = __esm(() => {
   init_detect();
   init_ledger();
   init_test_agents();
+  init_litellm_config_sensor();
 });
 
 // src/cli/index.ts
@@ -78331,7 +79046,7 @@ Cross-agent reflection plan
     }
     console.log();
   }));
-  memory.command("setup").description("Manage the Hindsight Docker container").option("--stop", "Stop and remove the Hindsight container").option("--status", "Show Hindsight container status").option("--recreate", "Pull the latest image and recreate the container (reusing its current port). Used by `switchroom update` to keep the hindsight singleton current.").option("--tag <version>", "Pin the hindsight image tag to pull + run (e.g. v0.15.18), overriding the " + "default floating `:latest`. Threaded through by `switchroom rollout` so a " + "version-pinned roll recreates hindsight on the SAME tag as the rest of the " + "fleet. Omit for `:latest` (the standalone default).").option("--provider <provider>", "LLM provider (ollama, openai, anthropic)").action(async (opts) => {
+  memory.command("setup").description("Manage the Hindsight Docker container").option("--stop", "Stop and remove the Hindsight container").option("--status", "Show Hindsight container status").option("--recreate", "Pull the latest image and recreate the container (reusing its current port). Used by `switchroom update` to keep the hindsight singleton current. Also required after any `hindsight.llm` model/provider config change \u2014 env is only re-derived on recreate, a plain docker restart is not enough (see docs/operators/hindsight-model-change.md).").option("--tag <version>", "Pin the hindsight image tag to pull + run (e.g. v0.15.18), overriding the " + "default floating `:latest`. Threaded through by `switchroom rollout` so a " + "version-pinned roll recreates hindsight on the SAME tag as the rest of the " + "fleet. Omit for `:latest` (the standalone default).").option("--provider <provider>", "LLM provider (ollama, openai, anthropic)").action(async (opts) => {
     if (opts.status) {
       if (!isDockerAvailable()) {
         console.log(source_default.red("  Docker is not available."));