switchroom 0.19.22 → 0.19.24

package/dist/cli/switchroom.js

@@ -2120,7 +2120,7 @@ var init_esm = __esm(() => {
 });
 
 // src/build-info.ts
-var VERSION = "0.19.22", COMMIT_SHA = "50ef9fb5";
+var VERSION = "0.19.24", COMMIT_SHA = "0fa8ffb8";
 
 // src/cli/resolve-version.ts
 import { existsSync, readFileSync } from "node:fs";
@@ -13939,16 +13939,19 @@ var init_schema = __esm(() => {
     model: exports_external.string().min(1).optional().describe("Per-op model (upstream `HINDSIGHT_API_<OP>_LLM_MODEL`). Absent \u2192 " + "inherit the global `hindsight.llm.model`."),
     provider: exports_external.string().min(1).optional().describe("Per-op provider (upstream `HINDSIGHT_API_<OP>_LLM_PROVIDER`). " + "Absent \u2192 inherit the global `hindsight.llm.provider`."),
     base_url: exports_external.string().min(1).optional().describe("Per-op base URL (upstream `HINDSIGHT_API_<OP>_LLM_BASE_URL`). " + "Optional passthrough; absent \u2192 inherit the global."),
-    api_key: exports_external.string().min(1).optional().describe("Per-op API key (upstream `HINDSIGHT_API_<OP>_LLM_API_KEY`). Literal " + "or `vault:` reference. Optional passthrough; absent \u2192 inherit global.")
+    api_key: exports_external.string().min(1).optional().describe("Per-op API key (upstream `HINDSIGHT_API_<OP>_LLM_API_KEY`). Literal " + "or `vault:` reference. Optional passthrough; absent \u2192 inherit global."),
+    context_window: exports_external.number().int().positive().optional().describe("Context window (tokens) of the backend serving THIS op. NOT an " + "upstream env var \u2014 switchroom derives the op's token budget " + "(consolidation batch size / max-completion caps / reflect " + "max-context cap) from it so a single call can never overflow the " + "window. Absent \u2192 inherit " + "`hindsight.llm.context_window`, else a per-provider default " + "(conservative for non-`claude-code` providers, which usually mean " + "a local llama.cpp/Ollama slot; a self-hosted `base_url` \u2014 loopback, " + "RFC1918, `.local`/`.internal` \u2014 forces the conservative default too, " + "regardless of the provider NAME, since the endpoint is where the " + "traffic actually terminates). All three lanes (`retain`, " + "`reflect`, `consolidation`) are budgeted independently.")
   }).describe("Per-operation LLM override. Every field optional; an unset field (or " + "an omitted op block) inherits the global `hindsight.llm.*`, which is " + "already the engine's fallback \u2014 switchroom emits only the vars set.");
   HindsightConfigSchema = exports_external.object({
     llm: exports_external.object({
       provider: exports_external.string().min(1).optional().describe("Hindsight LLM provider (upstream `HINDSIGHT_API_LLM_PROVIDER`). " + "Defaults to `claude-code` (subscription-honest, broker-fed OAuth). " + "Any litellm-routable provider the upstream image supports is valid. " + "Serves as the GLOBAL default for every op absent a per-op override."),
       model: exports_external.string().min(1).optional().describe("Hindsight LLM model (upstream `HINDSIGHT_API_LLM_MODEL`). Defaults " + "to HINDSIGHT_DEFAULT_MODEL. Any model your LiteLLM proxy can route " + "is valid, e.g. `openrouter/z-ai/glm-5.2` when routing through the " + "fleet proxy. With provider=claude-code this value is ALSO exported " + "as `ANTHROPIC_MODEL` to the claude subprocess. Serves as the GLOBAL " + "default for every op absent a per-op override."),
+      context_window: exports_external.number().int().positive().optional().describe("GLOBAL context window (tokens) of the backend serving hindsight's " + "LLM ops \u2014 the declared size switchroom derives every token budget " + "from. Set this to the real window of whatever you point " + "`hindsight.llm` at (e.g. 32768 for a llama.cpp slot launched with " + "`-c 65536 -np 2`, 131072 for a large-window OpenRouter model). " + "Absent \u2192 a per-provider default: 200000 for `claude-code`, a " + "conservative 32768 for everything else. Overflowing a local " + "backend's window does NOT error \u2014 llama.cpp context-shift silently " + "drops the system prompt and the model answers conversationally " + "with HTTP 200 \u2014 so this value is what makes the failure " + "detectable at setup time instead of never."),
       retain: HindsightPerOpLlmSchema.optional().describe("Per-op override for the `retain` LLM op (memory ingestion). Emits " + "`HINDSIGHT_API_RETAIN_LLM_*`. Absent \u2192 uses the global model/provider."),
       reflect: HindsightPerOpLlmSchema.optional().describe("Per-op override for the `reflect` LLM op (synthesis / mental-model " + "refresh). Emits `HINDSIGHT_API_REFLECT_LLM_*`. Absent \u2192 uses global."),
       consolidation: HindsightPerOpLlmSchema.optional().describe("Per-op override for the `consolidation` LLM op (background memory " + "merge). Emits `HINDSIGHT_API_CONSOLIDATION_LLM_*`. Absent \u2192 global.")
-    }).optional().describe("LLM knob for the hindsight container. The flat `provider`/`model` set " + "the global default (backward-compatible); optional `retain`/`reflect`/" + "`consolidation` blocks override individual ops. All fields optional; " + "unset fields fall back to the hard-coded defaults.")
+    }).optional().describe("LLM knob for the hindsight container. The flat `provider`/`model` set " + "the global default (backward-compatible); optional `retain`/`reflect`/" + "`consolidation` blocks override individual ops. All fields optional; " + "unset fields fall back to the hard-coded defaults."),
+    env: exports_external.record(exports_external.union([exports_external.string(), exports_external.number(), exports_external.boolean()])).optional().describe("Operator overrides for switchroom's capability-gated Hindsight " + "performance defaults. Only the keys switchroom actually manages are " + "honoured (`HINDSIGHT_PERF_ENV_KEYS` in " + "src/setup/hindsight-perf-defaults.ts: RERANKER_LOCAL_FP16, " + "RERANKER_LOCAL_BATCH_SIZE, LLM_MAX_CONCURRENT, " + "RETAIN/CONSOLIDATION_LLM_MAX_CONCURRENT, LLM_STRICT_SCHEMA, " + "LLM_MAX_RETRIES, CONSOLIDATION_LLM_PARALLELISM, " + "RECALL_MAX_CANDIDATES_PER_SOURCE, LINK_EXPANSION_PER_ENTITY_LIMIT, " + "LINK_EXPANSION_TIMEOUT, LLM_REASONING_EFFORT), the override-only keys " + "switchroom manages but ships NO default for " + "(`HINDSIGHT_PERF_OVERRIDE_ONLY_KEYS`: " + "HINDSIGHT_API_WORKER_CONSOLIDATION_BANK_PRIORITY \u2014 a per-deployment " + "`bank-pattern:priority,...` map; unset means upstream's flat " + "created_at FIFO across banks), plus the " + "embedded-PostgreSQL (pg0) sizing keys switchroom manages in " + "src/setup/hindsight-pg-defaults.ts (`HINDSIGHT_PG_ENV_KEYS`: " + "SWITCHROOM_HINDSIGHT_PG_EFFECTIVE_CACHE_SIZE, " + "SWITCHROOM_HINDSIGHT_PG_SHARED_BUFFERS \u2014 a postgres size string such " + "as `4GB`, or the sentinel `off` to leave pg0's own default for that " + "one knob). A value set here " + "REPLACES switchroom's default and is emitted even when the gating " + "capability is absent, so an operator can always force a knob. Other " + "`HINDSIGHT_API_*` keys are deliberately IGNORED \u2014 a blanket " + "passthrough would collide with the vars startHindsight() derives " + "itself (HINDSIGHT_API_PORT, the retain token/deadline budget).")
   });
   MicrosoftWorkspaceConfigSchema = exports_external.object({
     microsoft_client_id: exports_external.string().min(1).optional().describe("Microsoft OAuth application (client) ID from Entra portal " + "(literal string or vault reference e.g. " + "'vault:microsoft-oauth-client-id'). OPTIONAL \u2014 omit it to use " + "switchroom's shipped default Microsoft app (zero-config). " + "Set it only to bring your own Entra app (BYO)."),
@@ -15555,6 +15558,376 @@ var init_timeout_budget = __esm(() => {
   };
 });
 
+// src/setup/host-capabilities.ts
+import { existsSync as existsSync5, mkdirSync, readFileSync as readFileSync5, writeFileSync } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+function hostCapabilitiesPath() {
+  return resolveStatePath("host-capabilities.json");
+}
+function saveVoiceCapability(caps, now = () => new Date) {
+  const doc = {
+    version: HOST_CAPABILITIES_VERSION,
+    voice: {
+      gpuPresent: caps.gpuPresent,
+      containerToolkit: caps.containerToolkit,
+      engine: caps.engine,
+      detectedAt: now().toISOString()
+    }
+  };
+  const path = hostCapabilitiesPath();
+  mkdirSync(dirname2(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(doc, null, 2) + `
+`, {
+    encoding: "utf-8",
+    mode: 384
+  });
+  return doc;
+}
+function loadHostCapabilities() {
+  const path = hostCapabilitiesPath();
+  if (!existsSync5(path))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync5(path, "utf-8"));
+    if (parsed && typeof parsed === "object" && "voice" in parsed && typeof parsed.voice === "object") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+var HOST_CAPABILITIES_VERSION = 1;
+var init_host_capabilities = __esm(() => {
+  init_paths();
+});
+
+// src/setup/hindsight-perf-defaults.ts
+function resolveHindsightPerfOverrides(configEnv, processEnv = process.env) {
+  const out = new Map;
+  for (const key of HINDSIGHT_PERF_ENV_KEYS) {
+    const fromProcess = processEnv[key];
+    if (typeof fromProcess === "string" && fromProcess.trim() !== "") {
+      out.set(key, fromProcess.trim());
+    }
+  }
+  for (const [key, raw] of Object.entries(configEnv ?? {})) {
+    if (!HINDSIGHT_PERF_ENV_KEYS.has(key))
+      continue;
+    const value = String(raw).trim();
+    if (value === "")
+      continue;
+    out.set(key, value);
+  }
+  return out;
+}
+function hindsightPerfEnv(caps, overrides = new Map) {
+  const groups = [
+    HINDSIGHT_PERF_DEFAULTS_UNGATED
+  ];
+  if (caps.gpu === true)
+    groups.push(HINDSIGHT_PERF_DEFAULTS_GPU);
+  if (caps.localLlm === true)
+    groups.push(HINDSIGHT_PERF_DEFAULTS_LOCAL_LLM);
+  const out = [];
+  const emitted = new Set;
+  for (const group of groups) {
+    for (const [key, value] of group) {
+      if (emitted.has(key))
+        continue;
+      emitted.add(key);
+      out.push([key, overrides.get(key) ?? value]);
+    }
+  }
+  for (const key of [...overrides.keys()].sort()) {
+    if (emitted.has(key))
+      continue;
+    emitted.add(key);
+    out.push([key, overrides.get(key)]);
+  }
+  return out;
+}
+var HINDSIGHT_RERANKER_MAX_CANDIDATES_FOR_DERIVATION = 150, HINDSIGHT_DEFAULT_RECALL_MAX_CANDIDATES_PER_SOURCE, HINDSIGHT_DEFAULT_LINK_EXPANSION_PER_ENTITY_LIMIT = 50, HINDSIGHT_DEFAULT_LINK_EXPANSION_TIMEOUT_S = 2, HINDSIGHT_DEFAULT_LLM_REASONING_EFFORT = "low", HINDSIGHT_DEFAULT_LLM_MAX_CONCURRENT = 4, HINDSIGHT_DEFAULT_RETAIN_LLM_MAX_CONCURRENT = 1, HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_MAX_CONCURRENT = 1, HINDSIGHT_DEFAULT_RERANKER_LOCAL_FP16 = "true", HINDSIGHT_DEFAULT_RERANKER_LOCAL_BATCH_SIZE = 128, HINDSIGHT_DEFAULT_LLM_STRICT_SCHEMA = "true", HINDSIGHT_DEFAULT_LLM_MAX_RETRIES = 2, HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_PARALLELISM = 2, HINDSIGHT_PERF_DEFAULTS_UNGATED, HINDSIGHT_PERF_DEFAULTS_GPU, HINDSIGHT_PERF_DEFAULTS_LOCAL_LLM, HINDSIGHT_PERF_OVERRIDE_ONLY_KEYS, HINDSIGHT_PERF_ENV_KEYS;
+var init_hindsight_perf_defaults = __esm(() => {
+  HINDSIGHT_DEFAULT_RECALL_MAX_CANDIDATES_PER_SOURCE = Math.ceil(HINDSIGHT_RERANKER_MAX_CANDIDATES_FOR_DERIVATION * 0.4);
+  HINDSIGHT_PERF_DEFAULTS_UNGATED = [
+    [
+      "HINDSIGHT_API_RECALL_MAX_CANDIDATES_PER_SOURCE",
+      String(HINDSIGHT_DEFAULT_RECALL_MAX_CANDIDATES_PER_SOURCE)
+    ],
+    [
+      "HINDSIGHT_API_LINK_EXPANSION_PER_ENTITY_LIMIT",
+      String(HINDSIGHT_DEFAULT_LINK_EXPANSION_PER_ENTITY_LIMIT)
+    ],
+    [
+      "HINDSIGHT_API_LINK_EXPANSION_TIMEOUT",
+      String(HINDSIGHT_DEFAULT_LINK_EXPANSION_TIMEOUT_S)
+    ],
+    ["HINDSIGHT_API_LLM_REASONING_EFFORT", HINDSIGHT_DEFAULT_LLM_REASONING_EFFORT],
+    [
+      "HINDSIGHT_API_CONSOLIDATION_LLM_PARALLELISM",
+      String(HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_PARALLELISM)
+    ]
+  ];
+  HINDSIGHT_PERF_DEFAULTS_GPU = [
+    ["HINDSIGHT_API_RERANKER_LOCAL_FP16", HINDSIGHT_DEFAULT_RERANKER_LOCAL_FP16],
+    [
+      "HINDSIGHT_API_RERANKER_LOCAL_BATCH_SIZE",
+      String(HINDSIGHT_DEFAULT_RERANKER_LOCAL_BATCH_SIZE)
+    ]
+  ];
+  HINDSIGHT_PERF_DEFAULTS_LOCAL_LLM = [
+    ["HINDSIGHT_API_LLM_MAX_CONCURRENT", String(HINDSIGHT_DEFAULT_LLM_MAX_CONCURRENT)],
+    [
+      "HINDSIGHT_API_RETAIN_LLM_MAX_CONCURRENT",
+      String(HINDSIGHT_DEFAULT_RETAIN_LLM_MAX_CONCURRENT)
+    ],
+    [
+      "HINDSIGHT_API_CONSOLIDATION_LLM_MAX_CONCURRENT",
+      String(HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_MAX_CONCURRENT)
+    ],
+    ["HINDSIGHT_API_LLM_STRICT_SCHEMA", HINDSIGHT_DEFAULT_LLM_STRICT_SCHEMA],
+    ["HINDSIGHT_API_LLM_MAX_RETRIES", String(HINDSIGHT_DEFAULT_LLM_MAX_RETRIES)]
+  ];
+  HINDSIGHT_PERF_OVERRIDE_ONLY_KEYS = new Set([
+    "HINDSIGHT_API_WORKER_CONSOLIDATION_BANK_PRIORITY"
+  ]);
+  HINDSIGHT_PERF_ENV_KEYS = new Set([
+    ...[
+      ...HINDSIGHT_PERF_DEFAULTS_UNGATED,
+      ...HINDSIGHT_PERF_DEFAULTS_GPU,
+      ...HINDSIGHT_PERF_DEFAULTS_LOCAL_LLM
+    ].map(([k]) => k),
+    ...HINDSIGHT_PERF_OVERRIDE_ONLY_KEYS
+  ]);
+});
+
+// src/setup/hindsight-pg-defaults.ts
+function pgMib(mib) {
+  return `${mib}MB`;
+}
+function resolveHindsightPgOverrides(configEnv, processEnv = process.env) {
+  const out = new Map;
+  for (const key of HINDSIGHT_PG_ENV_KEYS) {
+    const fromProcess = processEnv[key];
+    if (typeof fromProcess === "string" && fromProcess.trim() !== "") {
+      out.set(key, fromProcess.trim());
+    }
+  }
+  for (const [key, raw] of Object.entries(configEnv ?? {})) {
+    if (!HINDSIGHT_PG_ENV_KEYS.has(key))
+      continue;
+    const value = String(raw).trim();
+    if (value === "")
+      continue;
+    out.set(key, value);
+  }
+  return out;
+}
+function hindsightPgEnv(overrides = new Map) {
+  const out = [];
+  const emitted = new Set;
+  for (const [key, value] of HINDSIGHT_PG_DEFAULTS) {
+    if (emitted.has(key))
+      continue;
+    emitted.add(key);
+    out.push([key, overrides.get(key) ?? value]);
+  }
+  return out;
+}
+var HINDSIGHT_PG_MEM_LIMIT_MIB_FOR_DERIVATION, HINDSIGHT_PG_APP_ANON_MIB = 2560, HINDSIGHT_PG_PAGE_CACHE_FLOOR_MIB = 2048, HINDSIGHT_PG_SHARED_BUFFERS_BUDGET_MIB, HINDSIGHT_PG_DEFAULT_SHARED_BUFFERS_MIB = 1536, HINDSIGHT_PG_DEFAULT_EFFECTIVE_CACHE_SIZE_MIB = 4096, HINDSIGHT_PG_EFFECTIVE_CACHE_SIZE_ENV = "SWITCHROOM_HINDSIGHT_PG_EFFECTIVE_CACHE_SIZE", HINDSIGHT_PG_SHARED_BUFFERS_ENV = "SWITCHROOM_HINDSIGHT_PG_SHARED_BUFFERS", HINDSIGHT_PG_DEFAULTS, HINDSIGHT_PG_ENV_KEYS;
+var init_hindsight_pg_defaults = __esm(() => {
+  HINDSIGHT_PG_MEM_LIMIT_MIB_FOR_DERIVATION = 8 * 1024;
+  HINDSIGHT_PG_SHARED_BUFFERS_BUDGET_MIB = HINDSIGHT_PG_MEM_LIMIT_MIB_FOR_DERIVATION - HINDSIGHT_PG_APP_ANON_MIB - HINDSIGHT_PG_PAGE_CACHE_FLOOR_MIB;
+  HINDSIGHT_PG_DEFAULTS = [
+    [
+      HINDSIGHT_PG_EFFECTIVE_CACHE_SIZE_ENV,
+      pgMib(HINDSIGHT_PG_DEFAULT_EFFECTIVE_CACHE_SIZE_MIB)
+    ],
+    [HINDSIGHT_PG_SHARED_BUFFERS_ENV, pgMib(HINDSIGHT_PG_DEFAULT_SHARED_BUFFERS_MIB)]
+  ];
+  HINDSIGHT_PG_ENV_KEYS = new Set(HINDSIGHT_PG_DEFAULTS.map(([k]) => k));
+});
+
+// src/setup/self-hosted-url.ts
+function isLoopbackHttpUrl(url) {
+  try {
+    const u = new URL(url.includes("://") ? url : `http://${url}`);
+    const h = (u.hostname || "").toLowerCase().replace(/^\[|\]$/g, "");
+    return h === "localhost" || h === "127.0.0.1" || h === "::1";
+  } catch {
+    return false;
+  }
+}
+function isSelfHostedHttpUrl(url) {
+  let host;
+  try {
+    const u = new URL(url.includes("://") ? url : `http://${url}`);
+    host = (u.hostname || "").toLowerCase().replace(/^\[|\]$/g, "");
+  } catch {
+    return false;
+  }
+  if (!host)
+    return false;
+  if (isLoopbackHttpUrl(url))
+    return true;
+  if (host === "host.docker.internal" || host === "gateway.docker.internal")
+    return true;
+  if (host.endsWith(".local") || host.endsWith(".internal"))
+    return true;
+  if (/^f[cd][0-9a-f]{2}:/.test(host) || /^fe[89ab][0-9a-f]:/.test(host))
+    return true;
+  const v4 = host.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+  if (!v4)
+    return false;
+  const [a, b] = [Number(v4[1]), Number(v4[2])];
+  if (a === 10)
+    return true;
+  if (a === 127)
+    return true;
+  if (a === 192 && b === 168)
+    return true;
+  if (a === 172 && b >= 16 && b <= 31)
+    return true;
+  if (a === 169 && b === 254)
+    return true;
+  return false;
+}
+
+// src/setup/hindsight-context-budget.ts
+function clamp(value, floor, ceiling) {
+  return Math.min(ceiling, Math.max(floor, value));
+}
+function usableContextTokens(windowTokens) {
+  return windowTokens - Math.floor(windowTokens * HINDSIGHT_CONTEXT_SAFETY_FRACTION);
+}
+function defaultContextWindowForProvider(provider, baseUrl) {
+  const url = baseUrl?.trim();
+  if (url && isSelfHostedHttpUrl(url))
+    return HINDSIGHT_CONSERVATIVE_CONTEXT_WINDOW;
+  const p = provider.trim().toLowerCase();
+  if (p === "claude-code" || p === "anthropic")
+    return HINDSIGHT_CLAUDE_CONTEXT_WINDOW;
+  return HINDSIGHT_CONSERVATIVE_CONTEXT_WINDOW;
+}
+function resolveLaneContextWindow(lane, llm) {
+  const perOp = llm?.[lane];
+  const provider = perOp?.provider?.trim() || llm?.provider?.trim() || "claude-code";
+  const baseUrl = perOp?.base_url?.trim() || undefined;
+  const perOpWindow = perOp?.context_window;
+  if (typeof perOpWindow === "number" && perOpWindow > 0) {
+    return { windowTokens: Math.floor(perOpWindow), windowSource: "per-op", provider, baseUrl };
+  }
+  const globalWindow = llm?.context_window;
+  if (typeof globalWindow === "number" && globalWindow > 0) {
+    return { windowTokens: Math.floor(globalWindow), windowSource: "global", provider, baseUrl };
+  }
+  return {
+    windowTokens: defaultContextWindowForProvider(provider, baseUrl),
+    windowSource: "provider-default",
+    provider,
+    baseUrl
+  };
+}
+function resolveHindsightContextBudget(llm) {
+  const cons = resolveLaneContextWindow("consolidation", llm);
+  const ret = resolveLaneContextWindow("retain", llm);
+  const consMaxCompletion = clamp(Math.floor(cons.windowTokens / 4), HINDSIGHT_CONSOLIDATION_MAX_COMPLETION_FLOOR, HINDSIGHT_CONSOLIDATION_MAX_COMPLETION_CEILING);
+  const consUsable = usableContextTokens(cons.windowTokens);
+  const consPromptBudget = consUsable - consMaxCompletion;
+  const batchSize = clamp(Math.floor((consPromptBudget - HINDSIGHT_CONSOLIDATION_PROMPT_OVERHEAD_TOKENS) / HINDSIGHT_CONSOLIDATION_TOKENS_PER_FACT), HINDSIGHT_CONSOLIDATION_BATCH_SIZE_FLOOR, HINDSIGHT_CONSOLIDATION_BATCH_SIZE_CEILING);
+  const consPrompt = HINDSIGHT_CONSOLIDATION_PROMPT_OVERHEAD_TOKENS + batchSize * HINDSIGHT_CONSOLIDATION_TOKENS_PER_FACT;
+  const retMaxCompletion = clamp(Math.floor(ret.windowTokens * 3 / 16), HINDSIGHT_RETAIN_MAX_COMPLETION_FLOOR, HINDSIGHT_RETAIN_MAX_COMPLETION_CEILING);
+  const refl = resolveLaneContextWindow("reflect", llm);
+  const reflCompletionReserve = clamp(Math.floor(refl.windowTokens * 3 / 16), HINDSIGHT_RETAIN_MAX_COMPLETION_FLOOR, HINDSIGHT_RETAIN_MAX_COMPLETION_CEILING);
+  const reflUsable = usableContextTokens(refl.windowTokens);
+  const reflMaxContext = Math.max(HINDSIGHT_REFLECT_MAX_CONTEXT_FLOOR, Math.floor((reflUsable - reflCompletionReserve) / 1000) * 1000);
+  return {
+    consolidation: {
+      lane: "consolidation",
+      windowTokens: cons.windowTokens,
+      usableTokens: consUsable,
+      windowSource: cons.windowSource,
+      provider: cons.provider,
+      batchSize,
+      maxCompletionTokens: consMaxCompletion,
+      estimatedPromptTokens: consPrompt,
+      worstCaseTotalTokens: consPrompt + consMaxCompletion
+    },
+    reflect: {
+      lane: "reflect",
+      windowTokens: refl.windowTokens,
+      usableTokens: reflUsable,
+      windowSource: refl.windowSource,
+      provider: refl.provider,
+      maxContextTokens: reflMaxContext,
+      completionReserveTokens: reflCompletionReserve,
+      estimatedPromptTokens: reflMaxContext,
+      worstCaseTotalTokens: reflMaxContext + reflCompletionReserve
+    },
+    retain: {
+      lane: "retain",
+      windowTokens: ret.windowTokens,
+      usableTokens: usableContextTokens(ret.windowTokens),
+      windowSource: ret.windowSource,
+      provider: ret.provider,
+      maxCompletionTokens: retMaxCompletion,
+      estimatedPromptTokens: HINDSIGHT_RETAIN_PROMPT_ESTIMATE_TOKENS,
+      worstCaseTotalTokens: HINDSIGHT_RETAIN_PROMPT_ESTIMATE_TOKENS + retMaxCompletion
+    }
+  };
+}
+function laneCheck(b) {
+  return { ...b, completionTokens: b.maxCompletionTokens, completionLabel: "completion" };
+}
+function reflectLaneCheck(b) {
+  return {
+    ...b,
+    completionTokens: b.completionReserveTokens,
+    completionLabel: "completion reserve"
+  };
+}
+function laneFailure(b) {
+  if (b.worstCaseTotalTokens > b.usableTokens) {
+    return `hindsight ${b.lane}: worst-case ${b.worstCaseTotalTokens} tokens ` + `(${b.estimatedPromptTokens} prompt + ${b.completionTokens} ${b.completionLabel}) ` + `exceeds the ${b.usableTokens} usable tokens of ` + `the declared ${b.windowTokens}-token context window ` + `(${Math.round(HINDSIGHT_CONTEXT_SAFETY_FRACTION * 100)}% safety band held back; ` + `source: ${b.windowSource}, provider: ${b.provider}).`;
+  }
+  if (b.lane === "retain" && b.maxCompletionTokens !== undefined && b.maxCompletionTokens <= HINDSIGHT_UPSTREAM_RETAIN_CHUNK_SIZE) {
+    return `hindsight retain: derived max_completion_tokens ${b.maxCompletionTokens} is not ` + `greater than the upstream retain_chunk_size ${HINDSIGHT_UPSTREAM_RETAIN_CHUNK_SIZE}; ` + `the hindsight container refuses to boot with this combination.`;
+  }
+  return;
+}
+function assertHindsightContextBudgetFits(budget) {
+  for (const lane of [
+    laneCheck(budget.consolidation),
+    laneCheck(budget.retain),
+    reflectLaneCheck(budget.reflect)
+  ]) {
+    const failure = laneFailure(lane);
+    if (failure) {
+      throw new HindsightContextBudgetError(lane.lane, `${failure}
+` + `A local backend does NOT error on context overflow \u2014 llama.cpp context-shift ` + `silently drops the system prompt and returns HTTP 200 with conversational text ` + `instead of the required JSON, so this must be caught here.
+` + `Fix: raise \`hindsight.llm.context_window\` (or \`hindsight.llm.${lane.lane}.context_window\`) ` + `to the backend's real window, or point the lane at a larger-window model.`);
+    }
+  }
+}
+function resolveCheckedHindsightContextBudget(llm) {
+  const budget = resolveHindsightContextBudget(llm);
+  assertHindsightContextBudgetFits(budget);
+  return budget;
+}
+var HINDSIGHT_CLAUDE_CONTEXT_WINDOW = 200000, HINDSIGHT_CONSERVATIVE_CONTEXT_WINDOW = 32768, HINDSIGHT_CONTEXT_SAFETY_FRACTION = 0.2, HINDSIGHT_CONSOLIDATION_PROMPT_OVERHEAD_TOKENS = 2270, HINDSIGHT_CONSOLIDATION_TOKENS_PER_FACT = 2500, HINDSIGHT_RETAIN_PROMPT_ESTIMATE_TOKENS = 8000, HINDSIGHT_CONSOLIDATION_BATCH_SIZE_CEILING = 12, HINDSIGHT_CONSOLIDATION_BATCH_SIZE_FLOOR = 1, HINDSIGHT_CONSOLIDATION_MAX_COMPLETION_CEILING = 16384, HINDSIGHT_RETAIN_MAX_COMPLETION_CEILING = 16384, HINDSIGHT_UPSTREAM_RETAIN_CHUNK_SIZE = 3000, HINDSIGHT_CONSOLIDATION_MAX_COMPLETION_FLOOR = 1024, HINDSIGHT_RETAIN_MAX_COMPLETION_FLOOR, HINDSIGHT_REFLECT_MAX_CONTEXT_FLOOR = 2048, HindsightContextBudgetError;
+var init_hindsight_context_budget = __esm(() => {
+  HINDSIGHT_RETAIN_MAX_COMPLETION_FLOOR = HINDSIGHT_UPSTREAM_RETAIN_CHUNK_SIZE + 72;
+  HindsightContextBudgetError = class HindsightContextBudgetError extends Error {
+    lane;
+    constructor(lane, message) {
+      super(message);
+      this.name = "HindsightContextBudgetError";
+      this.lane = lane;
+    }
+  };
+});
+
 // src/util/atomic.ts
 var exports_atomic = {};
 __export(exports_atomic, {
@@ -15678,8 +16051,9 @@ function hindsightInteractiveLlmTimeoutSeconds() {
 function hindsightConsolidationLlmTimeoutSeconds() {
   return clientBudgetSeconds(LITELLM_TIMEOUT_TIERS.consolidation);
 }
-function hindsightLlmBudgetEnv() {
-  const maxCompletionTokens = HINDSIGHT_DEFAULT_RETAIN_MAX_COMPLETION_TOKENS;
+function hindsightLlmBudgetEnv(llm) {
+  const contextBudget = resolveCheckedHindsightContextBudget(llm);
+  const maxCompletionTokens = Math.min(HINDSIGHT_DEFAULT_RETAIN_MAX_COMPLETION_TOKENS, contextBudget.retain.maxCompletionTokens);
   const interactiveS = hindsightInteractiveLlmTimeoutSeconds();
   const retainS = hindsightRetainClientTimeoutSeconds();
   const consolidationS = hindsightConsolidationLlmTimeoutSeconds();
@@ -15709,7 +16083,16 @@ function hindsightLlmBudgetEnv() {
     ["HINDSIGHT_API_LLM_TIMEOUT", String(interactiveS)],
     ["HINDSIGHT_API_REFLECT_LLM_TIMEOUT", String(interactiveS)],
     ["HINDSIGHT_API_RETAIN_LLM_TIMEOUT", String(retainS)],
-    ["HINDSIGHT_API_CONSOLIDATION_LLM_TIMEOUT", String(consolidationS)]
+    ["HINDSIGHT_API_CONSOLIDATION_LLM_TIMEOUT", String(consolidationS)],
+    ["HINDSIGHT_API_CONSOLIDATION_LLM_BATCH_SIZE", String(contextBudget.consolidation.batchSize)],
+    [
+      "HINDSIGHT_API_CONSOLIDATION_MAX_COMPLETION_TOKENS",
+      String(contextBudget.consolidation.maxCompletionTokens)
+    ],
+    [
+      "HINDSIGHT_API_REFLECT_MAX_CONTEXT_TOKENS",
+      String(contextBudget.reflect.maxContextTokens)
+    ]
   ];
 }
 function isPortFree(port) {
@@ -15838,15 +16221,6 @@ 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;
@@ -15869,6 +16243,11 @@ function hindsightNeedsHostNetwork(llm, litellm) {
     return true;
   return collectHindsightLlmBaseUrls(llm).some(isLoopbackHttpUrl);
 }
+function hindsightLocalLlmEnabled(llm, litellm, override) {
+  if (override !== undefined)
+    return override;
+  return collectHindsightLlmBaseUrls(llm, litellm).some(isSelfHostedHttpUrl);
+}
 function pickHindsightLiteLlmProbeUrl(llm, litellm) {
   return collectHindsightLlmBaseUrls(llm, litellm)[0];
 }
@@ -15885,7 +16264,22 @@ function buildLiteLlmAwareHealthPy(apiPort, litellmBaseUrl) {
 function buildLiteLlmAwareHealthCmd(apiPort, litellmBaseUrl) {
   return `python3 -c "${buildLiteLlmAwareHealthPy(apiPort, litellmBaseUrl)}"`;
 }
-function startHindsight(ports, litellm, imageTag, llm, mirrorDir) {
+function hindsightGpuEnabled(override) {
+  if (override !== undefined)
+    return override;
+  const caps = loadHostCapabilities();
+  return caps?.voice?.gpuPresent === true && caps?.voice?.containerToolkit === true;
+}
+function hindsightPerfEnvPairs(llm, litellm, gpu, perf) {
+  return hindsightPerfEnv({
+    gpu: hindsightGpuEnabled(gpu),
+    localLlm: hindsightLocalLlmEnabled(llm, litellm, perf?.localLlm)
+  }, resolveHindsightPerfOverrides(perf?.env, perf?.processEnv));
+}
+function hindsightPgEnvPairs(perf) {
+  return hindsightPgEnv(resolveHindsightPgOverrides(perf?.env, perf?.processEnv));
+}
+function startHindsight(ports, litellm, imageTag, llm, mirrorDir, gpu, perf) {
   const apiPort = ports?.apiPort ?? HINDSIGHT_DEFAULT_API_PORT;
   const uiPort = ports?.uiPort ?? HINDSIGHT_DEFAULT_UI_PORT;
   const { provider: llmProvider, model: llmModel } = resolveHindsightLlm(llm, litellm);
@@ -15910,17 +16304,17 @@ function startHindsight(ports, litellm, imageTag, llm, mirrorDir) {
     `HINDSIGHT_API_RECALL_MAX_CONCURRENT=${HINDSIGHT_DEFAULT_RECALL_MAX_CONCURRENT}`,
     "-e",
     `HINDSIGHT_API_REFLECT_WALL_TIMEOUT=${HINDSIGHT_DEFAULT_REFLECT_WALL_TIMEOUT_S}`,
-    ...hindsightLlmBudgetEnv().flatMap(([k, v]) => ["-e", `${k}=${v}`]),
-    "-e",
-    `HINDSIGHT_API_CONSOLIDATION_LLM_BATCH_SIZE=${HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_BATCH_SIZE}`,
+    ...hindsightLlmBudgetEnv(llm).flatMap(([k, v]) => ["-e", `${k}=${v}`]),
     "-e",
     `HINDSIGHT_API_WORKER_CONSOLIDATION_MAX_SLOTS=${HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_SLOTS}`,
     "-e",
-    `HINDSIGHT_API_CONSOLIDATION_LLM_PARALLELISM=${HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_PARALLELISM}`,
+    `HINDSIGHT_API_WORKER_CONSOLIDATION_SLOT_LIMIT=${HINDSIGHT_DEFAULT_CONSOLIDATION_SLOT_LIMIT}`,
     "-e",
     `HINDSIGHT_API_CONSOLIDATION_MAX_MEMORIES_PER_ROUND=${HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND}`,
     "-e",
-    `HINDSIGHT_API_WORKER_ID=${HINDSIGHT_DEFAULT_WORKER_ID}`
+    `HINDSIGHT_API_WORKER_ID=${HINDSIGHT_DEFAULT_WORKER_ID}`,
+    ...hindsightPerfEnvPairs(llm, litellm, gpu, perf).flatMap(([k, v]) => ["-e", `${k}=${v}`]),
+    ...hindsightPgEnvPairs(perf).flatMap(([k, v]) => ["-e", `${k}=${v}`])
   ];
   if (llmProvider === "claude-code") {
     envArgs.push("-e", `ANTHROPIC_MODEL=${llmModel}`);
@@ -15943,6 +16337,7 @@ x-litellm-tags: service:hindsight`);
     `--memory-reservation=${HINDSIGHT_DEFAULT_MEM_RESERVATION}`,
     `--pids-limit=${HINDSIGHT_DEFAULT_PIDS_LIMIT}`,
     `--shm-size=${HINDSIGHT_DEFAULT_SHM_SIZE}`,
+    ...hindsightGpuEnabled(gpu) ? ["--gpus", "all"] : [],
     ...(() => {
       const hostNet = hindsightNeedsHostNetwork(llm, litellm);
       const healthApiPort = hostNet ? apiPort : 8888;
@@ -16078,10 +16473,11 @@ function getHindsightStatus() {
     return null;
   }
 }
-function generateHindsightComposeSnippet(llm, mirrorDir, litellm) {
+function generateHindsightComposeSnippet(llm, mirrorDir, litellm, gpu, perf) {
   const { provider: llmProvider, model: llmModel } = resolveHindsightLlm(llm, litellm);
   const perOpLlm = resolveHindsightPerOpLlm(llm);
   const hostNetwork = hindsightNeedsHostNetwork(llm, litellm);
+  const gpuEnabled = hindsightGpuEnabled(gpu);
   const apiPort = HINDSIGHT_DEFAULT_API_PORT;
   const internalApiPort = hostNetwork ? apiPort : 8888;
   const probeUrl = pickHindsightLiteLlmProbeUrl(llm, litellm);
@@ -16141,16 +16537,26 @@ function generateHindsightComposeSnippet(llm, mirrorDir, litellm) {
     `      - HINDSIGHT_API_RERANKER_LOCAL_MAX_CONCURRENT=${HINDSIGHT_DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT}`,
     `      - HINDSIGHT_API_RECALL_MAX_CONCURRENT=${HINDSIGHT_DEFAULT_RECALL_MAX_CONCURRENT}`,
     `      - HINDSIGHT_API_REFLECT_WALL_TIMEOUT=${HINDSIGHT_DEFAULT_REFLECT_WALL_TIMEOUT_S}`,
-    ...hindsightLlmBudgetEnv().map(([k, v]) => `      - ${k}=${v}`),
-    `      - HINDSIGHT_API_CONSOLIDATION_LLM_BATCH_SIZE=${HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_BATCH_SIZE}`,
+    ...hindsightLlmBudgetEnv(llm).map(([k, v]) => `      - ${k}=${v}`),
     `      - HINDSIGHT_API_WORKER_CONSOLIDATION_MAX_SLOTS=${HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_SLOTS}`,
-    `      - HINDSIGHT_API_CONSOLIDATION_LLM_PARALLELISM=${HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_PARALLELISM}`,
+    `      - HINDSIGHT_API_WORKER_CONSOLIDATION_SLOT_LIMIT=${HINDSIGHT_DEFAULT_CONSOLIDATION_SLOT_LIMIT}`,
     `      - HINDSIGHT_API_CONSOLIDATION_MAX_MEMORIES_PER_ROUND=${HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND}`,
     `      - HINDSIGHT_API_WORKER_ID=${HINDSIGHT_DEFAULT_WORKER_ID}`,
+    ...hindsightPerfEnvPairs(llm, litellm, gpu, perf).map(([k, v]) => `      - ${k}=${v}`),
+    ...hindsightPgEnvPairs(perf).map(([k, v]) => `      - ${k}=${v}`),
     `    mem_limit: ${HINDSIGHT_DEFAULT_MEM_LIMIT}`,
     `    mem_reservation: ${HINDSIGHT_DEFAULT_MEM_RESERVATION}`,
     `    pids_limit: ${HINDSIGHT_DEFAULT_PIDS_LIMIT}`,
     `    shm_size: ${HINDSIGHT_DEFAULT_SHM_SIZE}`,
+    ...gpuEnabled ? [
+      "    deploy:",
+      "      resources:",
+      "        reservations:",
+      "          devices:",
+      "            - driver: nvidia",
+      "              count: 1",
+      '              capabilities: ["gpu"]'
+    ] : [],
     "    healthcheck:",
     `      test: ${JSON.stringify(["CMD", "python3", "-c", healthPy])}`,
     "      interval: 30s",
@@ -16236,7 +16642,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_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_RETAIN_CHUNK_SIZE = 3000, HINDSIGHT_DEFAULT_RETAIN_MAX_COMPLETION_TOKENS = 16384, HINDSIGHT_RETAIN_MIN_TOKENS_PER_SECOND = 80.6, HINDSIGHT_RETAIN_CLIENT_DEADLINE_S, 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, DOCKER_PROBE_TIMEOUT_MS, defaultDockerProbe = (args) => {
+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_RETAIN_CHUNK_SIZE = 3000, HINDSIGHT_DEFAULT_RETAIN_MAX_COMPLETION_TOKENS = 16384, HINDSIGHT_RETAIN_MIN_TOKENS_PER_SECOND = 80.6, HINDSIGHT_RETAIN_CLIENT_DEADLINE_S, HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_SLOTS = 1, HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND = 500, HINDSIGHT_DEFAULT_CONSOLIDATION_SLOT_LIMIT = 6, 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, DOCKER_PROBE_TIMEOUT_MS, defaultDockerProbe = (args) => {
   try {
     return execFileSync("docker", args, {
       stdio: "pipe",
@@ -16251,6 +16657,11 @@ var HINDSIGHT_DEFAULT_API_PORT = 18888, HINDSIGHT_DEFAULT_UI_PORT = 9999, HINDSI
 var init_hindsight = __esm(() => {
   init_model_command();
   init_timeout_budget();
+  init_host_capabilities();
+  init_hindsight_perf_defaults();
+  init_hindsight_pg_defaults();
+  init_hindsight_context_budget();
+  init_hindsight_perf_defaults();
   HINDSIGHT_DEFAULT_MCP_URL = `http://127.0.0.1:${HINDSIGHT_DEFAULT_API_PORT}/mcp/`;
   HINDSIGHT_DEFAULT_API_BASE_URL = HINDSIGHT_DEFAULT_MCP_URL.replace(/\/mcp\/?$/, "");
   HINDSIGHT_IMAGE = `${HINDSIGHT_IMAGE_REPO}:latest`;
@@ -17021,7 +17432,7 @@ function parseSocketIdentity(socketPath, spec) {
 
 // src/vault/broker/peercred.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { readFileSync as readFileSync5, readlinkSync as readlinkSync2, fstatSync } from "node:fs";
+import { readFileSync as readFileSync6, readlinkSync as readlinkSync2, fstatSync } from "node:fs";
 function socketPathToIdentity(socketPath) {
   return parseSocketIdentity(socketPath, {
     patterns: [SOCKET_PATH_AGENT_RE, SOCKET_PATH_AGENT_SUBDIR_RE],
@@ -17102,7 +17513,7 @@ function findClientPidByServerInode(rows, socketPath, serverInode) {
 }
 function readUid(pid) {
   try {
-    const status = readFileSync5(`/proc/${pid}/status`, "utf8");
+    const status = readFileSync6(`/proc/${pid}/status`, "utf8");
     const m = status.match(/^Uid:\s+(\d+)/m);
     if (!m)
       return null;
@@ -17120,7 +17531,7 @@ function readExe(pid) {
 }
 function readSystemdUnit(pid) {
   try {
-    const content = readFileSync5(`/proc/${pid}/cgroup`, "utf8");
+    const content = readFileSync6(`/proc/${pid}/cgroup`, "utf8");
     const lines = content.split(`
 `);
     for (const line of lines) {
@@ -17287,7 +17698,7 @@ var init_agent_uid = __esm(() => {
 
 // src/agents/agent-owned-tree.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync as existsSync5, lstatSync, readdirSync as readdirSync2, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync6, lstatSync, readdirSync as readdirSync2, statSync as statSync3 } from "node:fs";
 import { join as join3 } from "node:path";
 function scopedAssertCandidates(agentDir) {
   return [
@@ -17306,7 +17717,7 @@ function chownScopedTree(uid, gid, agentDir) {
   ownershipRuntime.chownShallow(uid, gid, [agentDir, ...children]);
   for (const sub of SCOPED_RECURSIVE_SUBDIRS) {
     const subPath = join3(agentDir, sub);
-    if (existsSync5(subPath)) {
+    if (existsSync6(subPath)) {
       ownershipRuntime.chownTree(uid, gid, subPath);
     }
   }
@@ -17314,7 +17725,7 @@ function chownScopedTree(uid, gid, agentDir) {
 function alignAgentTreeOwnershipIfRoot(name, agentDir) {
   if (ownershipRuntime.geteuid() !== 0)
     return null;
-  if (!existsSync5(agentDir))
+  if (!existsSync6(agentDir))
     return null;
   const uid = allocateAgentUid(name);
   const scoped = ownershipRuntime.scopedSweepEnabled();
@@ -17401,7 +17812,7 @@ var init_agent_owned_tree = __esm(() => {
 
 // src/agents/generation-stamp.ts
 import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "node:fs";
 import { join as join4 } from "node:path";
 function sha256Text(s) {
   return createHash3("sha256").update(s, "utf-8").digest("hex");
@@ -17424,11 +17835,11 @@ function hashManagedClaudeMd(content) {
 }
 function hashStampedFileOnDisk(agentDir, rel) {
   const p = join4(agentDir, rel);
-  if (!existsSync6(p))
+  if (!existsSync7(p))
     return null;
   let content;
   try {
-    content = readFileSync6(p, "utf-8");
+    content = readFileSync7(p, "utf-8");
   } catch {
     return null;
   }
@@ -17451,15 +17862,15 @@ function writeGenerationStamp(agentDir, stamp) {
     configHash: stamp.configHash,
     files: stamp.files
   };
-  writeFileSync(join4(agentDir, GENERATION_STAMP_FILE), JSON.stringify(full, null, 2) + `
+  writeFileSync2(join4(agentDir, GENERATION_STAMP_FILE), JSON.stringify(full, null, 2) + `
 `, "utf-8");
 }
 function readGenerationStamp(agentDir) {
   const p = join4(agentDir, GENERATION_STAMP_FILE);
-  if (!existsSync6(p))
+  if (!existsSync7(p))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync6(p, "utf-8"));
+    const parsed = JSON.parse(readFileSync7(p, "utf-8"));
     if (parsed?.version !== 1 || typeof parsed.files !== "object" || parsed.files === null || Array.isArray(parsed.files)) {
       return null;
     }
@@ -17976,10 +18387,10 @@ var init_cron_introspect = __esm(() => {
 import { join as join5 } from "node:path";
 import { homedir as homedir2 } from "node:os";
 import {
-  existsSync as existsSync7,
-  mkdirSync,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync2,
   appendFileSync,
-  readFileSync as readFileSync7
+  readFileSync as readFileSync8
 } from "node:fs";
 function auditPathFor(agent) {
   return join5(AUDIT_ROOT, agent, "agent-config.jsonl");
@@ -17996,8 +18407,8 @@ function appendAudit(agent, cmd, args, exit, opts = {}) {
   const path = opts.auditPath ?? auditPathFor(agent);
   const dir = path.slice(0, path.lastIndexOf("/"));
   try {
-    if (!existsSync7(dir)) {
-      mkdirSync(dir, { recursive: true });
+    if (!existsSync8(dir)) {
+      mkdirSync2(dir, { recursive: true });
     }
     appendFileSync(path, JSON.stringify(row) + `
 `, { flag: "a" });
@@ -18008,7 +18419,7 @@ function isContainerContext(env2 = process.env, opts = {}) {
     return true;
   const probe = opts.dockerEnvPath ?? "/.dockerenv";
   try {
-    if (existsSync7(probe))
+    if (existsSync8(probe))
       return true;
   } catch {}
   return false;
@@ -18136,11 +18547,11 @@ function getAgentSlice(config, agent) {
 }
 function readAuditTail(agent, limit, opts = {}) {
   const path = opts.auditPath ?? auditPathFor(agent);
-  if (!existsSync7(path))
+  if (!existsSync8(path))
     return [];
   let raw;
   try {
-    raw = readFileSync7(path, "utf-8");
+    raw = readFileSync8(path, "utf-8");
   } catch {
     return [];
   }
@@ -23946,7 +24357,7 @@ var require_lib = __commonJS((exports, module) => {
 });
 
 // src/agents/profiles.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync2, existsSync as existsSync8, readdirSync as readdirSync3, statSync as statSync4, copyFileSync, mkdirSync as mkdirSync2, realpathSync } from "node:fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync3, existsSync as existsSync9, readdirSync as readdirSync3, statSync as statSync4, copyFileSync, mkdirSync as mkdirSync3, realpathSync } from "node:fs";
 import { resolve as resolve4, join as join6, sep as pathSep } from "node:path";
 function resolveProfilesRoot() {
   const envOverride = process.env.SWITCHROOM_PROFILES_ROOT?.trim();
@@ -23958,7 +24369,7 @@ function resolveProfilesRoot() {
     resolve4(import.meta.dirname, "profiles")
   ];
   for (const candidate of candidates) {
-    if (existsSync8(candidate)) {
+    if (existsSync9(candidate)) {
       return candidate;
     }
   }
@@ -23978,11 +24389,11 @@ function getProfilePath(profileName) {
   if (real !== PROFILES_ROOT && !real.startsWith(PROFILES_ROOT + pathSep)) {
     throw new Error(`Invalid profile name: ${profileName}`);
   }
-  if (existsSync8(requested) && hasProfileFiles(requested)) {
+  if (existsSync9(requested) && hasProfileFiles(requested)) {
     return requested;
   }
   const fallback = resolve4(PROFILES_ROOT, "default");
-  if (existsSync8(fallback)) {
+  if (existsSync9(fallback)) {
     return fallback;
   }
   throw new Error(`Profile not found: ${profileName} (searched ${PROFILES_ROOT})`);
@@ -24012,19 +24423,19 @@ function getBaseProfilePath() {
   return resolve4(PROFILES_ROOT, "_base");
 }
 function renderTemplate(templatePath, context) {
-  const source = readFileSync8(templatePath, "utf-8");
+  const source = readFileSync9(templatePath, "utf-8");
   const template = import_handlebars.default.compile(source, { noEscape: true });
   return template(context);
 }
 function copyProfileSkills(profilePath, destPath) {
   const skillsSrc = join6(profilePath, "skills");
-  if (!existsSync8(skillsSrc)) {
+  if (!existsSync9(skillsSrc)) {
     return;
   }
   copyDirRecursive(skillsSrc, destPath);
 }
 function copyDirRecursive(src, dest) {
-  mkdirSync2(dest, { recursive: true });
+  mkdirSync3(dest, { recursive: true });
   const entries = readdirSync3(src);
   for (const entry of entries) {
     const srcPath = join6(src, entry);
@@ -24033,7 +24444,7 @@ function copyDirRecursive(src, dest) {
     if (stat.isDirectory()) {
       copyDirRecursive(srcPath, destPath);
     } else {
-      if (!existsSync8(destPath)) {
+      if (!existsSync9(destPath)) {
         copyFileSync(srcPath, destPath);
       }
     }
@@ -24041,49 +24452,49 @@ function copyDirRecursive(src, dest) {
 }
 function renderVaultProtocolFragment(context = {}, profilesRoot = PROFILES_ROOT) {
   const fragPath = join6(resolve4(profilesRoot, "_shared"), "vault-protocol.md.hbs");
-  if (!existsSync8(fragPath))
+  if (!existsSync9(fragPath))
     return "";
-  const source = readFileSync8(fragPath, "utf-8");
+  const source = readFileSync9(fragPath, "utf-8");
   const template = import_handlebars.default.compile(source, { noEscape: true });
   return template(context).trimEnd();
 }
 function renderAgentSelfServiceFragment(context = {}, profilesRoot = PROFILES_ROOT) {
   const fragPath = join6(resolve4(profilesRoot, "_shared"), "agent-self-service.md.hbs");
-  if (!existsSync8(fragPath))
+  if (!existsSync9(fragPath))
     return "";
-  const source = readFileSync8(fragPath, "utf-8");
+  const source = readFileSync9(fragPath, "utf-8");
   const template = import_handlebars.default.compile(source, { noEscape: true });
   return template(context).trimEnd();
 }
 function renderExecutionDisciplineFragment(context = {}, profilesRoot = PROFILES_ROOT) {
   const fragPath = join6(resolve4(profilesRoot, "_shared"), "execution-discipline.md.hbs");
-  if (!existsSync8(fragPath))
+  if (!existsSync9(fragPath))
     return "";
-  const source = readFileSync8(fragPath, "utf-8");
+  const source = readFileSync9(fragPath, "utf-8");
   const template = import_handlebars.default.compile(source, { noEscape: true });
   return template(context).trimEnd();
 }
 function renderDevProtocolFragment(context = {}, profilesRoot = PROFILES_ROOT) {
   const fragPath = join6(resolve4(profilesRoot, "_shared"), "dev-protocol.md.hbs");
-  if (!existsSync8(fragPath))
+  if (!existsSync9(fragPath))
     return "";
-  const source = readFileSync8(fragPath, "utf-8");
+  const source = readFileSync9(fragPath, "utf-8");
   const template = import_handlebars.default.compile(source, { noEscape: true });
   return template(context).trimEnd();
 }
 function renderDelegationGoldenRuleFragment(context = {}, profilesRoot = PROFILES_ROOT) {
   const fragPath = join6(resolve4(profilesRoot, "_shared"), "delegation-golden-rule.md.hbs");
-  if (!existsSync8(fragPath))
+  if (!existsSync9(fragPath))
     return "";
-  const source = readFileSync8(fragPath, "utf-8");
+  const source = readFileSync9(fragPath, "utf-8");
   const template = import_handlebars.default.compile(source, { noEscape: true });
   return template(context).trimEnd();
 }
 function renderReplyDisciplineFragment(context = {}, profilesRoot = PROFILES_ROOT) {
   const fragPath = join6(resolve4(profilesRoot, "_shared"), "reply-discipline.md.hbs");
-  if (!existsSync8(fragPath))
+  if (!existsSync9(fragPath))
     return "";
-  const source = readFileSync8(fragPath, "utf-8");
+  const source = readFileSync9(fragPath, "utf-8");
   const template = import_handlebars.default.compile(source, { noEscape: true });
   return template(context).trimEnd();
 }
@@ -24091,14 +24502,14 @@ function renderProfileClaudeTemplate(profileName, profilesRoot = PROFILES_ROOT)
   const profileDir = resolve4(profilesRoot, profileName);
   const hbsPath = join6(profileDir, "CLAUDE.md.hbs");
   const outPath = join6(profileDir, "CLAUDE.md");
-  if (!existsSync8(hbsPath)) {
+  if (!existsSync9(hbsPath)) {
     return { wrote: false, path: outPath };
   }
-  const source = readFileSync8(hbsPath, "utf-8");
+  const source = readFileSync9(hbsPath, "utf-8");
   const template = import_handlebars.default.compile(source, { noEscape: true });
   const rendered = template({ profile: profileName });
   try {
-    writeFileSync2(outPath, rendered, "utf-8");
+    writeFileSync3(outPath, rendered, "utf-8");
     return { wrote: true, path: outPath };
   } catch (err) {
     const code = err.code;
@@ -24123,8 +24534,8 @@ var init_profiles = __esm(() => {
   SHARED_FRAGMENTS = ["vault-protocol", "agent-self-service", "execution-discipline", "reply-discipline", "dev-protocol"];
   for (const name of SHARED_FRAGMENTS) {
     const fragPath = join6(SHARED_FRAGMENTS_DIR, `${name}.md.hbs`);
-    if (existsSync8(fragPath)) {
-      import_handlebars.default.registerPartial(name, readFileSync8(fragPath, "utf-8"));
+    if (existsSync9(fragPath)) {
+      import_handlebars.default.registerPartial(name, readFileSync9(fragPath, "utf-8"));
     }
   }
 });
@@ -24289,9 +24700,9 @@ function bindingsForAgent(agentName, mw, microsoftAccounts) {
 }
 
 // src/agents/reconcile-default-skills.ts
-import { existsSync as existsSync9, lstatSync as lstatSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync4, readlinkSync as readlinkSync3, rmSync as rmSync2, symlinkSync } from "node:fs";
+import { existsSync as existsSync10, lstatSync as lstatSync2, mkdirSync as mkdirSync4, readdirSync as readdirSync4, readlinkSync as readlinkSync3, rmSync as rmSync2, symlinkSync } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { dirname as dirname2, isAbsolute, join as join7, relative, resolve as resolve5 } from "node:path";
+import { dirname as dirname3, isAbsolute, join as join7, relative, resolve as resolve5 } from "node:path";
 function warnMissingPoolDir(poolDir) {
   if (warnedMissingPool.has(poolDir))
     return;
@@ -24322,10 +24733,10 @@ function isOwnedStaleLink(target, poolDir) {
   return false;
 }
 function absoluteLinkTarget(linkPath, storedTarget) {
-  return isAbsolute(storedTarget) ? storedTarget : resolve5(dirname2(linkPath), storedTarget);
+  return isAbsolute(storedTarget) ? storedTarget : resolve5(dirname3(linkPath), storedTarget);
 }
 function linkTargetFor(dest, src) {
-  return relative(dirname2(dest), src);
+  return relative(dirname3(dest), src);
 }
 function isOwnedBundledLink(dest, poolDir) {
   let stored = null;
@@ -24338,7 +24749,7 @@ function isOwnedBundledLink(dest, poolDir) {
   }
   if (!stored)
     return false;
-  const resolved = isAbsolute(stored) ? stored : resolve5(dirname2(dest), stored);
+  const resolved = isAbsolute(stored) ? stored : resolve5(dirname3(dest), stored);
   const poolPrefix = poolDir.endsWith("/") ? poolDir : poolDir + "/";
   return resolved === poolDir || resolved.startsWith(poolPrefix);
 }
@@ -24355,12 +24766,12 @@ function reconcileAgentDefaultSkills(agentDir, optOuts = {}, defaults = getBuilt
     changed: false
   };
   const claudeDir = join7(agentDir, ".claude");
-  if (!existsSync9(claudeDir)) {
+  if (!existsSync10(claudeDir)) {
     return result;
   }
   const targetDir = join7(claudeDir, "skills");
-  mkdirSync3(targetDir, { recursive: true });
-  if (!existsSync9(poolDir)) {
+  mkdirSync4(targetDir, { recursive: true });
+  if (!existsSync10(poolDir)) {
     warnMissingPoolDir(poolDir);
     return result;
   }
@@ -24378,7 +24789,7 @@ function reconcileAgentDefaultSkills(agentDir, optOuts = {}, defaults = getBuilt
       continue;
     }
     const src = join7(poolDir, entry.key);
-    if (!existsSync9(src)) {
+    if (!existsSync10(src)) {
       result.missingFromPool.push(entry.key);
       warnMissingBuiltinDefault(poolDir, entry.key);
       if (isOwnedBundledLink(dest, poolDir)) {
@@ -24439,7 +24850,7 @@ function reconcileAgentDefaultSkills(agentDir, optOuts = {}, defaults = getBuilt
         continue;
       try {
         const st = lstatSync2(join7(poolDir, poolName));
-        if (st.isDirectory() && existsSync9(join7(poolDir, poolName, "SKILL.md"))) {
+        if (st.isDirectory() && existsSync10(join7(poolDir, poolName, "SKILL.md"))) {
           legitimate.add(poolName);
         }
       } catch {}
@@ -24518,25 +24929,25 @@ function applyTelegramProgressGuidance(body, args) {
 
 // src/telegram/state.ts
 import {
-  readFileSync as readFileSync9,
-  writeFileSync as writeFileSync3,
-  mkdirSync as mkdirSync4,
-  existsSync as existsSync10,
+  readFileSync as readFileSync10,
+  writeFileSync as writeFileSync4,
+  mkdirSync as mkdirSync5,
+  existsSync as existsSync11,
   renameSync as renameSync2,
   copyFileSync as copyFileSync2,
   unlinkSync
 } from "node:fs";
-import { basename as basename2, dirname as dirname3, resolve as resolve6 } from "node:path";
+import { basename as basename2, dirname as dirname4, resolve as resolve6 } from "node:path";
 function defaultStatePath() {
   return resolveStatePath("topics.json");
 }
 function loadTopicState(statePath) {
   const path = statePath ?? defaultStatePath();
-  if (!existsSync10(path)) {
+  if (!existsSync11(path)) {
     return { topics: {} };
   }
   try {
-    const raw = readFileSync9(path, "utf-8");
+    const raw = readFileSync10(path, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && parsed.topics && typeof parsed.topics === "object") {
       return parsed;
@@ -24553,19 +24964,19 @@ function loadTopicState(statePath) {
 }
 function saveTopicState(state, statePath) {
   const path = statePath ?? defaultStatePath();
-  const dir = dirname3(path);
-  if (!existsSync10(dir)) {
-    mkdirSync4(dir, { recursive: true });
+  const dir = dirname4(path);
+  if (!existsSync11(dir)) {
+    mkdirSync5(dir, { recursive: true });
   }
   const absDir = resolve6(dir);
   const tmp = resolve6(absDir, `.${basename2(path)}.${process.pid}.${Date.now()}.tmp`);
   try {
-    writeFileSync3(tmp, JSON.stringify(state, null, 2) + `
+    writeFileSync4(tmp, JSON.stringify(state, null, 2) + `
 `, "utf-8");
     renameSync2(tmp, path);
   } catch (err) {
     try {
-      if (existsSync10(tmp))
+      if (existsSync11(tmp))
         unlinkSync(tmp);
     } catch {}
     throw err;
@@ -24577,13 +24988,13 @@ var init_state = __esm(() => {
 
 // src/vault/flock.ts
 import {
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   openSync as openSync3,
   closeSync as closeSync3,
   writeSync as writeSync2,
   fsyncSync as fsyncSync2,
   unlinkSync as unlinkSync2,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync11,
   readdirSync as readdirSync5,
   rmdirSync,
   statSync as statSync5,
@@ -24594,7 +25005,7 @@ function lockPathFor(vaultPath) {
 }
 function readLockHolder(lockPath) {
   try {
-    const raw = readFileSync10(lockPath, "utf8");
+    const raw = readFileSync11(lockPath, "utf8");
     const lines = raw.split(`
 `);
     const pid = Number.parseInt(lines[0] ?? "", 10);
@@ -24610,7 +25021,7 @@ function readLockHolder(lockPath) {
 }
 function pidIsLive(pid) {
   if (process.platform === "linux") {
-    return existsSync11(`/proc/${pid}`);
+    return existsSync12(`/proc/${pid}`);
   }
   try {
     process.kill(pid, 0);
@@ -24646,8 +25057,8 @@ function pidStartTimeMs(pid) {
   if (process.platform !== "linux")
     return null;
   try {
-    const statLine = readFileSync10(`/proc/${pid}/stat`, "utf8");
-    const procStat = readFileSync10("/proc/stat", "utf8");
+    const statLine = readFileSync11(`/proc/${pid}/stat`, "utf8");
+    const procStat = readFileSync11("/proc/stat", "utf8");
     return parseProcStartTimeMs(statLine, procStat, Date.now());
   } catch {
     return null;
@@ -24670,7 +25081,7 @@ function lockFileMtimeIsOlderThan(lockPath, budgetMs) {
 }
 function clearStaleSentinelDir(lockPath) {
   try {
-    if (!existsSync11(lockPath))
+    if (!existsSync12(lockPath))
       return true;
     const s = statSync5(lockPath);
     if (!s.isDirectory())
@@ -24813,11 +25224,11 @@ __export(exports_vault, {
 });
 import { randomBytes as randomBytes2, scryptSync, createCipheriv, createDecipheriv } from "node:crypto";
 import {
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync12,
   writeSync as writeSync3,
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   renameSync as renameSync3,
-  mkdirSync as mkdirSync5,
+  mkdirSync as mkdirSync6,
   unlinkSync as unlinkSync3,
   fsyncSync as fsyncSync3,
   openSync as openSync4,
@@ -24825,15 +25236,15 @@ import {
   lstatSync as lstatSync3,
   realpathSync as realpathSync2
 } from "node:fs";
-import { dirname as dirname4, basename as basename3, resolve as resolve7 } from "node:path";
+import { dirname as dirname5, basename as basename3, resolve as resolve7 } from "node:path";
 function atomicWriteFileSync2(path, data, mode) {
   let effectivePath = path;
   try {
-    if (existsSync12(path) && lstatSync3(path).isSymbolicLink()) {
+    if (existsSync13(path) && lstatSync3(path).isSymbolicLink()) {
       effectivePath = realpathSync2(path);
     }
   } catch {}
-  const dir = dirname4(resolve7(effectivePath));
+  const dir = dirname5(resolve7(effectivePath));
   const tmp = resolve7(dir, `.${basename3(effectivePath)}.${process.pid}.${Date.now()}.tmp`);
   try {
     const fd = openSync4(tmp, "wx", mode);
@@ -24854,7 +25265,7 @@ function atomicWriteFileSync2(path, data, mode) {
     } catch {}
   } catch (err) {
     try {
-      if (existsSync12(tmp))
+      if (existsSync13(tmp))
         unlinkSync3(tmp);
     } catch {}
     throw err;
@@ -24967,12 +25378,12 @@ function detectFormat(value) {
   return null;
 }
 function createVault(passphrase, vaultPath) {
-  if (existsSync12(vaultPath)) {
+  if (existsSync13(vaultPath)) {
     throw new VaultError(`Vault file already exists: ${vaultPath}`);
   }
-  const dir = dirname4(vaultPath);
-  if (!existsSync12(dir)) {
-    mkdirSync5(dir, { recursive: true, mode: 448 });
+  const dir = dirname5(vaultPath);
+  if (!existsSync13(dir)) {
+    mkdirSync6(dir, { recursive: true, mode: 448 });
   }
   const salt = randomBytes2(16);
   const key = deriveKey(passphrase, salt);
@@ -24988,12 +25399,12 @@ function createVault(passphrase, vaultPath) {
   atomicWriteFileSync2(vaultPath, JSON.stringify(vaultFile, null, 2), 384);
 }
 function openVault(passphrase, vaultPath) {
-  if (!existsSync12(vaultPath)) {
+  if (!existsSync13(vaultPath)) {
     throw new VaultError(`Vault file not found: ${vaultPath}`);
   }
   let vaultFile;
   try {
-    vaultFile = JSON.parse(readFileSync11(vaultPath, "utf8"));
+    vaultFile = JSON.parse(readFileSync12(vaultPath, "utf8"));
   } catch {
     throw new VaultError(`Failed to read vault file: ${vaultPath}`);
   }
@@ -25015,7 +25426,7 @@ function openVault(passphrase, vaultPath) {
   return normalizeSecrets(vaultData.secrets ?? {});
 }
 function saveVault(passphrase, vaultPath, secrets) {
-  if (!existsSync12(vaultPath)) {
+  if (!existsSync13(vaultPath)) {
     throw new VaultError(`Vault file not found: ${vaultPath}`);
   }
   let releaseLock = null;
@@ -25030,7 +25441,7 @@ function saveVault(passphrase, vaultPath, secrets) {
   try {
     let vaultFile;
     try {
-      vaultFile = JSON.parse(readFileSync11(vaultPath, "utf8"));
+      vaultFile = JSON.parse(readFileSync12(vaultPath, "utf8"));
     } catch {
       throw new VaultError(`Failed to read vault file: ${vaultPath}`);
     }
@@ -25937,7 +26348,7 @@ __export(exports_resolver, {
 import {
   chmodSync,
   closeSync as closeSync5,
-  mkdirSync as mkdirSync6,
+  mkdirSync as mkdirSync7,
   mkdtempSync,
   openSync as openSync5,
   rmSync as rmSync3,
@@ -25997,7 +26408,7 @@ function materializationRoot() {
   const xdg = process.env.XDG_RUNTIME_DIR;
   if (xdg) {
     const base = join9(xdg, "switchroom", "vault");
-    mkdirSync6(base, { recursive: true, mode: 448 });
+    mkdirSync7(base, { recursive: true, mode: 448 });
     cachedRoot = mkdtempSync(join9(base, "run-"));
   } else {
     cachedRoot = mkdtempSync(join9(tmpdir(), "switchroom-vault-"));
@@ -26021,7 +26432,7 @@ function materializeFilesEntry(key, files) {
       rmSync3(dir, { recursive: true, force: true });
     } catch {}
   }
-  mkdirSync6(dir, { recursive: true, mode: 448 });
+  mkdirSync7(dir, { recursive: true, mode: 448 });
   chmodSync(dir, 448);
   const st = statSync7(dir);
   if (typeof process.getuid === "function" && st.uid !== process.getuid()) {
@@ -26178,7 +26589,7 @@ var init_resolver = __esm(() => {
 });
 
 // src/setup/onboarding.ts
-import { existsSync as existsSync14, copyFileSync as copyFileSync3, mkdirSync as mkdirSync7, writeFileSync as writeFileSync4, readFileSync as readFileSync13 } from "node:fs";
+import { existsSync as existsSync15, copyFileSync as copyFileSync3, mkdirSync as mkdirSync8, writeFileSync as writeFileSync5, readFileSync as readFileSync14 } from "node:fs";
 import { resolve as resolve8, join as join10 } from "node:path";
 function findExistingClaudeJson() {
   const home2 = process.env.HOME ?? "/root";
@@ -26190,7 +26601,7 @@ function findExistingClaudeJson() {
     resolve8(home2, ".claude", "config.json")
   ];
   for (const candidate of candidates) {
-    if (existsSync14(candidate)) {
+    if (existsSync15(candidate)) {
       return candidate;
     }
   }
@@ -26202,9 +26613,9 @@ function findExistingClaudeJson() {
 }
 function copyOnboardingState(sourcePath, agentDir, configDirName = ".claude") {
   const claudeDir = join10(agentDir, configDirName);
-  mkdirSync7(claudeDir, { recursive: true });
+  mkdirSync8(claudeDir, { recursive: true });
   const destPath = join10(claudeDir, ".claude.json");
-  if (!existsSync14(destPath)) {
+  if (!existsSync15(destPath)) {
     copyFileSync3(sourcePath, destPath);
   }
 }
@@ -26227,18 +26638,18 @@ function buildAccessJson(userId, forumChatId, topicId, opts = {}) {
 }
 function writeAccessJson(agentDir, userId, forumChatId, topicId, opts = {}) {
   const telegramDir = join10(agentDir, "telegram");
-  mkdirSync7(telegramDir, { recursive: true });
+  mkdirSync8(telegramDir, { recursive: true });
   const accessPath = join10(telegramDir, "access.json");
-  writeFileSync4(accessPath, buildAccessJson(userId, forumChatId, topicId, opts), {
+  writeFileSync5(accessPath, buildAccessJson(userId, forumChatId, topicId, opts), {
     encoding: "utf-8",
     mode: 384
   });
 }
 function writeAgentEnv(agentDir, botToken) {
   const telegramDir = join10(agentDir, "telegram");
-  mkdirSync7(telegramDir, { recursive: true });
+  mkdirSync8(telegramDir, { recursive: true });
   const envPath = join10(telegramDir, ".env");
-  writeFileSync4(envPath, `TELEGRAM_BOT_TOKEN=${botToken}
+  writeFileSync5(envPath, `TELEGRAM_BOT_TOKEN=${botToken}
 `, {
     encoding: "utf-8",
     mode: 384
@@ -26250,12 +26661,12 @@ function userConfigPath() {
 function saveUserConfig(userId, username) {
   const configPath = userConfigPath();
   const dir = join10(configPath, "..");
-  mkdirSync7(dir, { recursive: true });
+  mkdirSync8(dir, { recursive: true });
   const config = { userId };
   if (username) {
     config.username = username;
   }
-  writeFileSync4(configPath, JSON.stringify(config, null, 2) + `
+  writeFileSync5(configPath, JSON.stringify(config, null, 2) + `
 `, {
     encoding: "utf-8",
     mode: 384
@@ -26263,11 +26674,11 @@ function saveUserConfig(userId, username) {
 }
 function loadUserConfig() {
   const configPath = userConfigPath();
-  if (!existsSync14(configPath)) {
+  if (!existsSync15(configPath)) {
     return null;
   }
   try {
-    const raw = readFileSync13(configPath, "utf-8");
+    const raw = readFileSync14(configPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") {
       return parsed;
@@ -26279,11 +26690,11 @@ function loadUserConfig() {
 }
 function preTrustWorkspace(agentDir, configDirName = ".claude") {
   const configPath = join10(agentDir, configDirName, ".claude.json");
-  if (!existsSync14(configPath)) {
+  if (!existsSync15(configPath)) {
     return;
   }
   try {
-    const raw = readFileSync13(configPath, "utf-8");
+    const raw = readFileSync14(configPath, "utf-8");
     const config = JSON.parse(raw);
     if (!config.projects) {
       config.projects = {};
@@ -26295,7 +26706,7 @@ function preTrustWorkspace(agentDir, configDirName = ".claude") {
         allowedTools: []
       };
     }
-    writeFileSync4(configPath, JSON.stringify(config, null, 2) + `
+    writeFileSync5(configPath, JSON.stringify(config, null, 2) + `
 `, {
       encoding: "utf-8",
       mode: 384
@@ -26304,11 +26715,11 @@ function preTrustWorkspace(agentDir, configDirName = ".claude") {
 }
 function ensureMcpServersTrusted(agentDir, serverKeys, configDirName = ".claude") {
   const configPath = join10(agentDir, configDirName, ".claude.json");
-  if (!existsSync14(configPath)) {
+  if (!existsSync15(configPath)) {
     return;
   }
   try {
-    const raw = readFileSync13(configPath, "utf-8");
+    const raw = readFileSync14(configPath, "utf-8");
     const config = JSON.parse(raw);
     if (!config.projects) {
       config.projects = {};
@@ -26322,7 +26733,7 @@ function ensureMcpServersTrusted(agentDir, serverKeys, configDirName = ".claude"
     const existing = Array.isArray(project.enabledMcpjsonServers) ? project.enabledMcpjsonServers : [];
     project.enabledMcpjsonServers = Array.from(new Set([...existing, ...serverKeys]));
     config.projects[absDir] = project;
-    writeFileSync4(configPath, JSON.stringify(config, null, 2) + `
+    writeFileSync5(configPath, JSON.stringify(config, null, 2) + `
 `, {
       encoding: "utf-8",
       mode: 384
@@ -26333,14 +26744,14 @@ function ensureMcpServersTrusted(agentDir, serverKeys, configDirName = ".claude"
 }
 function createMinimalClaudeConfig(agentDir, configDirName = ".claude") {
   const claudeDir = join10(agentDir, configDirName);
-  mkdirSync7(claudeDir, { recursive: true });
+  mkdirSync8(claudeDir, { recursive: true });
   const configPath = join10(claudeDir, ".claude.json");
-  if (!existsSync14(configPath)) {
+  if (!existsSync15(configPath)) {
     const minimal = {
       hasCompletedOnboarding: true,
       numStartups: 1
     };
-    writeFileSync4(configPath, JSON.stringify(minimal, null, 2) + `
+    writeFileSync5(configPath, JSON.stringify(minimal, null, 2) + `
 `, {
       encoding: "utf-8",
       mode: 384
@@ -26351,8 +26762,8 @@ function seedCronConfigDir(agentDir, serverKeys) {
   const mainConfig = join10(agentDir, ".claude", ".claude.json");
   const cronDir = join10(agentDir, ".claude-cron");
   const cronConfig = join10(cronDir, ".claude.json");
-  mkdirSync7(cronDir, { recursive: true });
-  if (existsSync14(mainConfig)) {
+  mkdirSync8(cronDir, { recursive: true });
+  if (existsSync15(mainConfig)) {
     try {
       copyFileSync3(mainConfig, cronConfig);
     } catch {
@@ -26370,16 +26781,16 @@ var init_onboarding = __esm(() => {
 
 // src/repos/bare-clone.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { existsSync as existsSync15, mkdirSync as mkdirSync8 } from "node:fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync9 } from "node:fs";
 import { resolve as resolve9 } from "node:path";
 function bareClonePath(slug) {
   return resolveStatePath(`repos/${slug}.git`);
 }
 function ensureBareClone(slug, url) {
   const reposDir = resolveStatePath("repos");
-  mkdirSync8(reposDir, { recursive: true });
+  mkdirSync9(reposDir, { recursive: true });
   const clonePath = bareClonePath(slug);
-  if (!existsSync15(clonePath)) {
+  if (!existsSync16(clonePath)) {
     process.stderr.write(`[switchroom] repo "${slug}": cloning ${url} \u2026
 `);
     execFileSync4("git", ["clone", "--bare", url, clonePath], {
@@ -26409,7 +26820,7 @@ var init_bare_clone = __esm(() => {
 
 // src/repos/agent-worktree.ts
 import { execFileSync as execFileSync5 } from "node:child_process";
-import { existsSync as existsSync16, mkdirSync as mkdirSync9, readdirSync as readdirSync6 } from "node:fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync10, readdirSync as readdirSync6 } from "node:fs";
 import { join as join11, resolve as resolve10 } from "node:path";
 function agentBranchName(agentName) {
   return `agent/${agentName}/main`;
@@ -26468,8 +26879,8 @@ function ensureAgentWorktree(agentName, slug, bareClonePath2, agentDir) {
   const worktreePath = agentWorktreePath(agentDir, slug);
   const branch = agentBranchName(agentName);
   const defaultBranch = resolveDefaultBranch(bareClonePath2);
-  if (!existsSync16(worktreePath)) {
-    mkdirSync9(join11(agentDir, "work"), { recursive: true });
+  if (!existsSync17(worktreePath)) {
+    mkdirSync10(join11(agentDir, "work"), { recursive: true });
     if (branchExistsInBare(bareClonePath2, branch)) {
       execFileSync5("git", ["worktree", "add", worktreePath, branch], {
         cwd: bareClonePath2,
@@ -26524,7 +26935,7 @@ function ensureAgentWorktree(agentName, slug, bareClonePath2, agentDir) {
 function removeAgentWorktree(agentName, slug, bareClonePath2, agentDir) {
   const worktreePath = agentWorktreePath(agentDir, slug);
   const branch = agentBranchName(agentName);
-  if (existsSync16(worktreePath)) {
+  if (existsSync17(worktreePath)) {
     try {
       execFileSync5("git", ["worktree", "remove", "--force", worktreePath], {
         cwd: bareClonePath2,
@@ -26561,11 +26972,11 @@ var init_agent_worktree = () => {};
 
 // src/agents/scaffold.ts
 import {
-  existsSync as existsSync17,
-  mkdirSync as mkdirSync10,
-  writeFileSync as writeFileSync5,
+  existsSync as existsSync18,
+  mkdirSync as mkdirSync11,
+  writeFileSync as writeFileSync6,
   appendFileSync as appendFileSync2,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync15,
   renameSync as renameSync4,
   chmodSync as chmodSync2,
   symlinkSync as symlinkSync2,
@@ -26579,7 +26990,7 @@ import {
 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
 import { execSync, execFileSync as execFileSync6 } from "node:child_process";
-import { dirname as dirname5, isAbsolute as isAbsolute2, join as join12, relative as relative2, resolve as resolve11 } from "node:path";
+import { dirname as dirname6, isAbsolute as isAbsolute2, join as join12, relative as relative2, resolve as resolve11 } from "node:path";
 import { createHash as createHash4 } from "node:crypto";
 function prependReplyDiscipline(rendered, context) {
   const replyDiscipline = renderReplyDisciplineFragment(context);
@@ -26661,12 +27072,12 @@ function maybeWriteCronMcp(agentDir, mcpServers, cronSessionEnabled) {
     "switchroom-telegram": cronTelegram
   };
   const cronDir = join12(agentDir, ".claude-cron");
-  mkdirSync10(cronDir, { recursive: true });
+  mkdirSync11(cronDir, { recursive: true });
   const path = join12(cronDir, ".mcp.json");
   const content = JSON.stringify({ mcpServers: cronServers }, null, 2) + `
 `;
-  if (!existsSync17(path) || readFileSync14(path, "utf-8") !== content) {
-    writeFileSync5(path, content, { encoding: "utf-8", mode: 384 });
+  if (!existsSync18(path) || readFileSync15(path, "utf-8") !== content) {
+    writeFileSync6(path, content, { encoding: "utf-8", mode: 384 });
   }
   seedCronConfigDir(agentDir, Object.keys(cronServers));
   return path;
@@ -26677,13 +27088,13 @@ function alignAgentUid(name, agentDir, uid, opts = {}) {
   const auditDir = join12(homedir5(), ".switchroom", "audit", name);
   const configMirrorDir = join12(homedir5(), ".switchroom-config", "agents", name, "personal-skills");
   const paths = [];
-  if (existsSync17(agentDir))
+  if (existsSync18(agentDir))
     paths.push(agentDir);
-  if (existsSync17(logsDir))
+  if (existsSync18(logsDir))
     paths.push(logsDir);
-  if (existsSync17(auditDir))
+  if (existsSync18(auditDir))
     paths.push(auditDir);
-  if (existsSync17(configMirrorDir))
+  if (existsSync18(configMirrorDir))
     paths.push(configMirrorDir);
   if (paths.length === 0)
     return { chowned: false, paths: [] };
@@ -26700,7 +27111,7 @@ function alignAgentUid(name, agentDir, uid, opts = {}) {
     return { chowned: false, paths };
   try {
     const logPath = join12(homedir5(), ".switchroom", ".uid-alignment.log");
-    mkdirSync10(join12(homedir5(), ".switchroom"), { recursive: true });
+    mkdirSync11(join12(homedir5(), ".switchroom"), { recursive: true });
     const ts = new Date().toISOString();
     for (const prior of priors) {
       if (prior.uid !== undefined && prior.gid !== undefined && (prior.uid !== uid || prior.gid !== uid)) {
@@ -26756,16 +27167,16 @@ function refreshTelegramBotTokenEnv(agentDir, resolvedBotToken, changes) {
   if (!resolvedBotToken)
     return;
   const envPath = join12(agentDir, "telegram", ".env");
-  if (!existsSync17(envPath))
+  if (!existsSync18(envPath))
     return;
-  const current = readFileSync14(envPath, "utf-8");
+  const current = readFileSync15(envPath, "utf-8");
   if (!isTelegramEnvPlaceholder(current))
     return;
   const next = `TELEGRAM_BOT_TOKEN=${resolvedBotToken}
 `;
   if (next === current)
     return;
-  writeFileSync5(envPath, next, { encoding: "utf-8", mode: 384 });
+  writeFileSync6(envPath, next, { encoding: "utf-8", mode: 384 });
   changes.push(envPath);
 }
 function stripOfficialTelegramPlugin(payload) {
@@ -26793,10 +27204,10 @@ function setupPlugins(agentDir, useSwitchroomPlugin = false) {
   const globalPluginsDir = join12(home2, ".claude", "plugins");
   const agentPluginsDir = join12(agentDir, ".claude", "plugins");
   const agentMarketplacesDir = join12(agentPluginsDir, "marketplaces");
-  mkdirSync10(agentMarketplacesDir, { recursive: true });
+  mkdirSync11(agentMarketplacesDir, { recursive: true });
   const globalMarketplace = join12(globalPluginsDir, "marketplaces", "claude-plugins-official");
   const agentMarketplace = join12(agentMarketplacesDir, "claude-plugins-official");
-  if (existsSync17(globalMarketplace) && !existsSync17(agentMarketplace)) {
+  if (existsSync18(globalMarketplace) && !existsSync18(agentMarketplace)) {
     try {
       symlinkSync2(globalMarketplace, agentMarketplace);
     } catch {}
@@ -26805,11 +27216,11 @@ function setupPlugins(agentDir, useSwitchroomPlugin = false) {
   for (const file of configFiles) {
     const globalFile = join12(globalPluginsDir, file);
     const agentFile = join12(agentPluginsDir, file);
-    if (existsSync17(globalFile) && !existsSync17(agentFile)) {
+    if (existsSync18(globalFile) && !existsSync18(agentFile)) {
       try {
         if (useSwitchroomPlugin && file === "installed_plugins.json") {
-          const scrubbed = stripOfficialTelegramPlugin(readFileSync14(globalFile, "utf8"));
-          writeFileSync5(agentFile, scrubbed);
+          const scrubbed = stripOfficialTelegramPlugin(readFileSync15(globalFile, "utf8"));
+          writeFileSync6(agentFile, scrubbed);
         } else {
           copyFileSync4(globalFile, agentFile);
         }
@@ -26820,9 +27231,9 @@ function setupPlugins(agentDir, useSwitchroomPlugin = false) {
 function webkiteBinaryAvailable() {
   const override = process.env.SWITCHROOM_WEBKITE_BINARY;
   if (override !== undefined && override !== "") {
-    return existsSync17(override);
+    return existsSync18(override);
   }
-  return existsSync17(join12(homedir5(), ".switchroom", "bin", "webkite")) || existsSync17(WEBKITE_BINARY_CONTAINER_PATH);
+  return existsSync18(join12(homedir5(), ".switchroom", "bin", "webkite")) || existsSync18(WEBKITE_BINARY_CONTAINER_PATH);
 }
 function webkiteDenyForAgent(agentConfig) {
   if (agentConfig.mcp_servers?.["webkite"] === false)
@@ -26875,9 +27286,9 @@ function toHostHomePath(p) {
   return p;
 }
 function composeWithSidecar(renderedBase, sidecarPath) {
-  if (!existsSync17(sidecarPath))
+  if (!existsSync18(sidecarPath))
     return renderedBase;
-  const sidecar = readFileSync14(sidecarPath, "utf-8").trimEnd();
+  const sidecar = readFileSync15(sidecarPath, "utf-8").trimEnd();
   if (sidecar.length === 0)
     return renderedBase;
   return `${renderedBase.trimEnd()}
@@ -26895,8 +27306,8 @@ function resolveClaudeMdYoursSection(existingFileContent, sidecarPath) {
       return afterMarker.trimEnd();
     }
   }
-  if (existsSync17(sidecarPath)) {
-    const sidecar = readFileSync14(sidecarPath, "utf-8").trimEnd();
+  if (existsSync18(sidecarPath)) {
+    const sidecar = readFileSync15(sidecarPath, "utf-8").trimEnd();
     if (sidecar.length > 0) {
       const deprecatedPath = sidecarPath + ".deprecated";
       try {
@@ -26919,7 +27330,7 @@ ${yours.trimEnd()}
 }
 function renderSoulMd(profilePath, agentWorkspaceDir, soul) {
   const soulMdSrc = join12(profilePath, "workspace", "SOUL.md.hbs");
-  if (!existsSync17(soulMdSrc))
+  if (!existsSync18(soulMdSrc))
     return null;
   const rendered = renderTemplate(soulMdSrc, { soul });
   const customSoulPath = join12(agentWorkspaceDir, "SOUL.custom.md");
@@ -27007,7 +27418,7 @@ function migrateLegacySkillsDir(agentDir, skillsPool) {
     } catch {
       continue;
     }
-    const resolved = target ? isAbsolute2(target) ? target : resolve11(dirname5(entryPath), target) : null;
+    const resolved = target ? isAbsolute2(target) ? target : resolve11(dirname6(entryPath), target) : null;
     if (resolved && resolved.startsWith(skillsPool)) {
       try {
         rmSync4(entryPath, { force: true });
@@ -27018,7 +27429,7 @@ function migrateLegacySkillsDir(agentDir, skillsPool) {
 function syncGlobalSkills(agentDir, declared, skillsDirOverride) {
   const skillsPool = resolveSkillsPoolDir(skillsDirOverride);
   const agentSkillsDir = join12(agentDir, ".claude", "skills");
-  mkdirSync10(agentSkillsDir, { recursive: true });
+  mkdirSync11(agentSkillsDir, { recursive: true });
   migrateLegacySkillsDir(agentDir, skillsPool);
   for (const name of declared) {
     if (!name || name.includes("/") || name === "." || name === "..") {
@@ -27027,11 +27438,11 @@ function syncGlobalSkills(agentDir, declared, skillsDirOverride) {
     }
     const src = join12(skillsPool, name);
     const dest = join12(agentSkillsDir, name);
-    if (!existsSync17(src)) {
+    if (!existsSync18(src)) {
       console.warn(`  WARNING: skill "${name}" not found in pool (${skillsPool}) \u2014 skipping`);
       continue;
     }
-    const relTarget = relative2(dirname5(dest), src);
+    const relTarget = relative2(dirname6(dest), src);
     let linkStat;
     try {
       linkStat = lstatSync4(dest);
@@ -27047,7 +27458,7 @@ function syncGlobalSkills(agentDir, declared, skillsDirOverride) {
         if (target === relTarget) {
           continue;
         }
-        const resolved = target ? isAbsolute2(target) ? target : resolve11(dirname5(dest), target) : null;
+        const resolved = target ? isAbsolute2(target) ? target : resolve11(dirname6(dest), target) : null;
         if (resolved && resolved.startsWith(skillsPool)) {
           try {
             rmSync4(dest, { force: true });
@@ -27076,7 +27487,7 @@ function syncGlobalSkills(agentDir, declared, skillsDirOverride) {
     } catch {
       continue;
     }
-    const resolved = linkTarget ? isAbsolute2(linkTarget) ? linkTarget : resolve11(dirname5(entryPath), linkTarget) : null;
+    const resolved = linkTarget ? isAbsolute2(linkTarget) ? linkTarget : resolve11(dirname6(entryPath), linkTarget) : null;
     if (resolved && resolved.includes("/.switchroom/skills/_bundled/")) {
       continue;
     }
@@ -27087,13 +27498,13 @@ function syncGlobalSkills(agentDir, declared, skillsDirOverride) {
 }
 function installSwitchroomSkills(agentDir, opts = {}) {
   const builtinSkillsDir = resolve11(homedir5(), ".switchroom/skills/_bundled");
-  if (!existsSync17(builtinSkillsDir)) {
+  if (!existsSync18(builtinSkillsDir)) {
     process.stderr.write(`switchroom: bundled skills pool dir not found at ${builtinSkillsDir} \u2014 run \`switchroom update\` to install it.
 `);
     return;
   }
   const targetDir = join12(agentDir, ".claude", "skills");
-  mkdirSync10(targetDir, { recursive: true });
+  mkdirSync11(targetDir, { recursive: true });
   let entries;
   try {
     entries = readdirSync7(builtinSkillsDir);
@@ -27113,7 +27524,7 @@ function installSwitchroomSkills(agentDir, opts = {}) {
     const src = join12(builtinSkillsDir, name);
     try {
       const st = lstatSync4(src);
-      return st.isDirectory() && existsSync17(join12(src, "SKILL.md"));
+      return st.isDirectory() && existsSync18(join12(src, "SKILL.md"));
     } catch {
       return false;
     }
@@ -27135,7 +27546,7 @@ function installSwitchroomSkills(agentDir, opts = {}) {
       } catch {}
       if (!currentTarget)
         continue;
-      const resolvedTarget = isAbsolute2(currentTarget) ? currentTarget : resolve11(dirname5(dest), currentTarget);
+      const resolvedTarget = isAbsolute2(currentTarget) ? currentTarget : resolve11(dirname6(dest), currentTarget);
       if (resolvedTarget !== join12(builtinSkillsDir, name))
         continue;
       try {
@@ -27147,7 +27558,7 @@ function installSwitchroomSkills(agentDir, opts = {}) {
   for (const name of switchroomSkillNames) {
     const src = join12(builtinSkillsDir, name);
     const dest = join12(targetDir, name);
-    const relTarget = relative2(dirname5(dest), src);
+    const relTarget = relative2(dirname6(dest), src);
     let existing;
     try {
       existing = lstatSync4(dest);
@@ -27289,9 +27700,9 @@ function filterMcpServers(servers) {
   return Object.keys(out).length > 0 ? out : undefined;
 }
 function copyDirRecursive2(src, dest) {
-  if (!existsSync17(src))
+  if (!existsSync18(src))
     return;
-  mkdirSync10(dest, { recursive: true });
+  mkdirSync11(dest, { recursive: true });
   for (const entry of readdirSync7(src)) {
     const srcPath = join12(src, entry);
     const destPath = join12(dest, entry);
@@ -27307,17 +27718,17 @@ function copyDirRecursive2(src, dest) {
   }
 }
 function writeFileSyncIfChanged(filePath, content, mode) {
-  if (existsSync17(filePath)) {
+  if (existsSync18(filePath)) {
     try {
-      if (readFileSync14(filePath, "utf-8") === content)
+      if (readFileSync15(filePath, "utf-8") === content)
         return false;
     } catch {}
   }
-  writeFileSync5(filePath, content, mode !== undefined ? { encoding: "utf-8", mode } : "utf-8");
+  writeFileSync6(filePath, content, mode !== undefined ? { encoding: "utf-8", mode } : "utf-8");
   return true;
 }
 function dirContentEquals(src, dest, topLevelOverrides) {
-  if (!existsSync17(src) || !existsSync17(dest))
+  if (!existsSync18(src) || !existsSync18(dest))
     return false;
   let srcEntries;
   let destEntries;
@@ -27355,9 +27766,9 @@ function dirContentEquals(src, dest, topLevelOverrides) {
       try {
         const expected = topLevelOverrides?.[entry];
         if (expected !== undefined) {
-          if (readFileSync14(d, "utf-8") !== expected)
+          if (readFileSync15(d, "utf-8") !== expected)
             return false;
-        } else if (!readFileSync14(s).equals(readFileSync14(d))) {
+        } else if (!readFileSync15(s).equals(readFileSync15(d))) {
           return false;
         }
       } catch {
@@ -27369,14 +27780,14 @@ function dirContentEquals(src, dest, topLevelOverrides) {
 }
 function seedWorkspaceBootstrapFiles(params) {
   const profileWorkspaceDir = join12(params.profilePath, "workspace");
-  if (!existsSync17(profileWorkspaceDir)) {
+  if (!existsSync18(profileWorkspaceDir)) {
     return;
   }
   const agentWorkspaceDir = join12(params.agentDir, "workspace");
-  mkdirSync10(agentWorkspaceDir, { recursive: true });
+  mkdirSync11(agentWorkspaceDir, { recursive: true });
   const walk = (relDir) => {
     const srcDir = join12(profileWorkspaceDir, relDir);
-    if (!existsSync17(srcDir))
+    if (!existsSync18(srcDir))
       return;
     for (const entry of readdirSync7(srcDir)) {
       if (entry.startsWith(".") && entry !== ".gitkeep")
@@ -27385,7 +27796,7 @@ function seedWorkspaceBootstrapFiles(params) {
       const srcPath = join12(profileWorkspaceDir, relPath);
       const srcStat = statSync8(srcPath);
       if (srcStat.isDirectory()) {
-        mkdirSync10(join12(agentWorkspaceDir, relPath), { recursive: true });
+        mkdirSync11(join12(agentWorkspaceDir, relPath), { recursive: true });
         walk(relPath);
         continue;
       }
@@ -27400,10 +27811,10 @@ function seedWorkspaceBootstrapFiles(params) {
         const destPath = join12(agentWorkspaceDir, destRel);
         if (destRel === "SOUL.default.md") {
           const rendered = renderTemplate(srcPath, params.context);
-          const existed = existsSync17(destPath);
-          const current = existed ? readFileSync14(destPath, "utf8") : null;
+          const existed = existsSync18(destPath);
+          const current = existed ? readFileSync15(destPath, "utf8") : null;
           if (current !== rendered) {
-            writeFileSync5(destPath, rendered);
+            writeFileSync6(destPath, rendered);
             params.created.push(destPath);
           } else {
             params.skipped.push(destPath);
@@ -27419,7 +27830,7 @@ function seedWorkspaceBootstrapFiles(params) {
         writeIfMissing(destPath, renderFn, params.created, params.skipped);
       } else {
         const destPath = join12(agentWorkspaceDir, relPath);
-        if (!existsSync17(destPath)) {
+        if (!existsSync18(destPath)) {
           copyFileSync4(srcPath, destPath);
           params.created.push(destPath);
         } else {
@@ -27433,27 +27844,27 @@ function seedWorkspaceBootstrapFiles(params) {
 function migrateLegacyAgentsMdIfPresent(agentWorkspaceDir, created) {
   const agentsMd = join12(agentWorkspaceDir, "AGENTS.md");
   const claudeMd = join12(agentWorkspaceDir, "CLAUDE.md");
-  if (!existsSync17(agentsMd))
+  if (!existsSync18(agentsMd))
     return;
   const stat = lstatSync4(agentsMd);
   if (stat.isSymbolicLink())
     return;
-  if (existsSync17(claudeMd)) {
+  if (existsSync18(claudeMd)) {
     return;
   }
-  const content = readFileSync14(agentsMd, "utf-8");
-  writeFileSync5(claudeMd, content, "utf-8");
+  const content = readFileSync15(agentsMd, "utf-8");
+  writeFileSync6(claudeMd, content, "utf-8");
   rmSync4(agentsMd);
   created.push(claudeMd);
   console.log(source_default.dim(`  migrated legacy workspace/AGENTS.md \u2192 workspace/CLAUDE.md (content preserved)`));
 }
 function ensureClaudeMdSymlinks(agentWorkspaceDir, changes) {
   const claudeMd = join12(agentWorkspaceDir, "CLAUDE.md");
-  if (!existsSync17(claudeMd))
+  if (!existsSync18(claudeMd))
     return;
   for (const name of ["AGENTS.md", "AGENT.md"]) {
     const linkPath = join12(agentWorkspaceDir, name);
-    if (existsSync17(linkPath) || lstatExists(linkPath)) {
+    if (existsSync18(linkPath) || lstatExists(linkPath)) {
       const stat = lstatSync4(linkPath);
       if (stat.isSymbolicLink()) {
         const target = readlinkSync4(linkPath);
@@ -27484,7 +27895,7 @@ function initWorkspaceGitRepo(workspaceDir, agentName) {
     return false;
   }
   const gitDir = join12(workspaceDir, ".git");
-  if (existsSync17(gitDir)) {
+  if (existsSync18(gitDir)) {
     return true;
   }
   const gitignore = `# Ephemeral runtime state
@@ -27496,7 +27907,7 @@ Thumbs.db
 *.swp
 *~
 `;
-  writeFileSync5(join12(workspaceDir, ".gitignore"), gitignore, "utf-8");
+  writeFileSync6(join12(workspaceDir, ".gitignore"), gitignore, "utf-8");
   try {
     execSync("git init --quiet", { cwd: workspaceDir, stdio: "pipe" });
     execSync("git add -A", { cwd: workspaceDir, stdio: "pipe" });
@@ -27533,7 +27944,7 @@ function installHindsightPlugin(agentName, agentDir, switchroomConfig) {
   if (agentMemory?.auto_recall === false)
     return null;
   const sourcePath = resolveHindsightVendorPath();
-  if (!existsSync17(sourcePath)) {
+  if (!existsSync18(sourcePath)) {
     process.stderr.write(`installHindsightPlugin: vendor source missing at ${sourcePath} ` + `\u2014 hindsight plugin NOT installed for ${agentName}. ` + `Likely a packaging regression: check the npm tarball's files array.
 `);
     return null;
@@ -27544,13 +27955,13 @@ function installHindsightPlugin(agentName, agentDir, switchroomConfig) {
   let expectedSettings = null;
   try {
     const vendorSettingsPath = join12(sourcePath, "settings.json");
-    if (existsSync17(vendorSettingsPath)) {
-      expectedSettings = renderHindsightSettingsOverrides(readFileSync14(vendorSettingsPath, "utf-8"), additionalBanks, retainConfig);
+    if (existsSync18(vendorSettingsPath)) {
+      expectedSettings = renderHindsightSettingsOverrides(readFileSync15(vendorSettingsPath, "utf-8"), additionalBanks, retainConfig);
     }
   } catch {}
   const upToDate = dirContentEquals(sourcePath, destPath, expectedSettings != null ? { "settings.json": expectedSettings } : undefined);
   if (!upToDate) {
-    if (existsSync17(destPath)) {
+    if (existsSync18(destPath)) {
       rmSync4(destPath, { recursive: true, force: true });
     }
     copyDirRecursive2(sourcePath, destPath);
@@ -27571,11 +27982,11 @@ function resolveHindsightRetainConfig(switchroomConfig, agentName) {
 }
 function applyHindsightSettingsOverrides(pluginDestPath, additionalBanks, retainConfig) {
   const settingsPath = join12(pluginDestPath, "settings.json");
-  if (!existsSync17(settingsPath))
+  if (!existsSync18(settingsPath))
     return;
   let raw;
   try {
-    raw = readFileSync14(settingsPath, "utf-8");
+    raw = readFileSync15(settingsPath, "utf-8");
   } catch {
     return;
   }
@@ -27974,23 +28385,23 @@ function scaffoldAgent(name, agentConfigRaw, agentsDir, telegramConfig, switchro
     join12(agentDir, "telegram")
   ];
   for (const dir of dirs) {
-    mkdirSync10(dir, { recursive: true });
+    mkdirSync11(dir, { recursive: true });
   }
   writeIfChanged(join12(agentDir, "start.sh"), () => renderTemplate(join12(basePath, "start.sh.hbs"), context), created, skipped);
-  if (existsSync17(join12(agentDir, "start.sh"))) {
+  if (existsSync18(join12(agentDir, "start.sh"))) {
     chmodSync2(join12(agentDir, "start.sh"), 448);
   }
   if (context.cronSessionEnabled) {
     writeIfChanged(join12(agentDir, "cron-session.sh"), () => renderTemplate(join12(basePath, "cron-session.sh.hbs"), context), created, skipped);
-    if (existsSync17(join12(agentDir, "cron-session.sh"))) {
+    if (existsSync18(join12(agentDir, "cron-session.sh"))) {
       chmodSync2(join12(agentDir, "cron-session.sh"), 448);
     }
   }
   writeIfMissing(join12(agentDir, ".claude", "settings.json"), () => renderTemplate(join12(basePath, "settings.json.hbs"), context), created, skipped, 384);
   if (switchroomConfig) {
     const settingsPath = join12(agentDir, ".claude", "settings.json");
-    if (existsSync17(settingsPath)) {
-      const settings = JSON.parse(readFileSync14(settingsPath, "utf-8"));
+    if (existsSync18(settingsPath)) {
+      const settings = JSON.parse(readFileSync15(settingsPath, "utf-8"));
       if (!settings.mcpServers) {
         settings.mcpServers = {};
       }
@@ -28133,7 +28544,7 @@ function scaffoldAgent(name, agentConfigRaw, agentsDir, telegramConfig, switchro
   ];
   for (const { src, dest } of templateFiles) {
     const srcPath = join12(profilePath, src);
-    if (existsSync17(srcPath)) {
+    if (existsSync18(srcPath)) {
       const renderManaged = () => {
         let rendered = renderTemplate(srcPath, context);
         if (dest === "CLAUDE.md") {
@@ -28190,7 +28601,7 @@ function scaffoldAgent(name, agentConfigRaw, agentsDir, telegramConfig, switchro
     }
   }
   const phase5WorkspaceDir = join12(agentDir, "workspace");
-  mkdirSync10(phase5WorkspaceDir, { recursive: true });
+  mkdirSync11(phase5WorkspaceDir, { recursive: true });
   migrateLegacyAgentsMdIfPresent(phase5WorkspaceDir, created);
   seedWorkspaceBootstrapFiles({
     profilePath,
@@ -28203,9 +28614,9 @@ function scaffoldAgent(name, agentConfigRaw, agentsDir, telegramConfig, switchro
   });
   ensureClaudeMdSymlinks(phase5WorkspaceDir, created);
   const persistentHomeDir = join12(agentDir, "home");
-  mkdirSync10(persistentHomeDir, { recursive: true });
+  mkdirSync11(persistentHomeDir, { recursive: true });
   for (const sub of [".local/bin", ".npm-global", "bin"]) {
-    mkdirSync10(join12(persistentHomeDir, sub), { recursive: true });
+    mkdirSync11(join12(persistentHomeDir, sub), { recursive: true });
   }
   if (!isContainerContext() && process.env.HOME) {
     const dotSwitchroomLink = join12(persistentHomeDir, ".switchroom");
@@ -28247,7 +28658,7 @@ function scaffoldAgent(name, agentConfigRaw, agentsDir, telegramConfig, switchro
   const existingClaudeJson = findExistingClaudeJson();
   if (existingClaudeJson) {
     copyOnboardingState(existingClaudeJson, agentDir);
-    if (!existsSync17(join12(agentDir, ".claude", "config.json"))) {
+    if (!existsSync18(join12(agentDir, ".claude", "config.json"))) {
       writeIfMissing(join12(agentDir, ".claude", "config.json"), () => JSON.stringify({ hasCompletedOnboarding: true, numStartups: 1 }, null, 2) + `
 `, created, skipped, 384);
     }
@@ -28274,7 +28685,7 @@ This file is auto-maintained. Do not edit manually.
   writeFileSyncIfChanged(join12(agentDir, "telegram", "people.json"), buildPeopleJson(switchroomConfig), 384);
   if (agentConfig.subagents) {
     const agentsDir2 = join12(agentDir, ".claude", "agents");
-    mkdirSync10(agentsDir2, { recursive: true });
+    mkdirSync11(agentsDir2, { recursive: true });
     for (const [saName, saDef] of Object.entries(agentConfig.subagents)) {
       const mdPath = join12(agentsDir2, `${saName}.md`);
       if (!saDef.description) {
@@ -28331,13 +28742,13 @@ ${body}
   }
   {
     const telegramDir = join12(agentDir, "telegram");
-    if (existsSync17(telegramDir)) {
+    if (existsSync18(telegramDir)) {
       for (const file of readdirSync7(telegramDir)) {
         const isCronScript = CRON_SCRIPT_BASENAME_RE.test(file) || LEGACY_CRON_SCRIPT_BASENAME_RE.test(file);
         if (isCronScript) {
           unlinkSync4(join12(telegramDir, file));
           const sidecar = join12(telegramDir, file.replace(/\.sh$/, ".source"));
-          if (existsSync17(sidecar))
+          if (existsSync18(sidecar))
             unlinkSync4(sidecar);
         }
       }
@@ -28353,8 +28764,8 @@ ${body}
   setupPlugins(agentDir, usesSwitchroomTelegramPlugin(agentConfig));
   const agentSoulPath = join12(agentDir, "SOUL.md");
   const workspaceSoulPath = join12(agentDir, "workspace", "SOUL.md");
-  if (existsSync17(workspaceSoulPath)) {
-    if (existsSync17(agentSoulPath)) {
+  if (existsSync18(workspaceSoulPath)) {
+    if (existsSync18(agentSoulPath)) {
       const stat = lstatSync4(agentSoulPath);
       if (stat.isSymbolicLink()) {
         const target = readlinkSync4(agentSoulPath);
@@ -28684,7 +29095,7 @@ function buildSettingsHooksBlock(p) {
 ` + `  - Question with a short answer \u2192 just reply with the answer.
 ` + "  - Complex tool-driven work \u2192 go straight to the tools (the " + "compose-area preview is the ambient liveness signal), then reply " + 'once with the answer or a genuine mid-work pivot ("halfway ' + 'through \u2014 found an unexpected issue, want me to continue?"). Not ' + `"still working".
 
-` + "NARRATE YOUR INTENT (your reasoning is NOT shown to the user). The " + "user cannot see your thinking \u2014 only your tool activity and your " + "replies. So before you fire a burst of tools or work silently for a " + "while, first write ONE short plain-language line of intent as " + "ordinary working text (NOT a reply tool call): name what you are " + 'about to do and why \u2014 "Now checking the gateway logs to find why ' + 'the turn stalled". The framework mirrors that line into the live ' + "compose-area preview the user watches; because it is plain text and " + "not a reply, it is never a chat message and never pings. One intent " + "line before a silent stretch, in plain words, never raw tool names " + '("calling Bash", "Read(x)") and never a debug dump. And when you run ' + "a Bash command, always give it a plain-English `description` naming " + "the goal \u2014 that description, not the raw command, is what the user " + "sees. This intent narration is the ONE thing to keep saying; it is " + "NOT the placeholder ack banned above (that is a chat reply, which " + `you still skip).
+` + "LABEL THE WORK AS YOU DO IT. The user watches a live preview built " + "from your tool activity, so what you put in a tool call is what they " + "read. Two output requirements. FIRST: every Bash and tool call gets a " + 'plain-English `description` naming the goal \u2014 "Checking the gateway ' + 'logs to find why the turn stalled", never raw tool names ("calling ' + 'Bash", "Read(x)") and never a debug dump. That description, not the ' + "raw command, is what the user sees. SECOND: before a long stretch of " + "work, post ONE short status line saying what you are starting \u2014 one " + "line per stretch, in plain words. Emit it as the `description` on the " + "first tool call of the stretch, or as a status line through the " + "progress tool where you have one; do NOT leave it sitting as unsent " + "transcript text (see the reply rule below). This labelling is the ONE " + "thing to keep doing; it is NOT the placeholder ack banned above (that " + `is a chat reply, which you still skip).
 
 ` + 'Do NOT send a trailing confirmation after your answer \u2014 no "Done.", ' + '"Sent.", "Hope that helps." as a separate message once you have ' + "already replied. Your answer is the last thing the user should " + `see; a follow-up "Done." is dead-air clutter (and the user's ` + `device already pinged on the answer). Stop after the answer.
 
@@ -28694,7 +29105,7 @@ function buildSettingsHooksBlock(p) {
 
 ` + "TURN-END SHAPE: the human reads your turn-end on a phone. Build it " + "for a thumb, not a terminal. LEAD WITH THE ONE DECISION OR ANSWER " + "in the first line \u2014 the single thing the user has to know. A routine " + "turn-end is a FEW SHORT LINES, not a multi-section report; if you " + "find yourself writing more than ~6 lines or stacking labelled " + "sections, you are dumping, not answering. ONE IDEA PER MESSAGE: " + "split genuinely separate topics into separate replies rather than " + "piling sections into one bubble. Push detail BELOW the answer or " + 'leave it out \u2014 offer "want the detail?" instead of pre-emptively ' + "dumping logs, full file contents, or a section per thread you " + "touched. RESERVE the long multi-section structured message for when " + 'the operator EXPLICITLY asked to go deep ("full breakdown", "walk me ' + 'through it", "show everything"). Default to short; expand on ' + "request. A wall of text the user has to re-read to find the one fact " + `that matters is the failure this exists to prevent.
 
-` + 'CRITICAL: "answer" means a call to the reply tool ' + "(mcp__switchroom-telegram__reply). " + "Your terminal/transcript text is NEVER delivered to Telegram \u2014 the " + "user sees only what you send through the reply tool. After a long " + "tool sequence (scheduling, multi-step research, sub-agent handback), " + "do not let your closing narration stand as the answer: end the turn " + "by passing that narration to the reply tool. No reply tool call = the " + "user got nothing, however much text you wrote. Call the reply tool as " + "your FIRST action when you have the answer \u2014 do not write it out as " + "transcript text first and call reply afterward: a framework backstop " + "flushes unsent text after a delay and then your real reply lands late " + "and out of order.</turn-pacing>";
+` + 'CRITICAL: "answer" means a call to the reply tool ' + "(mcp__switchroom-telegram__reply). " + "Your terminal/transcript text is NEVER delivered to Telegram \u2014 the " + "user sees only what you send through the reply tool. After a long " + "tool sequence (scheduling, multi-step research, sub-agent handback), " + "do not let your closing narration stand as the answer: end the turn " + "by passing that narration to the reply tool. No reply tool call = the " + "user got nothing, however much text you wrote. Call the reply tool as " + "your FIRST action when you have the answer \u2014 do not write it out as " + "transcript text first and call reply afterward: a framework backstop " + "flushes unsent text after a delay and then your real reply lands late " + "and out of order. This is why the work-labelling above rides on tool " + "`description`s rather than loose prose: a tool description reaches the " + "preview immediately and is never subject to that flush, so there is " + "exactly one rule \u2014 user-facing text goes through a tool call, always." + "</turn-pacing>";
   const switchroomUserPromptSubmit = [
     ...useHotReloadStable ? [
       {
@@ -28829,13 +29240,13 @@ function reconcileAgentInner(name, agentConfigRaw, agentsDir, telegramConfig, sw
       }
     });
   }
-  if (!existsSync17(agentDir)) {
+  if (!existsSync18(agentDir)) {
     throw new Error(`Agent directory does not exist: ${agentDir}. Run \`switchroom agent create ${name}\` first.`);
   }
   {
     const explicitResumeMode = agentConfig.session_continuity?.resume_mode;
     const markerPath = join12(agentDir, ".resume-mode-migration-warned");
-    if (!explicitResumeMode && !existsSync17(markerPath)) {
+    if (!explicitResumeMode && !existsSync18(markerPath)) {
       console.warn(`  ${source_default.yellow("\u26a0")} [${name}] resume_mode default changed from 'auto' to 'handoff' (switchroom #362).`);
       console.warn(`     Your agent will now start a fresh Claude session on every restart, using a`);
       console.warn(`     context briefing instead of --continue. This prevents stale MCP servers`);
@@ -28845,7 +29256,7 @@ function reconcileAgentInner(name, agentConfigRaw, agentsDir, telegramConfig, sw
       console.warn(`         resume_mode: auto`);
       console.warn(`     (This warning fires once per agent directory and is then suppressed.)`);
       try {
-        writeFileSync5(markerPath, `resume_mode default changed to handoff at reconcile
+        writeFileSync6(markerPath, `resume_mode default changed to handoff at reconcile
 `, "utf-8");
       } catch {}
     }
@@ -28853,10 +29264,10 @@ function reconcileAgentInner(name, agentConfigRaw, agentsDir, telegramConfig, sw
   const legacyCustomPath = join12(agentDir, "CLAUDE.custom.md");
   const workspaceDir = join12(agentDir, "workspace");
   const newCustomPath = join12(workspaceDir, "CLAUDE.custom.md");
-  if (existsSync17(legacyCustomPath) && !existsSync17(newCustomPath)) {
-    mkdirSync10(workspaceDir, { recursive: true });
-    const legacyContent = readFileSync14(legacyCustomPath, "utf-8");
-    writeFileSync5(newCustomPath, legacyContent, "utf-8");
+  if (existsSync18(legacyCustomPath) && !existsSync18(newCustomPath)) {
+    mkdirSync11(workspaceDir, { recursive: true });
+    const legacyContent = readFileSync15(legacyCustomPath, "utf-8");
+    writeFileSync6(newCustomPath, legacyContent, "utf-8");
     rmSync4(legacyCustomPath);
     console.log(source_default.green(`  moved CLAUDE.custom.md \u2192 workspace/CLAUDE.custom.md`));
   }
@@ -28989,19 +29400,19 @@ ${baseAppend}` : TELEGRAM_FORMATTING_FLOOR_CARD;
       resumeMaxBytes: agentConfig.session_continuity?.resume_max_bytes ?? 2000000,
       bootResumeMode: agentConfig.session_continuity?.boot_resume ?? "in-flight"
     };
-    const beforeStartSh = existsSync17(startShPath) ? readFileSync14(startShPath, "utf-8") : "";
+    const beforeStartSh = existsSync18(startShPath) ? readFileSync15(startShPath, "utf-8") : "";
     const afterStartSh = renderTemplate(join12(basePath, "start.sh.hbs"), startShContext);
     if (afterStartSh !== beforeStartSh) {
-      writeFileSync5(startShPath, afterStartSh, "utf-8");
+      writeFileSync6(startShPath, afterStartSh, "utf-8");
       chmodSync2(startShPath, 493);
       changes.push(startShPath);
     }
     if (startShContext.cronSessionEnabled) {
       const cronShPath = join12(agentDir, "cron-session.sh");
-      const beforeCronSh = existsSync17(cronShPath) ? readFileSync14(cronShPath, "utf-8") : "";
+      const beforeCronSh = existsSync18(cronShPath) ? readFileSync15(cronShPath, "utf-8") : "";
       const afterCronSh = renderTemplate(join12(basePath, "cron-session.sh.hbs"), startShContext);
       if (afterCronSh !== beforeCronSh) {
-        writeFileSync5(cronShPath, afterCronSh, "utf-8");
+        writeFileSync6(cronShPath, afterCronSh, "utf-8");
         chmodSync2(cronShPath, 493);
         changes.push(cronShPath);
       }
@@ -29012,7 +29423,7 @@ ${baseAppend}` : TELEGRAM_FORMATTING_FLOOR_CARD;
     const claudeMdSrc = join12(profilePath, "CLAUDE.md.hbs");
     const claudeMdDest = join12(agentDir, "CLAUDE.md");
     const claudeCustomPath = join12(agentDir, "workspace", "CLAUDE.custom.md");
-    if (existsSync17(claudeMdSrc)) {
+    if (existsSync18(claudeMdSrc)) {
       const claudeContext = {
         name,
         agentDir,
@@ -29071,17 +29482,17 @@ ${baseAppend}` : TELEGRAM_FORMATTING_FLOOR_CARD;
 ` + agentConfig.claude_md_raw + `
 `;
       }
-      const before = existsSync17(claudeMdDest) ? readFileSync14(claudeMdDest, "utf-8") : "";
+      const before = existsSync18(claudeMdDest) ? readFileSync15(claudeMdDest, "utf-8") : "";
       const composed = composeTwoSectionClaudeMd(rendered, before.length > 0 ? before : null, claudeCustomPath);
       if (composed !== before) {
-        writeFileSync5(claudeMdDest, composed, "utf-8");
+        writeFileSync6(claudeMdDest, composed, "utf-8");
         changes.push(claudeMdDest);
       }
     }
   }
   const settingsPath = join12(agentDir, ".claude", "settings.json");
-  if (existsSync17(settingsPath)) {
-    const before = readFileSync14(settingsPath, "utf-8");
+  if (existsSync18(settingsPath)) {
+    const before = readFileSync15(settingsPath, "utf-8");
     const settings = JSON.parse(before);
     settings.permissions = settings.permissions ?? {};
     settings.permissions.allow = desiredAllow;
@@ -29143,15 +29554,15 @@ ${baseAppend}` : TELEGRAM_FORMATTING_FLOOR_CARD;
     });
     let greetingUserId;
     const accessPath = join12(agentDir, "telegram", "access.json");
-    if (existsSync17(accessPath)) {
+    if (existsSync18(accessPath)) {
       try {
-        const access = JSON.parse(readFileSync14(accessPath, "utf-8"));
+        const access = JSON.parse(readFileSync15(accessPath, "utf-8"));
         greetingUserId = access.allowFrom?.[0];
       } catch {}
     }
     if (agentConfig.subagents) {
       const saDir = join12(agentDir, ".claude", "agents");
-      mkdirSync10(saDir, { recursive: true });
+      mkdirSync11(saDir, { recursive: true });
       for (const [saName, saDef] of Object.entries(agentConfig.subagents)) {
         const mdPath = join12(saDir, `${saName}.md`);
         if (!saDef.description) {
@@ -29203,9 +29614,9 @@ ${fmLines}
 
 ${body}
 `;
-        const before2 = existsSync17(mdPath) ? readFileSync14(mdPath, "utf-8") : "";
+        const before2 = existsSync18(mdPath) ? readFileSync15(mdPath, "utf-8") : "";
         if (content !== before2) {
-          writeFileSync5(mdPath, content, "utf-8");
+          writeFileSync6(mdPath, content, "utf-8");
           changes.push(mdPath);
         }
       }
@@ -29223,7 +29634,7 @@ ${body}
     }
   }
   const telegramDir = join12(agentDir, "telegram");
-  if (existsSync17(telegramDir)) {
+  if (existsSync18(telegramDir)) {
     const files = readdirSync7(telegramDir);
     for (const file of files) {
       const isCronScript = CRON_SCRIPT_BASENAME_RE.test(file) || LEGACY_CRON_SCRIPT_BASENAME_RE.test(file);
@@ -29232,7 +29643,7 @@ ${body}
         unlinkSync4(staleScript);
         changes.push(staleScript);
         const sourceSidecar = staleScript.replace(/\.sh$/, ".source");
-        if (existsSync17(sourceSidecar)) {
+        if (existsSync18(sourceSidecar)) {
           unlinkSync4(sourceSidecar);
           changes.push(sourceSidecar);
         }
@@ -29310,7 +29721,7 @@ ${body}
     const mcpJson = { mcpServers };
     const after = JSON.stringify(mcpJson, null, 2) + `
 `;
-    const before = existsSync17(mcpJsonPath) ? readFileSync14(mcpJsonPath, "utf-8") : "";
+    const before = existsSync18(mcpJsonPath) ? readFileSync15(mcpJsonPath, "utf-8") : "";
     if (after !== before) {
       atomicWriteFileSync(mcpJsonPath, after, 384);
       changes.push(mcpJsonPath);
@@ -29349,7 +29760,7 @@ ${body}
       hindsightSenderBanksJson,
       hindsightTopicFilterMode
     });
-    mkdirSync10(reconcileWorkspaceDir, { recursive: true });
+    mkdirSync11(reconcileWorkspaceDir, { recursive: true });
     migrateLegacyAgentsMdIfPresent(reconcileWorkspaceDir, changes);
     seedWorkspaceBootstrapFiles({
       profilePath: reconcileProfilePath,
@@ -29362,13 +29773,13 @@ ${body}
     });
     ensureClaudeMdSymlinks(reconcileWorkspaceDir, changes);
   }
-  if (existsSync17(reconcileWorkspaceDir)) {
+  if (existsSync18(reconcileWorkspaceDir)) {
     initWorkspaceGitRepo(reconcileWorkspaceDir, name);
   }
   const agentSoulPath = join12(agentDir, "SOUL.md");
   const workspaceSoulPath = join12(agentDir, "workspace", "SOUL.md");
-  if (existsSync17(workspaceSoulPath)) {
-    if (existsSync17(agentSoulPath)) {
+  if (existsSync18(workspaceSoulPath)) {
+    if (existsSync18(agentSoulPath)) {
       const stat = lstatSync4(agentSoulPath);
       if (stat.isSymbolicLink()) {
         const target = readlinkSync4(agentSoulPath);
@@ -29479,7 +29890,7 @@ ${body}
   };
 }
 function writeIfMissing(filePath, contentFn, created, skipped, mode) {
-  if (existsSync17(filePath)) {
+  if (existsSync18(filePath)) {
     skipped.push(filePath);
     return;
   }
@@ -29488,12 +29899,12 @@ function writeIfMissing(filePath, contentFn, created, skipped, mode) {
 }
 function writeIfChanged(filePath, contentFn, created, skipped, mode) {
   const next = contentFn();
-  const prev = existsSync17(filePath) ? readFileSync14(filePath, "utf-8") : null;
+  const prev = existsSync18(filePath) ? readFileSync15(filePath, "utf-8") : null;
   if (prev === next) {
     skipped.push(filePath);
     return;
   }
-  writeFileSync5(filePath, next, mode !== undefined ? { encoding: "utf-8", mode } : "utf-8");
+  writeFileSync6(filePath, next, mode !== undefined ? { encoding: "utf-8", mode } : "utf-8");
   created.push(filePath);
 }
 function claudeMdManagedSection(content) {
@@ -29503,42 +29914,42 @@ function claudeMdManagedSection(content) {
   return content.slice(0, idx + CLAUDE_MD_YOURS_MARKER.length);
 }
 function writeTwoSectionClaudeMdWithFingerprint(filePath, managedFn, sidecarPath, created, skipped, rewrittenWithBackup) {
-  const prev = existsSync17(filePath) ? readFileSync14(filePath, "utf-8") : null;
+  const prev = existsSync18(filePath) ? readFileSync15(filePath, "utf-8") : null;
   const next = composeTwoSectionClaudeMd(managedFn(), prev, sidecarPath);
   const nextManagedHash = createHash4("sha256").update(claudeMdManagedSection(next), "utf-8").digest("hex");
   const fingerprintPath = filePath + ".fingerprint";
   if (prev === null) {
-    writeFileSync5(filePath, next, "utf-8");
-    writeFileSync5(fingerprintPath, nextManagedHash, "utf-8");
+    writeFileSync6(filePath, next, "utf-8");
+    writeFileSync6(fingerprintPath, nextManagedHash, "utf-8");
     created.push(filePath);
     return;
   }
   if (prev === next) {
     try {
-      writeFileSync5(fingerprintPath, nextManagedHash, "utf-8");
+      writeFileSync6(fingerprintPath, nextManagedHash, "utf-8");
     } catch {}
     skipped.push(filePath);
     return;
   }
   const prevManagedHash = createHash4("sha256").update(claudeMdManagedSection(prev), "utf-8").digest("hex");
-  const recordedFingerprint = existsSync17(fingerprintPath) ? readFileSync14(fingerprintPath, "utf-8").trim() : null;
+  const recordedFingerprint = existsSync18(fingerprintPath) ? readFileSync15(fingerprintPath, "utf-8").trim() : null;
   if (recordedFingerprint === prevManagedHash) {
-    writeFileSync5(filePath, next, "utf-8");
-    writeFileSync5(fingerprintPath, nextManagedHash, "utf-8");
+    writeFileSync6(filePath, next, "utf-8");
+    writeFileSync6(fingerprintPath, nextManagedHash, "utf-8");
     created.push(filePath);
     return;
   }
   const backupPath = `${filePath}.before-rerender.${Date.now()}`;
   try {
-    writeFileSync5(backupPath, prev, "utf-8");
+    writeFileSync6(backupPath, prev, "utf-8");
   } catch (err) {
     process.stderr.write(`scaffold: refusing to overwrite ${filePath} \u2014 backup write failed ` + `(${err.message}). Operator edits preserved.
 `);
     skipped.push(filePath);
     return;
   }
-  writeFileSync5(filePath, next, "utf-8");
-  writeFileSync5(fingerprintPath, nextManagedHash, "utf-8");
+  writeFileSync6(filePath, next, "utf-8");
+  writeFileSync6(fingerprintPath, nextManagedHash, "utf-8");
   rewrittenWithBackup.push(filePath);
   created.push(filePath);
 }
@@ -29547,39 +29958,39 @@ function rerenderWithFingerprint(filePath, contentFn, created, skipped, rewritte
   const nextHash = createHash4("sha256").update(next, "utf-8").digest("hex");
   const fingerprintPath = filePath + ".fingerprint";
   const writeMode = mode !== undefined ? { encoding: "utf-8", mode } : "utf-8";
-  if (!existsSync17(filePath)) {
-    writeFileSync5(filePath, next, writeMode);
-    writeFileSync5(fingerprintPath, nextHash, "utf-8");
+  if (!existsSync18(filePath)) {
+    writeFileSync6(filePath, next, writeMode);
+    writeFileSync6(fingerprintPath, nextHash, "utf-8");
     created.push(filePath);
     return;
   }
-  const prev = readFileSync14(filePath, "utf-8");
+  const prev = readFileSync15(filePath, "utf-8");
   if (prev === next) {
     try {
-      writeFileSync5(fingerprintPath, nextHash, "utf-8");
+      writeFileSync6(fingerprintPath, nextHash, "utf-8");
     } catch {}
     skipped.push(filePath);
     return;
   }
   const prevHash = createHash4("sha256").update(prev, "utf-8").digest("hex");
-  const recordedFingerprint = existsSync17(fingerprintPath) ? readFileSync14(fingerprintPath, "utf-8").trim() : null;
+  const recordedFingerprint = existsSync18(fingerprintPath) ? readFileSync15(fingerprintPath, "utf-8").trim() : null;
   if (recordedFingerprint === prevHash) {
-    writeFileSync5(filePath, next, writeMode);
-    writeFileSync5(fingerprintPath, nextHash, "utf-8");
+    writeFileSync6(filePath, next, writeMode);
+    writeFileSync6(fingerprintPath, nextHash, "utf-8");
     created.push(filePath);
     return;
   }
   const backupPath = `${filePath}.before-rerender.${Date.now()}`;
   try {
-    writeFileSync5(backupPath, prev, "utf-8");
+    writeFileSync6(backupPath, prev, "utf-8");
   } catch (err) {
     process.stderr.write(`scaffold: refusing to overwrite ${filePath} \u2014 backup write failed ` + `(${err.message}). Operator edits preserved.
 `);
     skipped.push(filePath);
     return;
   }
-  writeFileSync5(filePath, next, writeMode);
-  writeFileSync5(fingerprintPath, nextHash, "utf-8");
+  writeFileSync6(filePath, next, writeMode);
+  writeFileSync6(fingerprintPath, nextHash, "utf-8");
   rewrittenWithBackup.push(filePath);
   created.push(filePath);
 }
@@ -29590,7 +30001,7 @@ function resolveAgentForumChatId(agentConfig, telegramConfig) {
   return telegramConfig.forum_chat_id ?? "";
 }
 function reconcileConfiguredGroup(accessPath, agentConfig, telegramConfig) {
-  if (!existsSync17(accessPath))
+  if (!existsSync18(accessPath))
     return;
   const forumChatId = resolveAgentForumChatId(agentConfig, telegramConfig);
   const hasRealForumChat = forumChatId !== "" && forumChatId !== "0";
@@ -29598,7 +30009,7 @@ function reconcileConfiguredGroup(accessPath, agentConfig, telegramConfig) {
     return;
   let access;
   try {
-    access = JSON.parse(readFileSync14(accessPath, "utf-8"));
+    access = JSON.parse(readFileSync15(accessPath, "utf-8"));
   } catch {
     return;
   }
@@ -29608,7 +30019,7 @@ function reconcileConfiguredGroup(accessPath, agentConfig, telegramConfig) {
   const allowFrom = Array.isArray(access.allowFrom) ? access.allowFrom : [];
   groups[forumChatId] = { requireMention: false, allowFrom };
   const tmp = accessPath + ".tmp";
-  writeFileSync5(tmp, JSON.stringify(access, null, 2) + `
+  writeFileSync6(tmp, JSON.stringify(access, null, 2) + `
 `, { mode: 384 });
   renameSync4(tmp, accessPath);
   console.log(source_default.green(`  registered supergroup ${forumChatId} in access.json ` + `(responds to all topics; requireMention=false)`));
@@ -29752,22 +30163,19 @@ messaging a capable colleague \u2014 not a tool emitting output. Five beats:
    compose the full answer. This holds even for a pure-thinking
    answer: if it will run to a paragraph, ack first. It is the line
    between a colleague and a black box.
-2. **Then go quiet and work \u2014 but leave a trail of intent.** Heads-down
+2. **Then go quiet and work \u2014 but label what you are doing.** Heads-down
    is correct: do NOT narrate every tool call, and a typing indicator
-   runs automatically (you do not maintain it). One thing you SHOULD do,
-   because your private reasoning is never shown to the user: before a
-   burst of tool calls or a long silent stretch, drop ONE short
-   plain-language line of intent in your own working text \u2014 *what* you
-   are about to do and *why* ("Now checking the gateway logs to find why
-   the turn stalled"). Write it as ordinary text, NOT a \`reply\` call, so
-   it never becomes a chat message and never pings \u2014 the framework
-   mirrors that line into the live preview the user watches while you
-   work. One line per stretch, plain words, never raw tool names
-   ("calling Bash") or debug dumps. It is the difference between the user
-   seeing "checking the logs to find the stall" and seeing a black box.
-   When a step is a \`Bash\` command, always give it a plain-English
-   \`description\` naming the goal \u2014 that description, not the raw command,
-   is what the user sees.
+   runs automatically (you do not maintain it). What you SHOULD do is
+   make the work legible through the tool calls themselves: always give a
+   \`Bash\` (or any tool) call a plain-English \`description\` naming the
+   goal \u2014 "Checking the gateway logs to find why the turn stalled". That
+   description, not the raw command, is what the user sees in the live
+   preview. Before a long silent stretch, put one short status line there
+   too, saying what you are starting. One line per stretch, plain words,
+   never raw tool names ("calling Bash") or debug dumps. It is the
+   difference between the user seeing "checking the logs to find the
+   stall" and seeing a black box. Keep it in the tool call \u2014 loose
+   transcript prose is not delivered and can be flushed late (see beat 5).
 3. **Surface meaningful progress** at genuine inflection points \u2014 a
    hard step finished, a blocker, a pivot, dispatching a sub-agent, a
    notably slow wait, a finding worth knowing now. One short \`reply\`,
@@ -30200,50 +30608,6 @@ var init_scaffold = __esm(() => {
   ];
 });
 
-// src/setup/host-capabilities.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync11, readFileSync as readFileSync15, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname6 } from "node:path";
-function hostCapabilitiesPath() {
-  return resolveStatePath("host-capabilities.json");
-}
-function saveVoiceCapability(caps, now = () => new Date) {
-  const doc = {
-    version: HOST_CAPABILITIES_VERSION,
-    voice: {
-      gpuPresent: caps.gpuPresent,
-      containerToolkit: caps.containerToolkit,
-      engine: caps.engine,
-      detectedAt: now().toISOString()
-    }
-  };
-  const path = hostCapabilitiesPath();
-  mkdirSync11(dirname6(path), { recursive: true });
-  writeFileSync6(path, JSON.stringify(doc, null, 2) + `
-`, {
-    encoding: "utf-8",
-    mode: 384
-  });
-  return doc;
-}
-function loadHostCapabilities() {
-  const path = hostCapabilitiesPath();
-  if (!existsSync18(path))
-    return null;
-  try {
-    const parsed = JSON.parse(readFileSync15(path, "utf-8"));
-    if (parsed && typeof parsed === "object" && "voice" in parsed && typeof parsed.voice === "object") {
-      return parsed;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-var HOST_CAPABILITIES_VERSION = 1;
-var init_host_capabilities = __esm(() => {
-  init_paths();
-});
-
 // src/vault/grants-db-path.ts
 var exports_grants_db_path = {};
 __export(exports_grants_db_path, {
@@ -51186,7 +51550,7 @@ function probePendingRetainsQueue(agentName) {
 function buildPendingRetainsProbeScript(base, now = Date.now()) {
   const dir = `${base}/pending-retains`;
   const cutoff = new Date(now - PENDING_RETAINS_EVICTION_WINDOW_DAYS * 86400000).toISOString().replace(/\.\d+Z$/, "Z");
-  return `P=0; D=0; X=0; E=0; C=\${HINDSIGHT_PENDING_MAX_ENTRIES:-${PENDING_RETAINS_DEFAULT_MAX_ENTRIES}}; ` + `if [ -d '${dir}' ]; then ` + `P=$(ls -1 '${dir}' 2>/dev/null | grep -c '\\.json$' || true); ` + `D=$(ls -1 '${dir}' 2>/dev/null | grep -c '\\.json\\.dead$' || true); ` + `fi; ` + `for L in '${base}/pending-drops.json' '${dir}/.drops.json'; do ` + `if [ "$X" = 0 ] && [ -f "$L" ]; then ` + `X=$(grep -o '"count"[^0-9]*[0-9][0-9]*' "$L" 2>/dev/null ` + `| grep -o '[0-9][0-9]*$' | head -n1); ` + `[ -n "$X" ] || X=0; ` + `fi; done; ` + `if [ -f '${base}/pending-evictions.log' ]; then ` + `E=$(awk -v c='${cutoff}' '$1 >= c && /evicted=/ {n++} END {print n+0}' ` + `'${base}/pending-evictions.log' 2>/dev/null || echo 0); ` + `[ -n "$E" ] || E=0; ` + `fi; ` + `echo "P=$P D=$D X=$X E=$E C=$C"`;
+  return `P=0; D=0; X=0; E=0; C=\${HINDSIGHT_PENDING_MAX_ENTRIES:-${PENDING_RETAINS_DEFAULT_MAX_ENTRIES}}; ` + `if [ -d '${dir}' ]; then ` + `P=$(ls -1 '${dir}' 2>/dev/null | grep -c '\\.json$' || true); ` + `D=$(ls -1 '${dir}' 2>/dev/null | grep -c '\\.json\\.dead$' || true); ` + `fi; ` + `if [ -d '${base}/pending-dead' ]; then ` + `D=$((D + $(ls -1 '${base}/pending-dead' 2>/dev/null | grep -c '\\.dead$' || true))); ` + `fi; ` + `for L in '${base}/pending-drops.json' '${dir}/.drops.json'; do ` + `if [ "$X" = 0 ] && [ -f "$L" ]; then ` + `X=$(grep -o '"count"[^0-9]*[0-9][0-9]*' "$L" 2>/dev/null ` + `| grep -o '[0-9][0-9]*$' | head -n1); ` + `[ -n "$X" ] || X=0; ` + `fi; done; ` + `if [ -f '${base}/pending-evictions.log' ]; then ` + `E=$(awk -v c='${cutoff}' '$1 >= c && /evicted=/ {n++} END {print n+0}' ` + `'${base}/pending-evictions.log' 2>/dev/null || echo 0); ` + `[ -n "$E" ] || E=0; ` + `fi; ` + `echo "P=$P D=$D X=$X E=$E C=$C"`;
 }
 function parsePendingRetainsProbeOutput(r) {
   const unreachable = {
@@ -66572,11 +66936,24 @@ function parseTurns(text) {
     if (!line)
       continue;
     try {
-      out.push(JSON.parse(line));
+      const parsed = JSON.parse(line);
+      if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        continue;
+      out.push(parsed);
     } catch {}
   }
   return out;
 }
+function ownedTurns(agent, turns) {
+  const slug = agent.trim().toLowerCase();
+  return turns.filter((t) => {
+    const raw = t?.agent;
+    if (typeof raw !== "string")
+      return true;
+    const owner = raw.trim().toLowerCase();
+    return owner === "" || owner === slug;
+  });
+}
 function isoFromTs(ts) {
   if (typeof ts !== "number" || !Number.isFinite(ts))
     return null;
@@ -66585,8 +66962,8 @@ function isoFromTs(ts) {
 function detectTurnFindings(agent, turns, opts = {}) {
   const findings = [];
   const silentNoopFloorTs = opts.silentNoopFloorTs ?? SILENT_NOOP_FLOOR_TS;
-  for (const t of turns) {
-    const tid = t.turn_id ?? "?";
+  for (const t of ownedTurns(agent, turns)) {
+    const tid = typeof t.turn_id === "string" ? t.turn_id : "?";
     const st = t.status;
     const tl = typeof t.tools === "number" ? t.tools : 0;
     const dur = typeof t.duration_ms === "number" ? t.duration_ms : 0;
@@ -66667,7 +67044,7 @@ function extractTs(line) {
   return m ? m[0] : null;
 }
 function scanAgent(agent, turnsText, gatewayText, opts = {}) {
-  const turns = parseTurns(turnsText);
+  const turns = ownedTurns(agent, parseTurns(turnsText));
   const status_mix = {};
   for (const t of turns) {
     const st = t.status ?? "unknown";
@@ -66677,7 +67054,16 @@ function scanAgent(agent, turnsText, gatewayText, opts = {}) {
   const { findings: gwFindings, gw_hits } = detectGatewayFindings(agent, gatewayText);
   const findings = [...turnFindings, ...gwFindings];
   const escalate = turnFindings.some((f) => f.signal === "killed-incomplete-turn" || f.signal === "hang-long-stalled" || f.signal === "silent-no-op-candidate" || f.signal === "send-failed-delivery") || gw_hits["duplicate-delivery-represent"] > 0 || gw_hits["reply-delivery-failure"] > 0;
-  return { agent, turns: turns.length, status_mix, findings, gw_hits, escalate };
+  const landed_unconfirmed_turns = turns.filter((t) => (t.landed_unconfirmed ?? 0) > 0).length;
+  return {
+    agent,
+    turns: turns.length,
+    status_mix,
+    findings,
+    gw_hits,
+    landed_unconfirmed_turns,
+    escalate
+  };
 }
 var HANG_MS = 360000, HANG_MAXTOOLS = 2, SILENT_NOOP_FLOOR_TS = 1783900800, GATEWAY_SIGNATURES;
 var init_detect = __esm(() => {
@@ -81563,7 +81949,7 @@ Cross-agent reflection plan
     try {
       const hindsightConfig = getConfig(program3);
       const litellmCfg = await resolveLiteLLMForHindsight(hindsightConfig);
-      startHindsight(ports, litellmCfg, effectiveTag, hindsightConfig.hindsight?.llm, hindsightConsumerMirrorDir(hindsightConfig));
+      startHindsight(ports, litellmCfg, effectiveTag, hindsightConfig.hindsight?.llm, hindsightConsumerMirrorDir(hindsightConfig), undefined, { env: hindsightConfig.hindsight?.env });
       if (litellmCfg) {
         console.log(source_default.gray("  LiteLLM routing enabled for hindsight (--network host)."));
       }
@@ -81594,7 +81980,7 @@ Cross-agent reflection plan
 `));
     {
       const snippetConfig = getConfig(program3);
-      console.log(generateHindsightComposeSnippet(snippetConfig.hindsight?.llm, hindsightConsumerMirrorDir(snippetConfig)));
+      console.log(generateHindsightComposeSnippet(snippetConfig.hindsight?.llm, hindsightConsumerMirrorDir(snippetConfig), undefined, undefined, { env: snippetConfig.hindsight?.env }));
     }
     console.log();
   });
@@ -99752,7 +100138,7 @@ var RING_MAX = 8;
 var MAX_SAMPLE_AGE_MS = 3 * 60 * 60000;
 var MIN_RETAIN_SAMPLES = 20;
 var RETAIN_FAILURE_RATE = 0.1;
-var PARTS_PER_MEMORY = 4.4;
+var PARTS_PER_MEMORY = 6;
 function inParts(memories) {
   return Math.round(memories * PARTS_PER_MEMORY);
 }
@@ -99878,6 +100264,12 @@ function probeSpool(agentsDir = resolve61(process.env.SWITCHROOM_HOME ?? process
           evicted++;
       }
     } catch {}
+    try {
+      for (const f of readdirSync43(resolve61(hindsightDir, "pending-dead"))) {
+        if (f.endsWith(".dead"))
+          dead++;
+      }
+    } catch {}
     drops += readDropCount(hindsightDir);
   }
   return { pending, dead, evicted, drops, agents };