switchroom 0.19.0 → 0.19.2

package/dist/auth-broker/index.js

@@ -7012,14 +7012,27 @@ var require_dist = __commonJS((exports) => {
 
 // src/util/atomic.ts
 import { randomBytes } from "node:crypto";
-import { closeSync, constants, fsyncSync, openSync, renameSync, rmSync, writeSync } from "node:fs";
-function atomicWriteFileSync(destPath, contents, mode = 384) {
+import { closeSync, constants, fchmodSync, fchownSync, fsyncSync, openSync, 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 = openSync(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);
     closeSync(fd);
     fd = null;
@@ -18221,9 +18234,10 @@ import {
   chmodSync,
   chownSync as chownSync2,
   existsSync as existsSync8,
-  lstatSync,
+  lstatSync as lstatSync2,
   mkdirSync as mkdirSync5,
   readFileSync as readFileSync7,
+  realpathSync as realpathSync3,
   renameSync as renameSync3,
   rmSync as rmSync5,
   statSync as statSync6,
@@ -18233,7 +18247,7 @@ import {
 import { closeSync as closeSync2, openSync as openSync2, writeSync as writeSync2 } from "node:fs";
 import * as constants2 from "node:constants";
 import { createHash as createHash2 } from "node:crypto";
-import { dirname as dirname3, join as join8, resolve as resolve9 } from "node:path";
+import { basename as basename2, dirname as dirname3, join as join8, resolve as resolve9 } from "node:path";
 
 // src/agents/scaffold.ts
 import { join as join4, resolve as resolve5 } from "node:path";
@@ -18343,7 +18357,7 @@ var HINDSIGHT_HEALTHCHECK_PY = 'import urllib.request,sys; sys.exit(0 if urllib.
 var HINDSIGHT_HEALTHCHECK_CMD = `python3 -c '${HINDSIGHT_HEALTHCHECK_PY}'`;
 
 // src/memory/hindsight.ts
-var 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.";
+var 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) — only retain the outcome once a task " + "actually completes or a decision is made.";
 var PROFILE_MEMORY_DEFAULTS = {
   "health-coach": {
     disposition: { skepticism: 2, literalism: 2, empathy: 5 },
@@ -19198,6 +19212,187 @@ function bestPremiumHeadroomAccount(ledger, candidates, now) {
 // src/auth/broker/server.ts
 init_atomic();
 
+// src/litellm/external-spend.ts
+var EXTERNAL_SPEND_TOP_N = 3;
+var DEFAULT_LITELLM_BASE = "http://127.0.0.1:4010";
+var EXTERNAL_SPEND_CACHE_TTL_MS = 90000;
+var EXTERNAL_SPEND_FETCH_TIMEOUT_MS = 5000;
+var LITELLM_MASTER_KEY_STATE_BASENAME = "litellm-master-key";
+var BARE_EXTERNAL_NEEDLES = [
+  "gpt-oss",
+  "grok",
+  "gemini",
+  "deepseek",
+  "kimi",
+  "glm-",
+  "qwen",
+  "llama"
+];
+function isExternalModel(model) {
+  const m = model.trim().toLowerCase();
+  if (!m)
+    return false;
+  if (m.startsWith("claude"))
+    return false;
+  if (m.includes("anthropic/claude"))
+    return false;
+  if (m.startsWith("openrouter/"))
+    return true;
+  if (m.startsWith("sr-"))
+    return true;
+  for (const needle of BARE_EXTERNAL_NEEDLES) {
+    if (m.includes(needle))
+      return true;
+  }
+  return false;
+}
+function shortModelLabel(model) {
+  let m = model.trim();
+  if (m.toLowerCase().startsWith("openrouter/")) {
+    m = m.slice("openrouter/".length);
+  }
+  const parts = m.split("/").filter(Boolean);
+  if (parts.length >= 2) {
+    m = parts[parts.length - 1];
+  }
+  if (m.toLowerCase().startsWith("sr-")) {
+    m = m.slice(3);
+  }
+  return m || model.trim();
+}
+function utcDateString(d) {
+  return d.toISOString().slice(0, 10);
+}
+function addUtcDays(dateStr, days) {
+  const [y, m, d] = dateStr.split("-").map(Number);
+  const dt = new Date(Date.UTC(y, m - 1, d));
+  dt.setUTCDate(dt.getUTCDate() + days);
+  return utcDateString(dt);
+}
+function rowDay(row) {
+  const st = row.startTime;
+  if (!st || typeof st !== "string")
+    return null;
+  return st.length >= 10 ? st.slice(0, 10) : null;
+}
+function externalModelsFromRow(row) {
+  const out = {};
+  const models = row.models ?? {};
+  for (const [name, raw] of Object.entries(models)) {
+    if (!isExternalModel(name))
+      continue;
+    const n = typeof raw === "number" ? raw : Number(raw);
+    if (!Number.isFinite(n) || n === 0)
+      continue;
+    out[name] = (out[name] ?? 0) + n;
+  }
+  return out;
+}
+function summarizeExternalSpend(days, now = new Date) {
+  const today = utcDateString(now);
+  const start7 = addUtcDays(today, -6);
+  let day24hUsd = 0;
+  let day7dUsd = 0;
+  const byModel = {};
+  for (const row of days) {
+    const day = rowDay(row);
+    if (!day)
+      continue;
+    if (day < start7 || day > today)
+      continue;
+    const ext = externalModelsFromRow(row);
+    let rowSum = 0;
+    for (const [name, usd] of Object.entries(ext)) {
+      rowSum += usd;
+      byModel[name] = (byModel[name] ?? 0) + usd;
+    }
+    day7dUsd += rowSum;
+    if (day === today)
+      day24hUsd += rowSum;
+  }
+  const top = Object.entries(byModel).filter(([, usd]) => usd > 0).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, EXTERNAL_SPEND_TOP_N).map(([name, usd]) => ({ label: shortModelLabel(name), usd }));
+  return { day24hUsd, day7dUsd, top };
+}
+function normalizeSpendLogRows(body) {
+  if (Array.isArray(body))
+    return body;
+  if (body && typeof body === "object") {
+    const data = body.data;
+    if (Array.isArray(data))
+      return data;
+  }
+  return [];
+}
+async function fetchAndSummarizeExternalSpend(opts) {
+  const now = opts.now ?? new Date;
+  const base = (opts.baseUrl ?? DEFAULT_LITELLM_BASE).replace(/\/+$/, "");
+  const today = utcDateString(now);
+  const start = addUtcDays(today, -6);
+  const end = addUtcDays(today, 1);
+  const url = `${base}/spend/logs?start_date=${encodeURIComponent(start)}` + `&end_date=${encodeURIComponent(end)}`;
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const timeoutMs = opts.timeoutMs ?? EXTERNAL_SPEND_FETCH_TIMEOUT_MS;
+  const ac = new AbortController;
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  try {
+    const res = await fetchImpl(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${opts.adminKey}`,
+        Accept: "application/json"
+      },
+      signal: ac.signal
+    });
+    if (!res.ok)
+      return null;
+    let body;
+    try {
+      body = await res.json();
+    } catch {
+      return null;
+    }
+    return summarizeExternalSpend(normalizeSpendLogRows(body), now);
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/auth/broker/mirror-write.ts
+init_atomic();
+import { lstatSync, realpathSync as realpathSync2 } from "node:fs";
+function safeMirrorWrite(input) {
+  let realParent;
+  try {
+    realParent = realpathSync2(input.parentDir);
+  } catch (err) {
+    input.logErr(`mirror parent realpath failed: ${err.message}`);
+    return false;
+  }
+  if (realParent !== input.expectedRealParent) {
+    input.refuse("parentDir", "realpath-mismatch");
+    return false;
+  }
+  try {
+    atomicWriteFileSync(input.targetPath, input.content, {
+      mode: input.mode ?? 384,
+      uid: input.uid,
+      gid: input.gid ?? input.uid,
+      onChownError: input.onChownError
+    });
+    return true;
+  } catch (err) {
+    const e = err;
+    if (e.code === "ELOOP" || e.code === "EEXIST") {
+      input.refuse("targetPath", `open-${e.code}`);
+      return false;
+    }
+    input.logErr(`mirror write failed: ${e.message}`);
+    return false;
+  }
+}
+
 // src/auth/account-store.ts
 init_atomic();
 import {
@@ -19998,14 +20193,20 @@ class ProviderRegistry {
 }
 
 // src/auth/broker/peercred.ts
-var AUTH_BROKER_SOCKET_PATH_RE = /^\/run\/switchroom\/auth-broker\/([a-zA-Z0-9][a-zA-Z0-9_-]*)\/sock$/;
+var AUTH_BROKER_ROOT = "/run/switchroom/auth-broker";
+function authBrokerSocketRe(socketRoot) {
+  const escaped = socketRoot.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^${escaped}/([a-zA-Z0-9][a-zA-Z0-9_-]*)/sock$`);
+}
+var AUTH_BROKER_SOCKET_PATH_RE = authBrokerSocketRe(AUTH_BROKER_ROOT);
 var AUTH_BROKER_MAX_NAME_LEN = 63;
 var RESERVED_NAMES = new Set(["operator"]);
-function socketPathToName(socketPath) {
-  return matchSocketName(socketPath, [AUTH_BROKER_SOCKET_PATH_RE], AUTH_BROKER_MAX_NAME_LEN);
+function socketPathToName(socketPath, socketRoot) {
+  const pattern = socketRoot === undefined || socketRoot === AUTH_BROKER_ROOT ? AUTH_BROKER_SOCKET_PATH_RE : authBrokerSocketRe(socketRoot);
+  return matchSocketName(socketPath, [pattern], AUTH_BROKER_MAX_NAME_LEN);
 }
-function classify(socketPath, config) {
-  const name = socketPathToName(socketPath);
+function classify(socketPath, config, socketRoot) {
+  const name = socketPathToName(socketPath, socketRoot);
   if (!name)
     return null;
   if (name === "operator")
@@ -20169,6 +20370,12 @@ var ClaimNotificationRequestSchema = exports_external.object({
   key: exports_external.string().min(1).max(512),
   windowMs: exports_external.number().int().positive().max(86400000)
 });
+var 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()
+});
 var RequestSchema2 = exports_external.discriminatedUnion("op", [
   GetCredentialsRequestSchema,
   ListStateRequestSchema,
@@ -20182,7 +20389,8 @@ var RequestSchema2 = exports_external.discriminatedUnion("op", [
   ListGoogleAccountsRequestSchema,
   ListMicrosoftAccountsRequestSchema,
   ProbeQuotaRequestSchema,
-  ClaimNotificationRequestSchema
+  ClaimNotificationRequestSchema,
+  GetExternalSpendRequestSchema
 ]);
 var GetCredentialsDataSchema = exports_external.object({
   account: exports_external.string(),
@@ -20249,6 +20457,18 @@ var SetOverrideDataSchema = exports_external.object({
 var ClaimNotificationDataSchema = exports_external.object({
   granted: exports_external.boolean()
 });
+var 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()
+});
 var GoogleAccountStateSchema = exports_external.object({
   account: exports_external.string(),
   expiresAt: exports_external.number(),
@@ -20329,13 +20549,14 @@ function encodeError(id, code, message) {
 }
 
 // src/auth/broker/server.ts
-var AUTH_BROKER_ROOT = "/run/switchroom/auth-broker";
+var AUTH_BROKER_ROOT2 = "/run/switchroom/auth-broker";
 var REFRESH_TICK_INTERVAL_MS = 60 * 1000;
 var MARK_EXHAUSTED_DEFAULT_MS = 5 * 60 * 60 * 1000;
 var MARK_THROTTLED_MAX_MS = 30 * 60 * 1000;
 var THROTTLE_ESCALATION_HITS = 3;
 var THROTTLE_ESCALATION_WINDOW_MS = 10 * 60 * 1000;
 var MARK_THROTTLED_MIN_INTERVAL_MS = 5 * 1000;
+var MARK_CORROBORATION_PROBE_DELAY_MS = 90 * 1000;
 var AUDIT_ROTATE_BYTES = 10 * 1024 * 1024;
 var AUDIT_KEEP = 5;
 var AUDIT_LINE_MAX = 4000;
@@ -20412,6 +20633,8 @@ class AuthBroker {
   refreshTimer = null;
   consumerProbeTimer = null;
   fleetProbeTimer = null;
+  markCorroborationTimers = new Set;
+  markCorroborationDelayMs = MARK_CORROBORATION_PROBE_DELAY_MS;
   fetchQuotaImpl;
   stateDir;
   socketRoot;
@@ -20422,6 +20645,8 @@ class AuthBroker {
   providers;
   quota = {};
   lastQuotaCache = {};
+  externalSpendCache = null;
+  externalSpendInFlight = null;
   probeInFlight = new Map;
   shaIndex = {};
   thresholdViolations = {};
@@ -20446,8 +20671,9 @@ class AuthBroker {
     this.operatorUid = opts.operatorUid;
     this.fetcher = opts.fetcher;
     this.fetchQuotaImpl = opts._testFetchQuota ?? fetchQuota;
+    this.markCorroborationDelayMs = opts._testCorroborationDelayMs ?? MARK_CORROBORATION_PROBE_DELAY_MS;
     this.stateDir = opts.stateDir ?? resolve9(this.homeRoot(), ".switchroom", "state", "auth-broker");
-    this.socketRoot = opts.socketRoot ?? AUTH_BROKER_ROOT;
+    this.socketRoot = opts.socketRoot ?? AUTH_BROKER_ROOT2;
     this.providers = new ProviderRegistry;
     this.providers.register(new AnthropicProvider);
     const googleClientId = config.google_workspace?.google_client_id;
@@ -20547,10 +20773,18 @@ class AuthBroker {
       clearInterval(this.fleetProbeTimer);
       this.fleetProbeTimer = null;
     }
+    for (const timer of this.markCorroborationTimers)
+      clearTimeout(timer);
+    this.markCorroborationTimers.clear();
     for (const [sock, lis] of this.listeners) {
       try {
         lis.server.close();
       } catch {}
+      for (const s of lis.sockets) {
+        try {
+          s.destroy();
+        } catch {}
+      }
       try {
         if (existsSync8(sock))
           unlinkSync(sock);
@@ -20579,7 +20813,12 @@ class AuthBroker {
     if (this.operatorUid !== undefined) {
       wanted.add(this.operatorSocketPath());
     }
+    const prevShape = configToShape(prev);
+    const nextShape = configToShape(config);
     for (const [sock, lis] of [...this.listeners]) {
+      const before = classify(lis.socketPath, prevShape, this.socketRoot);
+      const after = classify(lis.socketPath, nextShape, this.socketRoot);
+      const identityChanged = JSON.stringify(before ?? null) !== JSON.stringify(after ?? null);
       if (!wanted.has(sock)) {
         try {
           lis.server.close();
@@ -20588,7 +20827,18 @@ class AuthBroker {
           if (existsSync8(sock))
             unlinkSync(sock);
         } catch {}
+        for (const s of lis.sockets) {
+          try {
+            s.destroy();
+          } catch {}
+        }
         this.listeners.delete(sock);
+      } else if (identityChanged) {
+        for (const s of lis.sockets) {
+          try {
+            s.destroy();
+          } catch {}
+        }
       }
     }
     for (const name of Object.keys(config.agents ?? {})) {
@@ -20676,12 +20926,24 @@ class AuthBroker {
         try {
           chownSync2(dir, targetUid, targetUid);
         } catch {}
-        this.listeners.set(sockPath, { server, identity, socketPath: sockPath });
+        this.listeners.set(sockPath, {
+          server,
+          identity,
+          socketPath: sockPath,
+          sockets: new Set
+        });
         resolveP();
       });
     });
   }
   handleConnection(socket, sockPath, boundIdentity) {
+    const listener = this.listeners.get(sockPath);
+    if (listener) {
+      listener.sockets.add(socket);
+      socket.on("close", () => {
+        listener.sockets.delete(socket);
+      });
+    }
     let buf = "";
     socket.on("data", (chunk) => {
       buf += chunk.toString("utf-8");
@@ -20720,7 +20982,17 @@ class AuthBroker {
       socket.write(encodeError(reqId, "INVALID_ARGS", err.message));
       return;
     }
-    const identity = classify(sockPath, configToShape(this.config)) ?? boundIdentity;
+    const identity = classify(sockPath, configToShape(this.config), this.socketRoot);
+    if (!identity) {
+      this.audit({
+        op: "stale-identity-rejected",
+        identity: boundIdentity,
+        ok: false,
+        error: "FORBIDDEN"
+      });
+      socket.end(encodeError(reqId, "FORBIDDEN", "identity no longer configured"));
+      return;
+    }
     try {
       switch (req.op) {
         case "get-credentials": {
@@ -20840,6 +21112,9 @@ class AuthBroker {
         case "claim-notification":
           this.opClaimNotification(socket, reqId, identity, req.key, req.windowMs);
           break;
+        case "get-external-spend":
+          await this.opGetExternalSpend(socket, reqId, identity, req.forceLive);
+          break;
       }
     } catch (err) {
       socket.write(encodeError(reqId, "INTERNAL", err.message));
@@ -21612,6 +21887,9 @@ class AuthBroker {
     });
     this.quota[account] = { ...this.quota[account], exhausted_until: exhaustedUntil, marked_at: now };
     this.persistQuota();
+    if (exhaustedUntil > now + MARK_EXHAUSTED_DEFAULT_MS) {
+      this.scheduleMarkCorroboration(account, now, identity);
+    }
     const rolledTo = await this.nextHealthyAccountLive(account, this.config.auth?.fallback_order ?? []);
     const rolled = this.fanoutFailoverTo(account, rolledTo);
     this.fanoutToAffectedConsumers(account);
@@ -21628,6 +21906,67 @@ class AuthBroker {
     }
     return { rolled, rolledTo };
   }
+  scheduleMarkCorroboration(account, markedAt, identity) {
+    if (this.markCorroborationDelayMs <= 0)
+      return;
+    const timer = setTimeout(() => {
+      this.markCorroborationTimers.delete(timer);
+      this.corroborateExhaustionMark(account, markedAt, identity).catch((err) => {
+        this.logErr(`mark-corroboration ${account}: ${err.message}`);
+      });
+    }, this.markCorroborationDelayMs);
+    timer.unref?.();
+    this.markCorroborationTimers.add(timer);
+  }
+  async corroborateExhaustionMark(account, markedAt, identity) {
+    const entry = this.quota[account];
+    if (!entry || entry.marked_at !== markedAt) {
+      return { clamped: false, reason: "mark-superseded" };
+    }
+    const until = entry.exhausted_until;
+    const now = this.now();
+    if (until == null || until <= now + MARK_EXHAUSTED_DEFAULT_MS) {
+      return { clamped: false, reason: "not-long" };
+    }
+    const creds = readAccountCredentials(account, this.home);
+    const token = creds?.claudeAiOauth?.accessToken;
+    if (!token)
+      return { clamped: false, reason: "no-token" };
+    let result;
+    try {
+      result = await this.fetchQuotaImpl({ accessToken: token });
+    } catch (err) {
+      this.logErr(`mark-corroboration probe ${account}: ${err.message}`);
+      return { clamped: false, reason: "probe-failed" };
+    }
+    this.cacheQuotaSnapshot(account, result);
+    const snapshot = this.lastQuotaCache[account];
+    const clampedUntil = clampMarkExpiry({
+      proposedUntil: until,
+      now,
+      shortMs: MARK_EXHAUSTED_DEFAULT_MS,
+      snapshot
+    });
+    if (clampedUntil >= until) {
+      return { clamped: false, reason: "not-contradicted" };
+    }
+    const live = this.quota[account];
+    if (!live || live.marked_at !== markedAt || (live.exhausted_until ?? 0) <= clampedUntil) {
+      return { clamped: false, reason: "mark-superseded" };
+    }
+    this.quota[account] = { ...live, exhausted_until: clampedUntil };
+    this.persistQuota();
+    this.audit({
+      op: "mark-corroboration-clamp",
+      identity,
+      account,
+      accountKind: "claude",
+      ok: true
+    });
+    process.stdout.write(`auth-broker: mark-corroboration probe CONTRADICTS ${account} weekly wall — ` + `clamped exhausted_until ${new Date(until).toISOString()} → ` + `${new Date(clampedUntil).toISOString()}
+`);
+    return { clamped: true, reason: "contradicted", until: clampedUntil };
+  }
   exhaustionLiveCorroborated(account) {
     const snapshot = this.lastQuotaCache[account];
     if (!snapshot || !snapshotFresh(snapshot, this.now(), MARK_EXHAUSTED_DEFAULT_MS))
@@ -21636,6 +21975,105 @@ class AuthBroker {
       return false;
     return !overageLiftsWall(snapshot, this.isOverageAllowed(account));
   }
+  async opGetExternalSpend(socket, id, _identity, forceLive) {
+    const nowMs2 = this.now();
+    const ttl = EXTERNAL_SPEND_CACHE_TTL_MS;
+    const fresh = this.externalSpendCache != null && nowMs2 - this.externalSpendCache.capturedAtMs < ttl;
+    if (forceLive || !fresh) {
+      try {
+        await this.refreshExternalSpend(forceLive === true);
+      } catch (err) {
+        this.logErr(`external-spend refresh failed: ${err?.message ?? err}`);
+      }
+    }
+    if (!this.externalSpendCache) {
+      socket.write(encodeSuccess(id, {
+        available: false,
+        reason: this.resolveLitellmMasterKey() ? "litellm_unreachable" : "master_key_unavailable"
+      }));
+      return;
+    }
+    const recently = nowMs2 - this.externalSpendCache.capturedAtMs < 5000;
+    const outServed = recently && (forceLive || !fresh) ? "live" : "cache";
+    const s = this.externalSpendCache.summary;
+    socket.write(encodeSuccess(id, {
+      available: true,
+      day24hUsd: s.day24hUsd,
+      day7dUsd: s.day7dUsd,
+      top: s.top,
+      capturedAtMs: this.externalSpendCache.capturedAtMs,
+      served: outServed
+    }));
+  }
+  resolveLitellmMasterKey() {
+    if (this.opts._testLitellmMasterKey !== undefined) {
+      const v = this.opts._testLitellmMasterKey;
+      return v && v.trim() ? v.trim() : null;
+    }
+    const envKey = (process.env.SWITCHROOM_LITELLM_ADMIN_KEY ?? process.env.LITELLM_MASTER_KEY ?? "").trim();
+    if (envKey)
+      return envKey;
+    try {
+      const path = join8(this.stateDir, LITELLM_MASTER_KEY_STATE_BASENAME);
+      if (!existsSync8(path))
+        return null;
+      const raw = readFileSync7(path, "utf-8").trim();
+      return raw.length > 0 ? raw : null;
+    } catch {
+      return null;
+    }
+  }
+  resolveLitellmBaseUrl() {
+    const fromCfg = this.config.litellm?.base_url;
+    const raw = (process.env.SWITCHROOM_LITELLM_BASE ?? fromCfg ?? DEFAULT_LITELLM_BASE).trim();
+    return raw.replace(/\/+$/, "") || DEFAULT_LITELLM_BASE;
+  }
+  async refreshExternalSpend(forceLive) {
+    while (this.externalSpendInFlight) {
+      await this.externalSpendInFlight;
+      if (!forceLive)
+        return;
+      const justNow = this.now();
+      if (this.externalSpendCache && justNow - this.externalSpendCache.capturedAtMs < 5000) {
+        return;
+      }
+    }
+    const run = (async () => {
+      const nowMs2 = this.now();
+      if (!forceLive && this.externalSpendCache && nowMs2 - this.externalSpendCache.capturedAtMs < EXTERNAL_SPEND_CACHE_TTL_MS) {
+        return;
+      }
+      const key = this.resolveLitellmMasterKey();
+      if (!key)
+        return;
+      const baseUrl = this.resolveLitellmBaseUrl();
+      const now = new Date(nowMs2);
+      let summary = null;
+      if (this.opts._testFetchExternalSpend) {
+        summary = await this.opts._testFetchExternalSpend({
+          adminKey: key,
+          baseUrl,
+          now,
+          forceLive
+        });
+      } else {
+        summary = await fetchAndSummarizeExternalSpend({
+          adminKey: key,
+          baseUrl,
+          now,
+          timeoutMs: EXTERNAL_SPEND_FETCH_TIMEOUT_MS
+        });
+      }
+      if (!summary)
+        return;
+      this.externalSpendCache = { summary, capturedAtMs: this.now() };
+      this.persistExternalSpendCache();
+    })();
+    this.externalSpendInFlight = run.finally(() => {
+      this.externalSpendInFlight = null;
+    });
+    await this.externalSpendInFlight;
+  }
   opClaimNotification(socket, id, identity, key, windowMs) {
     const now = this.now();
     const prev = this.notificationClaims[key];
@@ -22201,25 +22639,68 @@ class AuthBroker {
     const mirrorDir = consumer.mirror_dir;
     if (!mirrorDir)
       return false;
-    const targetPath = join8(mirrorDir, ".credentials.json");
     const credsPath = accountCredentialsPath(label, this.home);
     if (!existsSync8(credsPath))
       return false;
     const mirrorContent = enrichMirrorContent(readFileSync7(credsPath, "utf-8"));
-    try {
-      mkdirSync5(mirrorDir, { recursive: true, mode: 448 });
-      atomicWriteFileSync(targetPath, mirrorContent, 384);
+    const safe = this.resolveConsumerMirrorPathsSafe(consumer.name, mirrorDir);
+    if (!safe)
+      return false;
+    return safeMirrorWrite({
+      parentDir: safe.mirrorDir,
+      expectedRealParent: safe.expectedRealParent,
+      targetPath: safe.targetPath,
+      content: mirrorContent,
+      uid: consumer.uid ?? 0,
+      onChownError: (err) => this.warnCapChownMissing(err),
+      refuse: (component, reason) => this.auditMirrorRefused({ kind: "consumer", name: consumer.name }, component, reason),
+      logErr: (msg) => this.logErr(`consumer-mirror ${consumer.name} <- ${label}: ${msg}`)
+    });
+  }
+  resolveConsumerMirrorPathsSafe(consumerName, mirrorDir) {
+    const identity = { kind: "consumer", name: consumerName };
+    const refuse = (component, reason) => {
+      this.auditMirrorRefused(identity, component, reason);
+      return null;
+    };
+    const parent = dirname3(mirrorDir);
+    const mirrorStat = this.lstatOrNull(mirrorDir);
+    if (mirrorStat) {
+      if (mirrorStat.isSymbolicLink())
+        return refuse("mirror_dir", "is-a-symlink");
+      if (!mirrorStat.isDirectory())
+        return refuse("mirror_dir", "is-not-a-directory");
+    } else {
+      const parentStat = this.lstatOrNull(parent);
+      if (!parentStat)
+        return refuse("mirror_dir-parent", "does-not-exist");
+      if (parentStat.isSymbolicLink())
+        return refuse("mirror_dir-parent", "is-a-symlink");
+      if (!parentStat.isDirectory())
+        return refuse("mirror_dir-parent", "is-not-a-directory");
       try {
-        const uid = consumer.uid ?? 0;
-        chownSync2(targetPath, uid, uid);
+        mkdirSync5(mirrorDir, { recursive: false, mode: 448 });
       } catch (err) {
-        this.warnCapChownMissing(err);
+        this.logErr(`consumer-mirror ${consumerName}: mkdir ${mirrorDir}: ${err.message}`);
+        return null;
       }
-      return true;
+    }
+    const targetPath = join8(mirrorDir, ".credentials.json");
+    const targetStat = this.lstatOrNull(targetPath);
+    if (targetStat) {
+      if (targetStat.isSymbolicLink())
+        return refuse(".credentials.json", "is-a-symlink");
+      if (!targetStat.isFile())
+        return refuse(".credentials.json", "is-not-a-regular-file");
+    }
+    let expectedRealParent;
+    try {
+      expectedRealParent = join8(realpathSync3(parent), basename2(mirrorDir));
     } catch (err) {
-      this.logErr(`consumer-mirror ${consumer.name} <- ${label}: ${err.message}`);
-      return false;
+      this.logErr(`consumer-mirror ${consumerName}: realpath ${parent}: ${err.message}`);
+      return null;
     }
+    return { mirrorDir, targetPath, expectedRealParent };
   }
   fanoutFailoverTo(label, next) {
     const auth = this.config.auth ?? {};
@@ -22274,13 +22755,7 @@ class AuthBroker {
     const claudeDir = join8(agentDir, ".claude");
     const targetPath = join8(claudeDir, ".credentials.json");
     const refuse = (component, reason) => {
-      this.logErr(`fanout ${agentName}: REFUSING mirror — ${component} ${reason} ` + `(symlink-guard #1393; agent-owned tree may be attacker-poisoned)`);
-      this.audit({
-        op: "mirror-symlink-refused",
-        identity: { kind: "agent", name: agentName, admin: false },
-        ok: false,
-        error: `${component}:${reason}`
-      });
+      this.auditMirrorRefused({ kind: "agent", name: agentName, admin: false }, component, reason);
       return null;
     };
     const agentsStat = this.lstatOrNull(agentsDir);
@@ -22311,15 +22786,26 @@ class AuthBroker {
       if (!targetStat.isFile())
         return refuse(".credentials.json", "is-not-a-regular-file");
     }
-    return { agentDir, claudeDir, targetPath };
+    const expectedRealParent = join8(realpathSync3(agentsDir), agentName, ".claude");
+    return { agentDir, claudeDir, targetPath, expectedRealParent };
   }
   lstatOrNull(path) {
     try {
-      return lstatSync(path);
+      return lstatSync2(path);
     } catch {
       return null;
     }
   }
+  auditMirrorRefused(identity, component, reason) {
+    const who = identity.kind === "operator" ? "operator" : identity.name;
+    this.logErr(`mirror ${who}: REFUSING mirror — ${component} ${reason} ` + `(symlink-guard #1393; peer-owned tree may be attacker-poisoned)`);
+    this.audit({
+      op: "mirror-symlink-refused",
+      identity,
+      ok: false,
+      error: `${component}:${reason}`
+    });
+  }
   mirrorAccountToAgent(label, agentName) {
     const credsPath = accountCredentialsPath(label, this.home);
     if (!existsSync8(credsPath))
@@ -22328,21 +22814,18 @@ class AuthBroker {
     const safe = this.resolveMirrorPathsSafe(agentName);
     if (!safe)
       return false;
-    const { claudeDir, targetPath } = safe;
+    const { claudeDir, targetPath, expectedRealParent } = safe;
     mkdirSync5(claudeDir, { recursive: true, mode: 448 });
-    try {
-      atomicWriteFileSync(targetPath, mirrorContent, 384);
-      try {
-        const uid = allocateAgentUid(agentName);
-        chownSync2(targetPath, uid, uid);
-      } catch (err) {
-        this.warnCapChownMissing(err);
-      }
-      return true;
-    } catch (err) {
-      this.logErr(`fanout ${agentName} <- ${label}: ${err.message}`);
-      return false;
-    }
+    return safeMirrorWrite({
+      parentDir: claudeDir,
+      expectedRealParent,
+      targetPath,
+      content: mirrorContent,
+      uid: allocateAgentUid(agentName),
+      onChownError: (err) => this.warnCapChownMissing(err),
+      refuse: (component, reason) => this.auditMirrorRefused({ kind: "agent", name: agentName, admin: false }, component, reason),
+      logErr: (msg) => this.logErr(`fanout ${agentName} <- ${label}: ${msg}`)
+    });
   }
   loadStateFromDisk() {
     this.quota = this.readJson("quota.json") ?? {};
@@ -22354,6 +22837,22 @@ class AuthBroker {
     this.lastTierQuotaCache = this.readJson("last-tier-quota.json") ?? {};
     this.premiumTierAllWalled = this.readJson("premium-tier-all-walled.json") ?? null;
     this.usageLedger = this.readJson("usage-ledger.json") ?? {};
+    {
+      const es = this.readJson("external-spend.json");
+      if (es && es.summary && typeof es.capturedAtMs === "number" && Number.isFinite(es.summary.day24hUsd) && Number.isFinite(es.summary.day7dUsd) && Array.isArray(es.summary.top) && es.summary.top.every((t) => t && typeof t.label === "string" && typeof t.usd === "number" && Number.isFinite(t.usd))) {
+        this.externalSpendCache = {
+          summary: {
+            day24hUsd: es.summary.day24hUsd,
+            day7dUsd: es.summary.day7dUsd,
+            top: es.summary.top.map((t) => ({
+              label: t.label,
+              usd: t.usd
+            }))
+          },
+          capturedAtMs: es.capturedAtMs
+        };
+      }
+    }
     this.applyActiveOverride();
   }
   applyActiveOverride() {
@@ -22407,6 +22906,11 @@ class AuthBroker {
   persistLastQuotaCache() {
     atomicWriteJsonSync(join8(this.stateDir, "last-quota.json"), this.lastQuotaCache, 384);
   }
+  persistExternalSpendCache() {
+    if (!this.externalSpendCache)
+      return;
+    atomicWriteJsonSync(join8(this.stateDir, "external-spend.json"), this.externalSpendCache, 384);
+  }
   persistLastTierQuotaCache() {
     atomicWriteJsonSync(join8(this.stateDir, "last-tier-quota.json"), this.lastTierQuotaCache, 384);
   }