switchroom 0.20.18 → 0.20.19

package/dist/cli/switchroom.js

@@ -2120,7 +2120,7 @@ var init_esm = __esm(() => {
 });
 
 // src/build-info.ts
-var VERSION = "0.20.18", COMMIT_SHA = "7b49b13d";
+var VERSION = "0.20.19", COMMIT_SHA = "552a2d21";
 
 // src/cli/resolve-version.ts
 import { existsSync, readFileSync } from "node:fs";
@@ -14046,6 +14046,12 @@ var init_schema = __esm(() => {
       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."),
+    recall_pool: exports_external.object({
+      enabled: exports_external.boolean().optional().describe("Turn on the recall/background WORKER SPLIT: a second container, " + "`switchroom-hindsight-recall`, serves recall/reflect only with N " + "uvicorn workers, while the existing `switchroom-hindsight` " + "container keeps pg0, the single background WorkerPoller, the " + "healthcheck and all consolidation/retain processing but moves off " + "the public port onto public+1. The public port (memory.config.url) " + "does not change \u2014 the pool binds it instead. Absent/false (the " + "default) \u2192 the single-container topology, unchanged. Opt-in only. " + "Raises recall throughput ~2.2x on the fleet (2.6\u21925.6 rps)."),
+      workers: exports_external.number().int().positive().optional().describe("uvicorn `--workers` for the recall pool (HINDSIGHT_API_WORKERS). " + "Default 4. Each worker holds its own GPU cross-encoder reranker, " + "so past ~4 workers contend for VRAM rather than adding throughput " + "on a single GPU \u2014 raise only on a bigger GPU or a CPU reranker. " + "The per-worker DB pools are auto-sized down from the pg0 " + "connection budget so N*(write+read)+60 background stays under " + "max_connections=250; a worker count that would overflow that " + "budget is rejected at launch."),
+      db_pool_max_size: exports_external.number().int().positive().optional().describe("Override the per-worker WRITE pool cap " + "(HINDSIGHT_API_DB_POOL_MAX_SIZE). Absent \u2192 auto-sized from the " + "worker count. Set this only to override the auto-sizing; the " + "connection-budget check still applies and rejects an overflow."),
+      read_db_pool_max_size: exports_external.number().int().positive().optional().describe("Override the per-worker READ pool cap " + "(HINDSIGHT_API_READ_DB_POOL_MAX_SIZE). Absent \u2192 auto-sized from " + "the worker count. Set this only to override the auto-sizing; the " + "connection-budget check still applies and rejects an overflow.")
+    }).optional().describe("Optional recall/background container split for the hindsight " + "singleton. Off by default; see `enabled`. Provisioned by " + "`switchroom memory setup` (src/setup/hindsight-recall-pool.ts) so it " + "survives `switchroom apply` \u2014 the hand-applied topology it replaces " + "did not."),
     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, " + "MAX_OBSERVATIONS_PER_SCOPE, " + "RECALL_MAX_CANDIDATES_PER_SOURCE, LINK_EXPANSION_PER_ENTITY_LIMIT, " + "LINK_EXPANSION_TIMEOUT, LLM_REASONING_EFFORT, " + "RERANKER_LOCAL_BUCKET_BATCHING, RERANKER_MAX_CANDIDATES, " + "RERANKER_LOCAL_MAX_CONCURRENT, RECALL_MAX_CONCURRENT, " + "REFLECT_WALL_TIMEOUT, WORKER_CONSOLIDATION_RESERVED_SLOTS, " + "WORKER_CONSOLIDATION_SLOT_LIMIT, " + "CONSOLIDATION_MAX_MEMORIES_PER_ROUND, GRAPH_SEED_MIN_SIMILARITY, " + "LLM_SUPPORTS_MAX_ITEMS, RECENCY_DECAY_FUNCTION, " + "RECENCY_DECAY_HALFLIFE_DAYS \u2014 switchroom defaults recall's recency " + "curve to `exponential` with a 30-day half-life so a fact retained " + "today outranks a stale one, instead of upstream's near-flat " + "linear/365-day window), 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; and " + "HINDSIGHT_CE_DECISIVE_RELATIVE_GAP \u2014 the rollback knob for " + "switchroom's CE-saturation damping patch, a float; >= ~0.65 backs the " + "damping out entirely, unset means the patch's own derived gap; and " + "HINDSIGHT_API_RECENCY_DECAY_LINEAR_WINDOW_DAYS \u2014 only read when the " + "decay function is `linear`, so switchroom ships no default for it but " + "still honours an operator who flips the function back; and " + "HINDSIGHT_API_WORKER_MAX_SLOTS \u2014 the worker poller's TOTAL in-flight " + "task budget, the pool WORKER_CONSOLIDATION_RESERVED_SLOTS reserves out of; " + "unset means upstream's own default; and " + "HINDSIGHT_API_WORKER_RETAIN_RESERVED_SLOTS \u2014 the reserved slot FLOOR for the " + "retain (memory write) lane, carved from that same total; unset means " + "upstream's own 0, i.e. no floor and retain competes for the shared " + "pool; and " + "the pre-0.8.6 name HINDSIGHT_API_WORKER_<TYPE>_MAX_SLOTS is still " + "accepted for every operation type and normalised to " + "..._RESERVED_SLOTS on the way in, because setting both names for " + "one type is a hard boot failure in the engine and switchroom " + "therefore emits only the canonical name; and " + "HINDSIGHT_API_SEMANTIC_MIN_SIMILARITY \u2014 the cosine-similarity floor a " + "candidate must reach to be returned by the semantic retrieval arm at " + "all (0..1); unset means upstream's own 0.3, and where it should sit " + "depends on the bank's embedding model and phrasing diversity, so " + "switchroom ships no opinion; and " + "HINDSIGHT_MCP_RECALL_BUDGET_MODE \u2014 the rollback knob for switchroom's " + "mcp-recall-token-budget image patch; `legacy` restores upstream's " + "exact pre-patch recall returns, anything else or unset is the " + "honest-envelope mode; and " + "HINDSIGHT_API_LLM_TEMPERATURE_REFLECT \u2014 upstream's own per-op reflect " + "temperature knob, made live by switchroom's reflect-temperature image " + "patch; a float, or `none` to omit the kwarg (provider default, " + "upstream's accidental pre-patch behaviour); unset means the image's " + "baked default 0.1; and " + "HINDSIGHT_API_CONSOLIDATION_RECALL_MAX_CONCURRENT \u2014 the background " + "half of switchroom's recall-admission split (#3660): of the " + "RECALL_MAX_CONCURRENT admission slots, at most this many may be held " + "by background consolidation recalls at once, so foreground per-turn " + "recall always keeps the remainder; must be >= 1 and strictly less " + "than RECALL_MAX_CONCURRENT or the engine refuses to boot; unset " + "means the image's derived default min(2, RECALL_MAX_CONCURRENT - 1); " + "1 biases hard toward the interactive lane while a consolidation " + "backlog drains; and " + "HINDSIGHT_MM_REFRESH_MIN_INTERVAL_S \u2014 the rollback/tuning knob for " + "switchroom's MM-refresh-debounce image patch: the minimum seconds " + "between consolidation-triggered refreshes of one mental model; unset " + "means the image's baked 3600, 0 restores upstream's " + "refresh-every-round behaviour; explicit and cron-scheduled refreshes " + "are never debounced; and " + "HINDSIGHT_API_QUERY_ANALYZER_LANGUAGES \u2014 the language set dateparser is " + "restricted to during temporal query analysis (upstream #3154, which " + "superseded switchroom's own temporal-language image patch at v0.9.0); " + "comma-separated; switchroom EMITS `en` on every host because upstream's " + "unset default auto-detects across 200+ locales inline on the shared " + "asyncio loop (~165x slower per call), set e.g. `en,es` for i18n parsing; " + "and " + "HINDSIGHT_API_TEMPORAL_MAX_QUERY_CHARS \u2014 the max chars of query text " + "dateparser.search_dates() is handed during temporal analysis (0 = " + "unlimited), made live by switchroom's temporal-offload image patch " + "(which moved the synchronous extraction off the shared asyncio loop onto " + "a single-worker thread and bounds its input, ending multi-second loop " + "stalls on multi-KB consolidation queries); unset means the image's baked " + "2000, set 0 to restore an unbounded full scan); and " + "HINDSIGHT_API_TEXT_SEARCH_EXTENSION_NATIVE_LANGUAGE \u2014 the Postgres " + "text-search regconfig the native BM25 arms and the search_vector index " + "write run to_tsvector/to_tsquery against; unset means upstream's " + "always-safe `english`, set `hindsight_english` to use switchroom's " + "junk-stopping config (dict + stopword file provisioned durably by the " + "image entrypoint, recall degrading to semantic-only if it is ever " + "missing); and " + "HINDSIGHT_API_BM25_MAX_QUERY_TERMS \u2014 the max number of query tokens the " + "keyword (BM25) recall arm searches for; unset means upstream's 0 = " + "unbounded, which makes a multi-KB consolidation query a disjunction " + "over hundreds of terms; set e.g. 64 to cap it, at the cost of " + "silently dropping the tail of a long query; and " + "HINDSIGHT_API_EMBEDDINGS_PROVIDER with the four " + "HINDSIGHT_API_EMBEDDINGS_ONNX_{MODEL_ID,POOLING,QUERY_PREFIX," + "PASSAGE_PREFIX} keys \u2014 the ONNX-embeddings cutover: unset keeps " + "upstream's slower `local` (PyTorch) backend, set `onnx` plus the model " + "id/pooling to run the SAME model on ONNX-CPU at a fraction of the " + "latency; the two _PREFIX keys are the query/passage affixes and are " + "set to the empty string for bge parity (vectors are byte-identical " + "between the two backends, so no re-embedding is needed) \u2014 unusually " + "for this block an EMPTY value here is honoured, not dropped, because an " + "affix-free prefix is the intended value; and the v0.9.0 knobs " + "switchroom allowlists for reach but emits no value for \u2014 " + "HINDSIGHT_API_RERANKER_MAX_CANDIDATES_{LOW,MID,HIGH} (per-recall-budget " + "rerank caps; unset/0 falls back to the global " + "HINDSIGHT_API_RERANKER_MAX_CANDIDATES switchroom does pin), " + "HINDSIGHT_API_EMBEDDINGS_MAX_INPUT_TOKENS (embedding-input truncation " + "ceiling; unset means the model's own limit), " + "HINDSIGHT_API_ENTITY_TRGM_SIMILARITY_THRESHOLD (entity-resolution fuzzy " + "match floor; unset means upstream's 0.15) and " + "HINDSIGHT_API_ENABLE_{TEMPORAL_RETRIEVAL,GRAPH_RETRIEVAL,RERANKING} " + "(global per-stage kill switches, all default true \u2014 the emergency lever " + "if one retrieval stage is implicated in a latency incident, at the cost " + "of recall quality); 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({
@@ -16200,7 +16206,7 @@ function hindsightPerfEnv(caps, overrides = new Map) {
 function findUnmanagedHindsightEnvKeys(configEnv) {
   return Object.keys(configEnv ?? {}).filter((key) => !HINDSIGHT_PERF_ENV_KEYS.has(key) && !HINDSIGHT_PG_ENV_KEYS.has(key)).sort();
 }
-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, 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_DEFAULT_MAX_OBSERVATIONS_PER_SCOPE = 1000, HINDSIGHT_DEFAULT_RERANKER_BUCKET_BATCHING = "true", HINDSIGHT_DEFAULT_RERANKER_MAX_CANDIDATES = 150, HINDSIGHT_DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT = 4, HINDSIGHT_DEFAULT_RECALL_MAX_CONCURRENT = 8, HINDSIGHT_DEFAULT_REFLECT_WALL_TIMEOUT_S = 600, HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND = 250, HINDSIGHT_DEFAULT_CONSOLIDATION_SLOT_LIMIT = 6, HINDSIGHT_DEFAULT_CONSOLIDATION_RESERVED_SLOTS = 1, HINDSIGHT_DEFAULT_GRAPH_SEED_MIN_SIMILARITY = 0.3, HINDSIGHT_DEFAULT_LLM_SUPPORTS_MAX_ITEMS = "false", HINDSIGHT_DEFAULT_RECENCY_DECAY_FUNCTION = "exponential", HINDSIGHT_DEFAULT_RECENCY_DECAY_HALFLIFE_DAYS = 30, HINDSIGHT_DEFAULT_TEXT_SEARCH_EXTENSION = "pg_search", HINDSIGHT_DEFAULT_QUERY_ANALYZER_LANGUAGES = "en", HINDSIGHT_PERF_DEFAULTS_UNGATED, HINDSIGHT_PERF_DEFAULTS_GPU, HINDSIGHT_PERF_DEFAULTS_LOCAL_LLM, HINDSIGHT_PERF_OVERRIDE_ONLY_KEYS, HINDSIGHT_PERF_ALLOW_EMPTY_KEYS, HINDSIGHT_WORKER_SLOT_TYPES, HINDSIGHT_WORKER_RESERVED_SLOT_ALIASES, HINDSIGHT_PERF_ENV_KEYS;
+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, 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_DEFAULT_MAX_OBSERVATIONS_PER_SCOPE = 1000, HINDSIGHT_DEFAULT_RERANKER_BUCKET_BATCHING = "true", HINDSIGHT_DEFAULT_RERANKER_MAX_CANDIDATES = 150, HINDSIGHT_DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT = 4, HINDSIGHT_DEFAULT_RECALL_MAX_CONCURRENT = 8, HINDSIGHT_DEFAULT_REFLECT_WALL_TIMEOUT_S = 600, HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND = 250, HINDSIGHT_DEFAULT_CONSOLIDATION_SLOT_LIMIT = 6, HINDSIGHT_DEFAULT_CONSOLIDATION_RESERVED_SLOTS = 1, HINDSIGHT_DEFAULT_GRAPH_SEED_MIN_SIMILARITY = 0.3, HINDSIGHT_DEFAULT_LLM_SUPPORTS_MAX_ITEMS = "false", HINDSIGHT_DEFAULT_RECENCY_DECAY_FUNCTION = "exponential", HINDSIGHT_DEFAULT_RECENCY_DECAY_HALFLIFE_DAYS = 30, HINDSIGHT_DEFAULT_TEXT_SEARCH_EXTENSION = "pg_search", HINDSIGHT_DEFAULT_QUERY_ANALYZER_LANGUAGES = "en", HINDSIGHT_PERF_DEFAULTS_UNGATED, HINDSIGHT_PERF_DEFAULTS_GPU, HINDSIGHT_PERF_DEFAULTS_LOCAL_LLM, HINDSIGHT_PERF_OVERRIDE_ONLY_KEYS, HINDSIGHT_PERF_ALLOW_EMPTY_KEYS, HINDSIGHT_WORKER_SLOT_TYPES, HINDSIGHT_WORKER_RESERVED_SLOT_ALIASES, HINDSIGHT_RECALL_POOL_ENV_KEYS, HINDSIGHT_PERF_ENV_KEYS;
 var init_hindsight_perf_defaults = __esm(() => {
   init_hindsight_pg_defaults();
   HINDSIGHT_DEFAULT_RECALL_MAX_CANDIDATES_PER_SOURCE = Math.ceil(HINDSIGHT_RERANKER_MAX_CANDIDATES_FOR_DERIVATION * 0.4);
@@ -16343,6 +16349,15 @@ var init_hindsight_perf_defaults = __esm(() => {
     `HINDSIGHT_API_WORKER_${type.toUpperCase()}_MAX_SLOTS`,
     `HINDSIGHT_API_WORKER_${type.toUpperCase()}_RESERVED_SLOTS`
   ]));
+  HINDSIGHT_RECALL_POOL_ENV_KEYS = [
+    "HINDSIGHT_API_WORKERS",
+    "HINDSIGHT_API_WORKER_ENABLED",
+    "HINDSIGHT_API_DATABASE_URL",
+    "HINDSIGHT_API_DB_URL",
+    "HINDSIGHT_API_DB_POOL_MAX_SIZE",
+    "HINDSIGHT_API_READ_DB_POOL_MAX_SIZE",
+    "HINDSIGHT_API_RUN_MIGRATIONS_ON_STARTUP"
+  ];
   HINDSIGHT_PERF_ENV_KEYS = new Set([
     ...[
       ...HINDSIGHT_PERF_DEFAULTS_UNGATED,
@@ -16351,7 +16366,8 @@ var init_hindsight_perf_defaults = __esm(() => {
     ].map(([k]) => k),
     ...HINDSIGHT_PERF_OVERRIDE_ONLY_KEYS,
     ...HINDSIGHT_WORKER_RESERVED_SLOT_ALIASES.keys(),
-    ...HINDSIGHT_WORKER_RESERVED_SLOT_ALIASES.values()
+    ...HINDSIGHT_WORKER_RESERVED_SLOT_ALIASES.values(),
+    ...HINDSIGHT_RECALL_POOL_ENV_KEYS
   ]);
 });
 
@@ -16521,7 +16537,7 @@ function resolveCheckedHindsightContextBudget(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 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 = 5000, 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 {
@@ -18727,20 +18743,16 @@ function probeDockerAvailability(probe = defaultDockerProbe) {
 function isDockerAvailable(probe = defaultDockerProbe) {
   return probeDockerAvailability(probe) === "ok";
 }
+function dockerNameMatchesExactly(probe, args, want) {
+  const out = probe(args);
+  return (out ?? "").split(`
+`).map((n) => n.trim()).some((n) => n === want);
+}
 function isHindsightRunning(probe = defaultDockerProbe) {
-  const out = probe(["ps", "--filter", "name=switchroom-hindsight", "--format", "{{.Status}}"]);
-  return (out ?? "").trim().length > 0;
+  return dockerNameMatchesExactly(probe, ["ps", "--filter", "name=switchroom-hindsight", "--format", "{{.Names}}"], HINDSIGHT_CONTAINER_NAME);
 }
 function isHindsightContainerExists(probe = defaultDockerProbe) {
-  const out = probe([
-    "ps",
-    "-a",
-    "--filter",
-    "name=switchroom-hindsight",
-    "--format",
-    "{{.Names}}"
-  ]);
-  return (out ?? "").trim().length > 0;
+  return dockerNameMatchesExactly(probe, ["ps", "-a", "--filter", "name=switchroom-hindsight", "--format", "{{.Names}}"], HINDSIGHT_CONTAINER_NAME);
 }
 function resolveHindsightPerOpLlm(llm) {
   const out = [];
@@ -19273,11 +19285,28 @@ function hindsightResolvedCapabilities(llm, litellm, gpu, perf) {
     localLlm: hindsightLocalLlmEnabled(llm, litellm, perf?.localLlm)
   };
 }
-function getHindsightStatus() {
+function getHindsightStatus(exec = (cmd, args) => execFileSync2(cmd, args, { stdio: "pipe", encoding: "utf-8" })) {
   try {
-    const output = execFileSync2("docker", ["ps", "-a", "--filter", "name=switchroom-hindsight", "--format", "{{.Status}}"], { stdio: "pipe", encoding: "utf-8" });
-    const status = output.trim();
-    return status.length > 0 ? status : null;
+    const output = exec("docker", [
+      "ps",
+      "-a",
+      "--filter",
+      "name=switchroom-hindsight",
+      "--format",
+      "{{.Names}}\t{{.Status}}"
+    ]);
+    for (const line of output.split(`
+`)) {
+      const tab = line.indexOf("\t");
+      if (tab === -1)
+        continue;
+      if (line.slice(0, tab).trim() !== HINDSIGHT_CONTAINER_NAME)
+        continue;
+      const status = line.slice(tab + 1).trim();
+      if (status.length > 0)
+        return status;
+    }
+    return null;
   } catch {
     return null;
   }
@@ -19439,7 +19468,7 @@ async function ensureHindsightConsumer(configPath, account, uid = HINDSIGHT_DEFA
   atomicWriteFileSync3(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_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_DEFAULT_REQUEUE_DEAD_LETTERS = "1", HINDSIGHT_DEFAULT_REQUEUE_MAX = "25", HINDSIGHT_BROKER_SOCK_VOLUME, HINDSIGHT_CREDS_MIRROR_VOLUME, HINDSIGHT_CRED_DIR = "/run/claude-creds", 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_MEM_LIMIT = "16g", 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_CONSUMER_NAME = "hindsight", HINDSIGHT_DEFAULT_WORKER_ID = "switchroom-hindsight", HINDSIGHT_CONTAINER_NAME = "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_DEFAULT_REQUEUE_DEAD_LETTERS = "1", HINDSIGHT_DEFAULT_REQUEUE_MAX = "25", HINDSIGHT_BROKER_SOCK_VOLUME, HINDSIGHT_CREDS_MIRROR_VOLUME, HINDSIGHT_CRED_DIR = "/run/claude-creds", 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_MEM_LIMIT = "16g", 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 execFileSync2("docker", args, {
       stdio: "pipe",
@@ -32805,6 +32834,9 @@ var init_scaffold = __esm(() => {
     "mcp__hindsight__delete_document",
     "mcp__hindsight__get_mental_model",
     "mcp__hindsight__list_mental_models",
+    "mcp__hindsight__search_knowledge_pages",
+    "mcp__hindsight__get_knowledge_page",
+    "mcp__hindsight__get_knowledge_tree",
     "mcp__hindsight__list_tags",
     "mcp__hindsight__get_operation",
     "mcp__hindsight__list_operations",
@@ -47618,7 +47650,7 @@ function buildRepairBankArgv(opts) {
   const script = `if command -v hindsight-admin >/dev/null 2>&1; then exec hindsight-admin "$@"; fi; ` + `exec ${HINDSIGHT_ADMIN_BIN} "$@"`;
   return [
     "exec",
-    opts.container ?? HINDSIGHT_CONTAINER_NAME,
+    opts.container ?? HINDSIGHT_CONTAINER_NAME2,
     "sh",
     "-c",
     script,
@@ -47731,7 +47763,7 @@ function classifyRepairOutcome(run) {
     detail: run.dryRun ? `Coverage complete: ${run.summary.alreadyPresent} index(es) present across ` + `${run.summary.banksScanned} bank(s), nothing to create.` : `${run.summary.created} created, ${run.summary.alreadyPresent} already present ` + `across ${run.summary.banksScanned} bank(s). Re-run \`switchroom doctor\` to confirm.`
   };
 }
-var HINDSIGHT_CONTAINER_NAME = "switchroom-hindsight", HINDSIGHT_ADMIN_BIN = "/app/api/.venv/bin/hindsight-admin", REPAIR_FAILED_EXIT = 1, REPAIR_COVERAGE_MISSING_EXIT = 3, REPAIR_UNVERIFIED_EXIT = 4;
+var HINDSIGHT_CONTAINER_NAME2 = "switchroom-hindsight", HINDSIGHT_ADMIN_BIN = "/app/api/.venv/bin/hindsight-admin", REPAIR_FAILED_EXIT = 1, REPAIR_COVERAGE_MISSING_EXIT = 3, REPAIR_UNVERIFIED_EXIT = 4;
 var init_hindsight_repair = __esm(() => {
   init_hindsight_tools();
 });
@@ -83069,7 +83101,7 @@ __export(exports_server2, {
   TOOLS: () => TOOLS2
 });
 import { randomBytes as randomBytes18 } from "node:crypto";
-import { existsSync as existsSync118 } from "node:fs";
+import { existsSync as existsSync119 } from "node:fs";
 function selfSocketPath() {
   return `/run/switchroom/hostd/${SELF_AGENT}/sock`;
 }
@@ -83096,7 +83128,7 @@ async function dispatchTool2(name, args) {
     return errorText2("hostd MCP: SWITCHROOM_AGENT_NAME env var is not set \u2014 cannot " + "determine which per-agent socket to talk to.");
   }
   const sockPath = selfSocketPath();
-  if (!existsSync118(sockPath)) {
+  if (!existsSync119(sockPath)) {
     return errorText2(`hostd MCP: socket not bound at ${sockPath}. The host-control ` + `daemon is either not installed (run \`switchroom hostd install\`) ` + `or this agent isn't admin-flagged in switchroom.yaml. RFC C ` + `bind-mounts the per-agent socket only when host_control.enabled ` + `is true AND the agent has admin: true.`);
   }
   let req;
@@ -83347,13 +83379,13 @@ function resolveAuditLogPath() {
   if (process.env.HOSTD_AUDIT_LOG_PATH)
     return process.env.HOSTD_AUDIT_LOG_PATH;
   const bindMounted = "/host-home/.switchroom/host-control-audit.log";
-  if (existsSync118(bindMounted))
+  if (existsSync119(bindMounted))
     return bindMounted;
   return defaultAuditLogPath2();
 }
 function getLastUpdateApplyStatus() {
   const path10 = resolveAuditLogPath();
-  if (!existsSync118(path10)) {
+  if (!existsSync119(path10)) {
     return errorText2(`get_status: audit log not found at ${path10}. No update_apply has run yet?`);
   }
   let raw;
@@ -83907,6 +83939,18 @@ var init_mapping = __esm(() => {
       job_spec: "keep-my-subscription-honest",
       signature: "litellm-header-passthrough:oauth-leak-scope"
     },
+    "litellm-callback-mount-missing": {
+      failure_mode: "constraint-violation",
+      severity: 3,
+      job_spec: "fleet-stays-healthy",
+      signature: "litellm-callback-mount:missing-bind"
+    },
+    "litellm-passthrough-mount-stale": {
+      failure_mode: "constraint-violation",
+      severity: 3,
+      job_spec: "fleet-stays-healthy",
+      signature: "litellm-passthrough-mount:stale-python-version"
+    },
     "litellm-timeout-budget-drift": {
       failure_mode: "drift",
       severity: 3,
@@ -84109,11 +84153,11 @@ var init_test_agents = __esm(() => {
 });
 
 // src/litellm/header-passthrough-guard.ts
-import { existsSync as existsSync121, readdirSync as readdirSync46 } from "node:fs";
+import { existsSync as existsSync122, readdirSync as readdirSync46 } from "node:fs";
 function discoverLiveLitellmConfigPath(opts) {
   const servicesDir = opts?.servicesDir ?? COOLIFY_SERVICES_DIR;
   const readdir2 = opts?.readdirFn ?? ((p) => readdirSync46(p));
-  const exists = opts?.existsFn ?? existsSync121;
+  const exists = opts?.existsFn ?? existsSync122;
   let entries;
   try {
     entries = readdir2(servicesDir);
@@ -84202,8 +84246,159 @@ var init_header_passthrough_guard = __esm(() => {
   ]);
 });
 
+// src/litellm/callback-mount-guard.ts
+function canReadComposeMounts(composeText) {
+  if (composeText == null)
+    return false;
+  return extractComposeBindTargets(composeText) !== null;
+}
+function extractCustomCallbackModules(parsed) {
+  const settings = parsed?.litellm_settings;
+  if (settings == null || typeof settings !== "object")
+    return [];
+  const out = [];
+  const seen = new Set;
+  for (const key of CALLBACK_KEYS) {
+    const raw = settings[key];
+    if (!Array.isArray(raw))
+      continue;
+    for (const entry of raw) {
+      if (typeof entry !== "string")
+        continue;
+      const reference = entry.trim();
+      const parts = reference.split(".");
+      if (parts.length !== 2)
+        continue;
+      const [module, attr] = parts;
+      if (!module || !attr)
+        continue;
+      if (seen.has(module))
+        continue;
+      seen.add(module);
+      out.push({ module, reference });
+    }
+  }
+  return out;
+}
+function extractComposeBindTargets(composeText) {
+  const targets = new Set;
+  let doc2;
+  try {
+    doc2 = import_yaml28.parse(composeText);
+  } catch {
+    return null;
+  }
+  const services = doc2?.services;
+  if (services == null || typeof services !== "object")
+    return null;
+  for (const svc of Object.values(services)) {
+    const volumes = svc?.volumes;
+    if (!Array.isArray(volumes))
+      continue;
+    for (const v of volumes) {
+      if (typeof v === "string") {
+        const parts = v.split(":");
+        if (parts.length >= 2 && parts[1])
+          targets.add(parts[1].trim());
+      } else if (v != null && typeof v === "object") {
+        const t = v.target;
+        if (typeof t === "string" && t)
+          targets.add(t.trim());
+      }
+    }
+  }
+  return targets;
+}
+function detectMissingCallbackMounts(parsedConfig, composeText) {
+  const modules = extractCustomCallbackModules(parsedConfig);
+  if (modules.length === 0 || composeText == null)
+    return [];
+  const targets = extractComposeBindTargets(composeText);
+  if (targets === null)
+    return [];
+  const violations = [];
+  for (const { module, reference } of modules) {
+    const expectedTarget = `${CONTAINER_APP_DIR}/${module}.py`;
+    if (targets.has(expectedTarget))
+      continue;
+    violations.push({
+      module,
+      reference,
+      expectedTarget,
+      detail: `litellm_settings names custom callback '${reference}' but no bind mount targets ` + `${expectedTarget} \u2014 the proxy will abort startup with ` + `ModuleNotFoundError: No module named '${module}'. Coolify regenerates this compose ` + `from services.docker_compose_raw in its database, so the mount must be restored THERE ` + `(a hand edit to the generated file is wiped on the next deploy).`
+    });
+  }
+  return violations;
+}
+var import_yaml28, CONTAINER_APP_DIR = "/app", LIVE_COMPOSE_BASENAME = "docker-compose.yml", CALLBACK_KEYS;
+var init_callback_mount_guard = __esm(() => {
+  import_yaml28 = __toESM(require_dist(), 1);
+  CALLBACK_KEYS = ["callbacks", "success_callback", "failure_callback"];
+});
+
+// src/litellm/passthrough-mount-guard.ts
+function extractVersionedSitePackagesMounts(composeText) {
+  const targets = extractComposeBindTargets(composeText);
+  if (targets === null)
+    return null;
+  const out = [];
+  for (const target of targets) {
+    const m = VERSIONED_SITE_PACKAGES_RE.exec(target);
+    if (m)
+      out.push({ target, declaredPythonVersion: m[1] });
+  }
+  return out;
+}
+function detectStalePassthroughMounts(composeText, actualPythonVersion) {
+  if (composeText == null || actualPythonVersion == null)
+    return [];
+  const mounts = extractVersionedSitePackagesMounts(composeText);
+  if (mounts === null)
+    return [];
+  const violations = [];
+  for (const { target, declaredPythonVersion } of mounts) {
+    if (declaredPythonVersion === actualPythonVersion)
+      continue;
+    violations.push({
+      target,
+      declaredPythonVersion,
+      actualPythonVersion,
+      detail: `bind mount targets ${target}, hard-coding CPython ${declaredPythonVersion}, but the live ` + `litellm image ships CPython ${actualPythonVersion} \u2014 its site-packages live under ` + `python${actualPythonVersion}/, so this mount lands at an inert path and the patch is ` + `SILENTLY dropped (no crash, no log; the proxy comes up "healthy" on unpatched code). ` + `Update the mount target to python${actualPythonVersion}/ in services.docker_compose_raw ` + `(a hand edit to the generated compose is wiped on the next Coolify deploy), then redeploy.`
+    });
+  }
+  return violations;
+}
+var VERSIONED_SITE_PACKAGES_RE;
+var init_passthrough_mount_guard = __esm(() => {
+  init_callback_mount_guard();
+  VERSIONED_SITE_PACKAGES_RE = /\/python(\d+\.\d+)\/site-packages\//;
+});
+
 // src/fleet-health/litellm-config-sensor.ts
-import { readFileSync as readFileSync110, existsSync as existsSync122 } from "node:fs";
+import { execFileSync as execFileSync35 } from "node:child_process";
+import { readFileSync as readFileSync110, existsSync as existsSync123 } from "node:fs";
+import { dirname as dirname50, join as join124 } from "node:path";
+function resolveLiveLitellmPythonVersion() {
+  try {
+    const ps = execFileSync35("docker", ["ps", "--format", "{{.Names}}\t{{.Image}}"], {
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const line = ps.split(`
+`).find((l) => /litellm-database|(^|\s)litellm/i.test(l) && l.trim().length > 0);
+    if (!line)
+      return null;
+    const name = line.split("\t")[0]?.trim();
+    if (!name)
+      return null;
+    const lsOut = execFileSync35("docker", ["exec", name, "sh", "-c", "ls -d /app/.venv/lib/python*/ 2>/dev/null"], { encoding: "utf-8", timeout: 5000, stdio: ["ignore", "pipe", "ignore"] });
+    const m = lsOut.match(/python(\d+\.\d+)/);
+    return m ? m[1] : null;
+  } catch {
+    return null;
+  }
+}
 function resolveLitellmConfigPath(explicit, discoverFn = () => discoverLiveLitellmConfigPath()) {
   if (explicit)
     return explicit;
@@ -84214,7 +84409,7 @@ function resolveLitellmConfigPath(explicit, discoverFn = () => discoverLiveLitel
 }
 function scanLitellmConfig(opts = {}) {
   const path10 = resolveLitellmConfigPath(opts.path, opts.discoverFn);
-  const exists = opts.existsFn ?? existsSync122;
+  const exists = opts.existsFn ?? existsSync123;
   const read = opts.readFn ?? ((p) => readFileSync110(p, "utf-8"));
   const log = opts.log ?? (() => {});
   const nowIso = opts.nowIso ?? new Date().toISOString();
@@ -84266,6 +84461,52 @@ function scanLitellmConfig(opts = {}) {
       ts: nowIso
     });
   }
+  const composePath = join124(dirname50(path10), LIVE_COMPOSE_BASENAME);
+  let composeText = null;
+  if (exists(composePath)) {
+    try {
+      composeText = read(composePath);
+    } catch (e) {
+      log(`fleet-health: litellm-config sensor \u2014 callback-mount check SKIPPED, ` + `${composePath} unreadable: ${String(e)}`);
+    }
+  } else {
+    log(`fleet-health: litellm-config sensor \u2014 callback-mount check SKIPPED, ` + `no ${LIVE_COMPOSE_BASENAME} beside ${path10}`);
+  }
+  const missingMounts = detectMissingCallbackMounts(parsed, composeText);
+  if (composeText !== null && !canReadComposeMounts(composeText)) {
+    log(`fleet-health: litellm-config sensor \u2014 callback-mount check SKIPPED, ` + `${composePath} has no readable services/volumes mapping`);
+  } else if (composeText !== null && missingMounts.length === 0) {
+    log(`fleet-health: litellm-config sensor OK \u2014 every custom callback module is ` + `bind-mounted by ${composePath}`);
+  }
+  for (const m of missingMounts) {
+    findings.push({
+      signal: "litellm-callback-mount-missing",
+      agent: LITELLM_PROXY_PSEUDO_AGENT,
+      turn_id: `litellm-callback-mount:${m.module}`,
+      log_pointer: `${composePath}: ${m.detail}`,
+      ts: nowIso
+    });
+  }
+  const versionedMounts = composeText !== null ? extractVersionedSitePackagesMounts(composeText) : null;
+  const hasVersionedMounts = versionedMounts !== null && versionedMounts.length > 0;
+  const pythonVersionFn = opts.pythonVersionFn ?? resolveLiveLitellmPythonVersion;
+  const actualPythonVersion = hasVersionedMounts ? pythonVersionFn() : null;
+  if (hasVersionedMounts && actualPythonVersion === null) {
+    log(`fleet-health: litellm-config sensor \u2014 passthrough-mount check SKIPPED, ` + `could not resolve the live litellm image's CPython version (docker down, no ` + `container, or off-host CI/dev)`);
+  }
+  const staleMounts = detectStalePassthroughMounts(composeText, actualPythonVersion);
+  if (hasVersionedMounts && actualPythonVersion !== null && staleMounts.length === 0) {
+    log(`fleet-health: litellm-config sensor OK \u2014 every versioned site-packages shadow ` + `mount in ${composePath} matches the live image's CPython ${actualPythonVersion}`);
+  }
+  for (const s of staleMounts) {
+    findings.push({
+      signal: "litellm-passthrough-mount-stale",
+      agent: LITELLM_PROXY_PSEUDO_AGENT,
+      turn_id: `litellm-passthrough-mount:${s.declaredPythonVersion}->${s.actualPythonVersion}`,
+      log_pointer: `${composePath}: ${s.detail}`,
+      ts: nowIso
+    });
+  }
   if (findings.length === 0)
     return { status: "ok", path: path10, findings: [] };
   for (const f of findings) {
@@ -84277,6 +84518,8 @@ var LITELLM_PROXY_PSEUDO_AGENT = "litellm-proxy";
 var init_litellm_config_sensor = __esm(() => {
   init_header_passthrough_guard();
   init_timeout_budget();
+  init_callback_mount_guard();
+  init_passthrough_mount_guard();
 });
 
 // src/fleet-health/hindsight-gpu-drift-sensor.ts
@@ -84323,18 +84566,18 @@ __export(exports_scan, {
 import {
   readFileSync as readFileSync111,
   readdirSync as readdirSync47,
-  existsSync as existsSync123,
+  existsSync as existsSync124,
   mkdirSync as mkdirSync70,
   writeFileSync as writeFileSync51
 } from "node:fs";
-import { resolve as resolve64, dirname as dirname50 } from "node:path";
+import { resolve as resolve64, dirname as dirname51 } from "node:path";
 import { homedir as homedir67 } from "node:os";
 function resolveSwitchroomBase(home2 = process.env.SWITCHROOM_HOME ?? process.env.HOME ?? homedir67()) {
   return resolve64(home2, ".switchroom");
 }
 function listAgents(base) {
   const dir = resolve64(base, "agents");
-  if (!existsSync123(dir))
+  if (!existsSync124(dir))
     return [];
   try {
     return readdirSync47(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
@@ -84363,7 +84606,7 @@ function runScan(opts = {}) {
     let gwText = "";
     let sawArtifact = false;
     try {
-      if (existsSync123(turnsPath)) {
+      if (existsSync124(turnsPath)) {
         turnsText = readFileSync111(turnsPath, "utf-8");
         sawArtifact = true;
       }
@@ -84371,7 +84614,7 @@ function runScan(opts = {}) {
       log(`fleet-health: WARN skipping ${agent} turns.jsonl unreadable: ${String(e)}`);
     }
     try {
-      if (existsSync123(gwPath)) {
+      if (existsSync124(gwPath)) {
         gwText = readFileSync111(gwPath, "utf-8");
         sawArtifact = true;
       }
@@ -84416,7 +84659,7 @@ function runScan(opts = {}) {
 function readLedgerIfPresent(base) {
   const path10 = ledgerPathForBase(base);
   try {
-    if (!existsSync123(path10))
+    if (!existsSync124(path10))
       return null;
     return JSON.parse(readFileSync111(path10, "utf-8"));
   } catch {
@@ -84424,11 +84667,11 @@ function readLedgerIfPresent(base) {
   }
 }
 function ledgerPathForBase(base) {
-  return fleetHealthLedgerPath(dirname50(base));
+  return fleetHealthLedgerPath(dirname51(base));
 }
 function writeLedger(base, ledger) {
   const path10 = ledgerPathForBase(base);
-  mkdirSync70(dirname50(path10), { recursive: true });
+  mkdirSync70(dirname51(path10), { recursive: true });
   writeFileSync51(path10, JSON.stringify(ledger, null, 2) + `
 `, "utf-8");
   return path10;
@@ -106739,6 +106982,323 @@ function redactMemoryWriteBody(body) {
 init_helpers();
 init_hindsight();
 
+// src/setup/hindsight-recall-pool.ts
+init_hindsight();
+init_hindsight_perf_defaults();
+import { execFileSync as execFileSync26 } from "node:child_process";
+var HINDSIGHT_RECALL_POOL_CONTAINER = "switchroom-hindsight-recall";
+var HINDSIGHT_RECALL_POOL_WORKER_ID = "switchroom-hindsight-recall";
+var HINDSIGHT_PG_MAX_CONNECTIONS = 250;
+var HINDSIGHT_BACKGROUND_DB_POOL_MAX_SIZE = 40;
+var HINDSIGHT_BACKGROUND_READ_DB_POOL_MAX_SIZE = 20;
+var HINDSIGHT_BACKGROUND_CONNECTION_BUDGET = HINDSIGHT_BACKGROUND_DB_POOL_MAX_SIZE + HINDSIGHT_BACKGROUND_READ_DB_POOL_MAX_SIZE;
+var HINDSIGHT_PG_SUPERUSER_RESERVED_CONNECTIONS = 3;
+var HINDSIGHT_RECALL_POOL_HEADROOM = 10;
+if (HINDSIGHT_RECALL_POOL_HEADROOM < HINDSIGHT_PG_SUPERUSER_RESERVED_CONNECTIONS) {
+  throw new Error(`HINDSIGHT_RECALL_POOL_HEADROOM (${HINDSIGHT_RECALL_POOL_HEADROOM}) must be \u2265 ` + `HINDSIGHT_PG_SUPERUSER_RESERVED_CONNECTIONS ` + `(${HINDSIGHT_PG_SUPERUSER_RESERVED_CONNECTIONS}).`);
+}
+var HINDSIGHT_RECALL_POOL_MAX_TOTAL_CONNECTIONS = HINDSIGHT_PG_MAX_CONNECTIONS - HINDSIGHT_RECALL_POOL_HEADROOM;
+var HINDSIGHT_RECALL_POOL_CONNECTION_BUDGET = HINDSIGHT_RECALL_POOL_MAX_TOTAL_CONNECTIONS - HINDSIGHT_BACKGROUND_CONNECTION_BUDGET;
+var HINDSIGHT_RECALL_POOL_DEFAULT_WORKERS = 4;
+var HINDSIGHT_RECALL_POOL_PG_DSN = "postgresql://hindsight:hindsight@127.0.0.1:5432/hindsight";
+function hindsightBackgroundApiPort(publicApiPort) {
+  return publicApiPort + 1;
+}
+function resolveHindsightLaunchPorts(input) {
+  const publicApiPort = input.configUrlPort ?? input.reuseApiPort ?? input.defaultApiPort;
+  const apiPort = input.recallEnabled ? hindsightBackgroundApiPort(publicApiPort) : publicApiPort;
+  return { publicApiPort, basePorts: { apiPort, uiPort: input.uiPort } };
+}
+function publicPortIsUnserved(input) {
+  if (input.configUrlPort == null || input.authorityApiPort == null)
+    return false;
+  if (input.poolRunning)
+    return false;
+  return input.authorityApiPort !== input.configUrlPort;
+}
+function planStaleRecallPoolConvergence(input) {
+  if (input.recallEnabled)
+    return { action: "none" };
+  if (!input.poolRunning)
+    return { action: "none" };
+  if (input.configUrlPort == null || input.authorityApiPort == null) {
+    return { action: "none" };
+  }
+  if (input.authorityApiPort === input.configUrlPort)
+    return { action: "stop-pool" };
+  return { action: "relaunch-single-on-public", publicApiPort: input.configUrlPort };
+}
+function recallPoolDbPoolSizing(workers) {
+  const perWorker = Math.floor(HINDSIGHT_RECALL_POOL_CONNECTION_BUDGET / workers);
+  const dbPoolMaxSize = Math.max(1, Math.floor(perWorker * 0.4));
+  const readDbPoolMaxSize = Math.max(1, perWorker - dbPoolMaxSize);
+  return { dbPoolMaxSize, readDbPoolMaxSize };
+}
+function assertRecallPoolConnectionBudget(cfg) {
+  const poolDemand = cfg.workers * (cfg.dbPoolMaxSize + cfg.readDbPoolMaxSize);
+  const total = poolDemand + HINDSIGHT_BACKGROUND_CONNECTION_BUDGET;
+  if (total > HINDSIGHT_RECALL_POOL_MAX_TOTAL_CONNECTIONS) {
+    throw new Error(`hindsight.recall_pool connection budget overflow: ${cfg.workers} workers \u00d7 ` + `(${cfg.dbPoolMaxSize} write + ${cfg.readDbPoolMaxSize} read) = ${poolDemand}, ` + `plus ${HINDSIGHT_BACKGROUND_CONNECTION_BUDGET} background = ${total} > the ` + `${HINDSIGHT_RECALL_POOL_MAX_TOTAL_CONNECTIONS}-connection ceiling ` + `(pg0 max_connections=${HINDSIGHT_PG_MAX_CONNECTIONS} \u2212 ` + `${HINDSIGHT_RECALL_POOL_HEADROOM} headroom, which reserves PG's ` + `${HINDSIGHT_PG_SUPERUSER_RESERVED_CONNECTIONS} superuser slots plus ` + `maintenance). Lower hindsight.recall_pool.workers or its ` + `db_pool_max_size/read_db_pool_max_size.`);
+  }
+}
+function resolveRecallPoolConfig(input) {
+  if (!input || input.enabled !== true)
+    return null;
+  const workers = input.workers && input.workers > 0 ? Math.floor(input.workers) : HINDSIGHT_RECALL_POOL_DEFAULT_WORKERS;
+  const autoSized = recallPoolDbPoolSizing(workers);
+  const cfg = {
+    workers,
+    dbPoolMaxSize: input.db_pool_max_size && input.db_pool_max_size > 0 ? Math.floor(input.db_pool_max_size) : autoSized.dbPoolMaxSize,
+    readDbPoolMaxSize: input.read_db_pool_max_size && input.read_db_pool_max_size > 0 ? Math.floor(input.read_db_pool_max_size) : autoSized.readDbPoolMaxSize
+  };
+  assertRecallPoolConnectionBudget(cfg);
+  return cfg;
+}
+function backgroundContainerPoolEnv() {
+  return {
+    HINDSIGHT_API_DB_POOL_MAX_SIZE: String(HINDSIGHT_BACKGROUND_DB_POOL_MAX_SIZE),
+    HINDSIGHT_API_READ_DB_POOL_MAX_SIZE: String(HINDSIGHT_BACKGROUND_READ_DB_POOL_MAX_SIZE)
+  };
+}
+var HINDSIGHT_SPLIT_MANAGED_DB_POOL_KEYS = [
+  "HINDSIGHT_API_DB_POOL_MAX_SIZE",
+  "HINDSIGHT_API_READ_DB_POOL_MAX_SIZE"
+];
+function splitDbPoolEnvConflicts(operatorEnv, cfg) {
+  if (!operatorEnv)
+    return [];
+  const authority = backgroundContainerPoolEnv();
+  const pool = {
+    HINDSIGHT_API_DB_POOL_MAX_SIZE: String(cfg.dbPoolMaxSize),
+    HINDSIGHT_API_READ_DB_POOL_MAX_SIZE: String(cfg.readDbPoolMaxSize)
+  };
+  const out = [];
+  for (const key of HINDSIGHT_SPLIT_MANAGED_DB_POOL_KEYS) {
+    const operatorValue = operatorEnv[key];
+    if (operatorValue === undefined)
+      continue;
+    out.push({
+      key,
+      operatorValue: String(operatorValue),
+      authorityValue: authority[key],
+      poolValue: pool[key]
+    });
+  }
+  return out;
+}
+function splitDbPoolEnvConflictWarning(c) {
+  const knob = c.key === "HINDSIGHT_API_DB_POOL_MAX_SIZE" ? "hindsight.recall_pool.db_pool_max_size" : "hindsight.recall_pool.read_db_pool_max_size";
+  return `hindsight.env.${c.key}=${c.operatorValue} is IGNORED while ` + `hindsight.recall_pool.enabled is true: the split computes this cap for both ` + `containers (authority ${c.authorityValue}, recall pool ${c.poolValue}) so the ` + `pg0 connection budget stays provable. Set \`${knob}\` instead \u2014 it is budget-checked \u2014 ` + `or set hindsight.recall_pool.enabled: false to have hindsight.env win again.`;
+}
+function splitContainerPerfEnv(operatorEnv) {
+  return { ...operatorEnv ?? {}, ...backgroundContainerPoolEnv() };
+}
+function recallPoolEnvOverrides(cfg, poolPort) {
+  return [
+    ["HINDSIGHT_API_HOST", HINDSIGHT_HOST_NETWORK_BIND_ADDR],
+    ["HINDSIGHT_API_PORT", String(poolPort)],
+    ["HINDSIGHT_API_DATABASE_URL", HINDSIGHT_RECALL_POOL_PG_DSN],
+    ["HINDSIGHT_API_DB_URL", HINDSIGHT_RECALL_POOL_PG_DSN],
+    ["HINDSIGHT_API_WORKERS", String(cfg.workers)],
+    ["HINDSIGHT_API_WORKER_ENABLED", "false"],
+    ["HINDSIGHT_API_RUN_MIGRATIONS_ON_STARTUP", "false"],
+    ["HINDSIGHT_ENABLE_CP", "false"],
+    ["HINDSIGHT_API_WORKER_ID", HINDSIGHT_RECALL_POOL_WORKER_ID],
+    ["HINDSIGHT_API_DB_POOL_MAX_SIZE", String(cfg.dbPoolMaxSize)],
+    ["HINDSIGHT_API_READ_DB_POOL_MAX_SIZE", String(cfg.readDbPoolMaxSize)]
+  ];
+}
+function applyRecallPoolEnvOverrides(base, overrides) {
+  const overrideMap = new Map(overrides);
+  const seen = new Set;
+  const out = [];
+  for (const [k, v] of base) {
+    if (overrideMap.has(k)) {
+      out.push([k, overrideMap.get(k)]);
+      seen.add(k);
+    } else {
+      out.push([k, v]);
+    }
+  }
+  for (const [k, v] of overrides) {
+    if (!seen.has(k))
+      out.push([k, v]);
+  }
+  return out;
+}
+function hindsightRecallPoolEnvPairs(opts) {
+  const { cfg, poolPort, litellm, llm, gpu, perf, cpAccessKey } = opts;
+  const base = hindsightContainerEnvPairs({
+    apiPort: poolPort,
+    litellm,
+    llm,
+    gpu,
+    perf,
+    cpAccessKey
+  });
+  return applyRecallPoolEnvOverrides(base, recallPoolEnvOverrides(cfg, poolPort));
+}
+function startHindsightRecallPool(opts) {
+  const {
+    cfg,
+    poolPort,
+    imageTag,
+    litellm,
+    llm,
+    gpu,
+    perf,
+    cpAccessKey,
+    mirrorDir,
+    exec = (cmd, args2) => {
+      execFileSync26(cmd, args2, { stdio: "pipe" });
+    }
+  } = opts;
+  assertRecallPoolConnectionBudget(cfg);
+  const envArgs = hindsightRecallPoolEnvPairs({
+    cfg,
+    poolPort,
+    litellm,
+    llm,
+    gpu,
+    perf,
+    cpAccessKey
+  }).flatMap(([k, v]) => ["-e", `${k}=${v}`]);
+  const probe2 = pickHindsightLiteLlmProbeUrl(llm, litellm);
+  const healthCmd = probe2 ? buildLiteLlmAwareHealthCmd(poolPort, probe2) : HINDSIGHT_HEALTHCHECK_CMD.replace("localhost:8888", `localhost:${poolPort}`);
+  const args = [
+    "run",
+    "-d",
+    "--name",
+    HINDSIGHT_RECALL_POOL_CONTAINER,
+    "--restart",
+    "always",
+    "--shm-size",
+    HINDSIGHT_DEFAULT_SHM_SIZE,
+    ...hindsightGpuEnabled(gpu) ? ["--gpus", "all"] : [],
+    "--network",
+    "host",
+    "--user",
+    "hindsight",
+    "--health-cmd",
+    healthCmd,
+    "--health-interval",
+    "30s",
+    "--health-timeout",
+    "5s",
+    "--health-retries",
+    "3",
+    "--health-start-period",
+    "60s",
+    ...mirrorDir ? ["-v", `${HINDSIGHT_CREDS_MIRROR_VOLUME}:${HINDSIGHT_CRED_DIR}`] : ["--tmpfs", `${HINDSIGHT_CRED_DIR}:rw,mode=0700,uid=${HINDSIGHT_DEFAULT_UID},gid=${HINDSIGHT_DEFAULT_UID}`],
+    "-v",
+    `${HINDSIGHT_BROKER_SOCK_VOLUME}:/run/switchroom/auth-broker`,
+    ...envArgs,
+    hindsightImageRef(imageTag)
+  ];
+  exec("docker", args);
+}
+function stopHindsightRecallPool(exec = (cmd, args) => {
+  execFileSync26(cmd, args, { stdio: "pipe" });
+}) {
+  try {
+    exec("docker", ["update", "--restart=no", HINDSIGHT_RECALL_POOL_CONTAINER]);
+  } catch {}
+  try {
+    exec("docker", ["stop", HINDSIGHT_RECALL_POOL_CONTAINER]);
+  } catch {}
+  try {
+    exec("docker", ["rm", "-f", HINDSIGHT_RECALL_POOL_CONTAINER]);
+  } catch {}
+}
+function isHindsightRecallPoolRunning(probe2 = defaultDockerProbe) {
+  return dockerNameMatchesExactly(probe2, ["ps", "--filter", `name=${HINDSIGHT_RECALL_POOL_CONTAINER}`, "--format", "{{.Names}}"], HINDSIGHT_RECALL_POOL_CONTAINER);
+}
+var HINDSIGHT_HEALTH_MIN_TIMEOUT_MS = 150000;
+var HINDSIGHT_HEALTH_PHASE_BUDGET_MS = {
+  apiStartup: 60000,
+  pgFirstBoot: 90000,
+  migrations: 90000,
+  perExtraWorker: 15000
+};
+function hindsightHealthTimeoutMs(input) {
+  const p = HINDSIGHT_HEALTH_PHASE_BUDGET_MS;
+  let budget;
+  switch (input.role) {
+    case "authority":
+    case "single-container":
+      budget = p.apiStartup + p.pgFirstBoot + p.migrations;
+      break;
+    case "recall-pool": {
+      const workers = input.workers && input.workers > 0 ? input.workers : 1;
+      budget = p.apiStartup + (workers - 1) * p.perExtraWorker;
+      break;
+    }
+  }
+  return Math.max(HINDSIGHT_HEALTH_MIN_TIMEOUT_MS, budget);
+}
+async function waitForHindsightHealthy(port, opts = {}) {
+  const {
+    timeoutMs = opts.role ? hindsightHealthTimeoutMs({ role: opts.role, workers: opts.workers }) : HINDSIGHT_HEALTH_MIN_TIMEOUT_MS,
+    intervalMs = 3000,
+    fetchImpl = fetch,
+    sleep: sleep4 = (ms) => new Promise((r) => setTimeout(r, ms)),
+    now: now2 = () => Date.now()
+  } = opts;
+  const deadline = now2() + timeoutMs;
+  for (;; ) {
+    try {
+      const res = await fetchImpl(`http://127.0.0.1:${port}/health`, {
+        signal: AbortSignal.timeout(4000)
+      });
+      if (res.ok)
+        return true;
+    } catch {}
+    if (now2() >= deadline)
+      return false;
+    await sleep4(intervalMs);
+  }
+}
+async function launchRecallPoolHealthGated(opts) {
+  const log = opts.log ?? (() => {});
+  log(`  Waiting for the authority container to become healthy on ` + `${opts.authorityApiPort} (pg0 startup)...`);
+  if (!await opts.waitForHealthy(opts.authorityApiPort, "authority")) {
+    return { outcome: "authority-unhealthy" };
+  }
+  opts.stopPool();
+  log(`  Starting recall pool (${opts.workers} workers) on ${opts.publicApiPort}...`);
+  opts.startPool();
+  if (await opts.waitForHealthy(opts.publicApiPort, "recall-pool")) {
+    return { outcome: "split" };
+  }
+  const reason = `the recall pool did not become healthy on ${opts.publicApiPort}`;
+  log(`  Recall pool unhealthy on ${opts.publicApiPort}; degrading to a single ` + `container on the public port so memory.config.url stays served...`);
+  opts.degradeToSingleContainer();
+  if (await opts.waitForHealthy(opts.publicApiPort, "single-container")) {
+    return { outcome: "degraded-single-container", reason };
+  }
+  return { outcome: "degrade-failed", reason };
+}
+async function convergeStaleRecallPool(opts) {
+  const log = opts.log ?? (() => {});
+  switch (opts.plan.action) {
+    case "none":
+      return { outcome: "nothing-to-do" };
+    case "stop-pool":
+      log("  hindsight.recall_pool is disabled but a recall pool container is running; " + "the authority already serves the public port, so removing the orphan pool...");
+      opts.stopPool();
+      return { outcome: "pool-stopped" };
+    case "relaunch-single-on-public": {
+      const publicApiPort = opts.plan.publicApiPort;
+      log(`  hindsight.recall_pool is disabled but a recall pool container still holds the ` + `public port ${publicApiPort}; relaunching a single container on it to match the ` + `declared topology...`);
+      opts.relaunchSingleOnPublic(publicApiPort);
+      if (await opts.waitForHealthy(publicApiPort, "single-container")) {
+        return { outcome: "relaunched-single", publicApiPort };
+      }
+      return { outcome: "relaunch-failed", publicApiPort };
+    }
+  }
+}
+
 // src/setup/hindsight-gpu-guard.ts
 init_hindsight();
 function assessHindsightGpuDrop(args) {
@@ -107116,6 +107676,7 @@ Cross-agent reflection plan
         return;
       }
       console.log(source_default.gray("  Stopping switchroom-hindsight..."));
+      stopHindsightRecallPool();
       stopHindsight();
       console.log(source_default.green("  Hindsight container stopped and removed."));
       return;
@@ -107171,6 +107732,182 @@ Cross-agent reflection plan
     }
     const reusePorts = recreate ? getRunningHindsightPorts() : null;
     if (isHindsightRunning() && !recreate) {
+      let noRecreatePoolCfg = null;
+      try {
+        noRecreatePoolCfg = resolveRecallPoolConfig(getConfig(program3).hindsight?.recall_pool);
+      } catch {
+        noRecreatePoolCfg = null;
+      }
+      if (noRecreatePoolCfg && !isHindsightRecallPoolRunning()) {
+        console.log(source_default.gray(`
+  Authority container is up but the recall pool is not \u2014 restoring the pool...`));
+        const repairConfig = getConfig(program3);
+        const repairGpu = hindsightGpuDecision(resolveHindsightGpuOverride({ flag: opts.gpu, config: repairConfig.hindsight?.gpu }));
+        const repairConfigUrlPort = (() => {
+          try {
+            const p = Number(new URL(repairConfig.memory?.config?.url ?? "").port);
+            return Number.isInteger(p) && p > 0 ? p : undefined;
+          } catch {
+            return;
+          }
+        })();
+        const { publicApiPort: repairPublicPort, basePorts: repairBasePorts } = resolveHindsightLaunchPorts({
+          recallEnabled: true,
+          configUrlPort: repairConfigUrlPort,
+          reuseApiPort: undefined,
+          uiPort: 0,
+          defaultApiPort: HINDSIGHT_DEFAULT_API_PORT
+        });
+        try {
+          const { litellm: repairLitellm } = await resolveLiteLLMForHindsight(repairConfig);
+          const repairLlm = await getResolvedLlm();
+          const repairCpAccessKey = await resolveHindsightCpAccessKey(repairConfig);
+          for (const conflict of splitDbPoolEnvConflicts(repairConfig.hindsight?.env, noRecreatePoolCfg)) {
+            console.log(source_default.yellow(`  ! ${splitDbPoolEnvConflictWarning(conflict)}`));
+          }
+          const repairAuthorityEnv = splitContainerPerfEnv(repairConfig.hindsight?.env);
+          const repairResult = await launchRecallPoolHealthGated({
+            publicApiPort: repairPublicPort,
+            authorityApiPort: repairBasePorts.apiPort,
+            workers: noRecreatePoolCfg.workers,
+            waitForHealthy: (p, role) => waitForHindsightHealthy(p, { role, workers: noRecreatePoolCfg.workers }),
+            stopPool: () => stopHindsightRecallPool(),
+            startPool: () => startHindsightRecallPool({
+              cfg: noRecreatePoolCfg,
+              poolPort: repairPublicPort,
+              imageTag: effectiveTag,
+              litellm: repairLitellm,
+              llm: repairLlm,
+              gpu: repairGpu.enabled,
+              perf: {
+                env: repairAuthorityEnv,
+                memLimit: repairConfig.hindsight?.mem_limit
+              },
+              cpAccessKey: repairCpAccessKey,
+              mirrorDir: hindsightConsumerMirrorDir(repairConfig)
+            }),
+            degradeToSingleContainer: () => {
+              const uiPort2 = getRunningHindsightPorts()?.uiPort ?? HINDSIGHT_DEFAULT_UI_PORT;
+              stopHindsightRecallPool();
+              stopHindsight();
+              startHindsight({ apiPort: repairPublicPort, uiPort: uiPort2 }, repairLitellm, effectiveTag, repairLlm, hindsightConsumerMirrorDir(repairConfig), repairGpu.enabled, { env: repairConfig.hindsight?.env, memLimit: repairConfig.hindsight?.mem_limit }, repairCpAccessKey);
+            },
+            log: (m) => console.log(source_default.gray(m))
+          });
+          switch (repairResult.outcome) {
+            case "split":
+              console.log(source_default.green(`
+  Recall pool restored on ${repairPublicPort} ` + `(authority on ${repairBasePorts.apiPort}).
+`));
+              break;
+            case "degraded-single-container":
+              console.log(source_default.yellow(`
+  ! Recall pool failed (${repairResult.reason}); DEGRADED to a single ` + `container on the public port ${repairPublicPort}. memory.config.url IS ` + `served, but the recall split is OFF \u2014 inspect \`docker logs ` + `${HINDSIGHT_RECALL_POOL_CONTAINER}\` and re-run \`switchroom memory setup ` + `--recreate\` once fixed, or set hindsight.recall_pool.enabled: false.
+`));
+              break;
+            case "authority-unhealthy":
+              console.error(source_default.red(`
+  The running authority container is not answering /health on ` + `${repairBasePorts.apiPort}; cannot restore the pool. Inspect ` + `\`docker logs switchroom-hindsight\` and re-run \`switchroom memory setup ` + `--recreate\`.
+`));
+              process.exit(1);
+              break;
+            case "degrade-failed":
+              console.error(source_default.red(`
+  Recall pool restore failed AND the single-container fallback could not ` + `bind the public port ${repairPublicPort}. Inspect \`docker logs ` + `switchroom-hindsight\` and \`docker logs ${HINDSIGHT_RECALL_POOL_CONTAINER}\`, ` + `then re-run \`switchroom memory setup --recreate\`.
+`));
+              process.exit(1);
+              break;
+          }
+        } catch (err) {
+          console.error(source_default.red(`
+  Failed to restore the recall pool: ${err.message}
+`));
+          process.exit(1);
+        }
+        const repairUrl = `http://127.0.0.1:${repairPublicPort}/mcp/`;
+        try {
+          if (persistMemoryConfigUrl(getConfigPath(program3), "claude-code", repairUrl)) {
+            console.log(source_default.gray(`  Updated ${getConfigPath(program3)} with memory.config.url = ${repairUrl}`));
+          }
+        } catch (err) {
+          console.error(source_default.yellow(`  Note: could not auto-update switchroom.yaml: ${err.message}`));
+        }
+        return;
+      }
+      const livePorts = getRunningHindsightPorts();
+      const liveApiPort = livePorts?.apiPort;
+      const liveConfigUrlPort = (() => {
+        try {
+          const p = Number(new URL(getConfig(program3).memory?.config?.url ?? "").port);
+          return Number.isInteger(p) && p > 0 ? p : undefined;
+        } catch {
+          return;
+        }
+      })();
+      const stalePlan = planStaleRecallPoolConvergence({
+        recallEnabled: noRecreatePoolCfg !== null,
+        poolRunning: isHindsightRecallPoolRunning(),
+        authorityApiPort: liveApiPort,
+        configUrlPort: liveConfigUrlPort
+      });
+      if (stalePlan.action !== "none") {
+        const staleConfig = getConfig(program3);
+        const staleGpu = hindsightGpuDecision(resolveHindsightGpuOverride({ flag: opts.gpu, config: staleConfig.hindsight?.gpu }));
+        try {
+          const needsSecrets = stalePlan.action === "relaunch-single-on-public";
+          const staleLitellm = needsSecrets ? (await resolveLiteLLMForHindsight(staleConfig)).litellm : undefined;
+          const staleLlm = needsSecrets ? await getResolvedLlm() : undefined;
+          const staleCpAccessKey = needsSecrets ? await resolveHindsightCpAccessKey(staleConfig) : undefined;
+          const staleResult = await convergeStaleRecallPool({
+            plan: stalePlan,
+            stopPool: () => stopHindsightRecallPool(),
+            relaunchSingleOnPublic: (publicApiPort2) => {
+              stopHindsightRecallPool();
+              stopHindsight();
+              startHindsight({ apiPort: publicApiPort2, uiPort: livePorts?.uiPort ?? HINDSIGHT_DEFAULT_UI_PORT }, staleLitellm, effectiveTag, staleLlm, hindsightConsumerMirrorDir(staleConfig), staleGpu.enabled, { env: staleConfig.hindsight?.env, memLimit: staleConfig.hindsight?.mem_limit }, staleCpAccessKey);
+            },
+            waitForHealthy: (p, role) => waitForHindsightHealthy(p, { role }),
+            log: (m) => console.log(source_default.gray(m))
+          });
+          switch (staleResult.outcome) {
+            case "pool-stopped":
+              console.log(source_default.green(`
+  Removed the orphan recall pool (hindsight.recall_pool is disabled).
+`));
+              break;
+            case "relaunched-single":
+              console.log(source_default.green(`
+  Converged to the declared single-container topology on ` + `${staleResult.publicApiPort}.
+`));
+              break;
+            case "relaunch-failed":
+              console.error(source_default.red(`
+  hindsight.recall_pool is disabled, but the single container relaunched ` + `on the public port ${staleResult.publicApiPort} did not become healthy \u2014 ` + `nothing is serving fleet memory. Inspect \`docker logs ` + `switchroom-hindsight --tail 50\`, then re-run \`switchroom memory setup ` + `--recreate\`.
+`));
+              process.exit(1);
+              break;
+            case "nothing-to-do":
+              break;
+          }
+        } catch (err) {
+          console.error(source_default.red(`
+  Failed to converge the stale recall pool: ${err.message}
+`));
+          process.exit(1);
+        }
+        return;
+      }
+      if (publicPortIsUnserved({
+        configUrlPort: liveConfigUrlPort,
+        authorityApiPort: liveApiPort,
+        poolRunning: isHindsightRecallPoolRunning()
+      })) {
+        console.error(source_default.red(`
+  switchroom-hindsight is running on port ${liveApiPort}, but ` + `memory.config.url points at ${liveConfigUrlPort} and nothing is serving ` + `it \u2014 fleet memory is DOWN.
+` + `  Run \`switchroom memory setup --recreate\` to rebind it to ` + `${liveConfigUrlPort}, or set hindsight.recall_pool.enabled: true to restore ` + `the recall pool on the public port.
+`));
+        process.exit(1);
+      }
       console.log(source_default.green(`
   Hindsight container is already running (switchroom-hindsight).
 `));
@@ -107253,31 +107990,24 @@ Cross-agent reflection plan
         process.exit(1);
       }
     }
+    stopHindsightRecallPool();
     if (isHindsightContainerExists()) {
       console.log(source_default.gray("  Removing existing switchroom-hindsight container..."));
       stopHindsight();
     }
-    let ports;
+    let recallPoolCfg;
+    try {
+      recallPoolCfg = resolveRecallPoolConfig(getConfig(program3).hindsight?.recall_pool);
+    } catch (err) {
+      console.log(source_default.yellow(`  ! Ignoring hindsight.recall_pool (${err.message}); ` + `starting the single-container topology.`));
+      recallPoolCfg = null;
+    }
+    let uiPort;
     if (reusePorts) {
-      ports = reusePorts;
-      if (reusePorts.apiPort !== HINDSIGHT_DEFAULT_API_PORT) {
-        let explicitUrl;
-        try {
-          explicitUrl = getConfig(program3).memory?.config?.url;
-        } catch {
-          explicitUrl = undefined;
-        }
-        if (!explicitUrl) {
-          console.log(source_default.yellow(`
-  \u26a0  MIGRATION HAZARD: reusing stale host port ${reusePorts.apiPort} ` + `for switchroom-hindsight, but scaffolding now defaults to ` + `${HINDSIGHT_DEFAULT_API_PORT} and no explicit memory.config.url is set.`));
-          console.log(source_default.yellow(`  Agents may be repointed to a dead URL (http://127.0.0.1:${HINDSIGHT_DEFAULT_API_PORT}/mcp/) ` + `while the container listens on ${reusePorts.apiPort}.`));
-          console.log(source_default.yellow(`  Fix: set memory.config.url: http://127.0.0.1:${reusePorts.apiPort}/mcp/ explicitly, ` + `or migrate the container to port ${HINDSIGHT_DEFAULT_API_PORT}.
-`));
-        }
-      }
+      uiPort = reusePorts.uiPort;
     } else {
       try {
-        ports = await pickHindsightPorts();
+        uiPort = (await pickHindsightPorts()).uiPort;
       } catch (err) {
         console.error(source_default.red(`
   ${err.message}
@@ -107285,31 +108015,39 @@ Cross-agent reflection plan
         process.exit(1);
       }
     }
-    if (ports.apiPort !== HINDSIGHT_DEFAULT_API_PORT) {
-      console.log(source_default.yellow(`  Port ${HINDSIGHT_DEFAULT_API_PORT} is already in use; ` + `using ${ports.apiPort}/${ports.uiPort} instead.`));
-    }
-    let conflict = await preflightHindsightPorts(ports);
-    if (conflict) {
-      const heldBy = conflict.holder ? ` (held by ${conflict.holder})` : "";
-      console.log(source_default.yellow(`
-  Chosen Hindsight port ${conflict.port} is occupied${heldBy}; ` + `selecting a free port instead of crash-looping.`));
+    const configUrlPort = (() => {
       try {
-        ports = await pickHindsightPorts();
-      } catch (err) {
-        console.error(source_default.red(`
-  ${err.message}
-`));
-        process.exit(1);
+        const p = Number(new URL(getConfig(program3).memory?.config?.url ?? "").port);
+        return Number.isInteger(p) && p > 0 ? p : undefined;
+      } catch {
+        return;
       }
-      conflict = await preflightHindsightPorts(ports);
+    })();
+    const { publicApiPort, basePorts } = resolveHindsightLaunchPorts({
+      recallEnabled: recallPoolCfg != null,
+      configUrlPort,
+      reuseApiPort: reusePorts?.apiPort,
+      uiPort,
+      defaultApiPort: HINDSIGHT_DEFAULT_API_PORT
+    });
+    if (!recallPoolCfg && configUrlPort == null && reusePorts && reusePorts.apiPort !== HINDSIGHT_DEFAULT_API_PORT) {
+      console.log(source_default.yellow(`
+  Note: reusing host port ${reusePorts.apiPort} for switchroom-hindsight ` + `(scaffolding default is ${HINDSIGHT_DEFAULT_API_PORT}); memory.config.url will be ` + `pinned to ${reusePorts.apiPort} so agents follow the live port. Migrate deliberately ` + `if you want ${HINDSIGHT_DEFAULT_API_PORT}.
+`));
+    }
+    if (recallPoolCfg) {
+      console.log(source_default.gray(`  recall_pool enabled: authority (pg0 + background) on ${basePorts.apiPort}, ` + `${recallPoolCfg.workers}-worker recall pool on ${publicApiPort}.`));
+    }
+    const portsToBind = recallPoolCfg ? [publicApiPort, basePorts.apiPort, basePorts.uiPort] : [basePorts.apiPort, basePorts.uiPort];
+    for (const p of portsToBind) {
+      const conflict = await preflightHindsightPorts({ apiPort: p, uiPort: p });
       if (conflict) {
-        const stillHeldBy = conflict.holder ? ` (held by ${conflict.holder})` : "";
+        const heldBy = conflict.holder ? ` (held by ${conflict.holder})` : "";
         console.error(source_default.red(`
-  Refusing to start Hindsight: port ${conflict.port} is still ` + `occupied${stillHeldBy} after reassignment. Free it and retry ` + `\`switchroom memory --start\`.
+  Refusing to start Hindsight: port ${conflict.port} is occupied${heldBy}. ` + `Free it and retry \`switchroom memory setup --recreate\`.
 `));
         process.exit(1);
       }
-      console.log(source_default.green(`  Reassigned Hindsight to port ${ports.apiPort}/${ports.uiPort}.`));
     }
     if (opts.provider && opts.provider !== "claude-code") {
       console.log(source_default.gray(`  Note: --provider=${opts.provider} ignored. switchroom-hindsight is pinned to the ` + "`claude-code` provider (subscription-honest). The flag is kept for back-compat."));
@@ -107329,23 +108067,83 @@ Cross-agent reflection plan
       for (const drop of await diffDroppedHindsightLlmVaultKeys(hindsightConfig.hindsight?.llm, resolvedLlm)) {
         console.log(source_default.yellow(`  ! ${hindsightLlmDroppedKeyWarning(drop)}`));
       }
-      startHindsight(ports, litellmCfg, effectiveTag, resolvedLlm, hindsightConsumerMirrorDir(hindsightConfig), gpuDecision.enabled, {
-        env: hindsightConfig.hindsight?.env,
+      if (recallPoolCfg) {
+        for (const conflict of splitDbPoolEnvConflicts(hindsightConfig.hindsight?.env, recallPoolCfg)) {
+          console.log(source_default.yellow(`  ! ${splitDbPoolEnvConflictWarning(conflict)}`));
+        }
+      }
+      const authorityEnv = recallPoolCfg ? splitContainerPerfEnv(hindsightConfig.hindsight?.env) : hindsightConfig.hindsight?.env;
+      startHindsight(basePorts, litellmCfg, effectiveTag, resolvedLlm, hindsightConsumerMirrorDir(hindsightConfig), gpuDecision.enabled, {
+        env: authorityEnv,
         memLimit: hindsightConfig.hindsight?.mem_limit
       }, cpAccessKey);
       if (litellmCfg) {
         console.log(source_default.gray("  LiteLLM routing enabled for hindsight (--network host)."));
       }
-      console.log(source_default.green(`
-  Hindsight container started (switchroom-hindsight) on port ${ports.apiPort}.
+      if (recallPoolCfg) {
+        const launchResult = await launchRecallPoolHealthGated({
+          publicApiPort,
+          authorityApiPort: basePorts.apiPort,
+          workers: recallPoolCfg.workers,
+          waitForHealthy: (p, role) => waitForHindsightHealthy(p, { role, workers: recallPoolCfg.workers }),
+          stopPool: () => stopHindsightRecallPool(),
+          startPool: () => startHindsightRecallPool({
+            cfg: recallPoolCfg,
+            poolPort: publicApiPort,
+            imageTag: effectiveTag,
+            litellm: litellmCfg,
+            llm: resolvedLlm,
+            gpu: gpuDecision.enabled,
+            perf: {
+              env: authorityEnv,
+              memLimit: hindsightConfig.hindsight?.mem_limit
+            },
+            cpAccessKey,
+            mirrorDir: hindsightConsumerMirrorDir(hindsightConfig)
+          }),
+          degradeToSingleContainer: () => {
+            stopHindsightRecallPool();
+            stopHindsight();
+            startHindsight({ apiPort: publicApiPort, uiPort: basePorts.uiPort }, litellmCfg, effectiveTag, resolvedLlm, hindsightConsumerMirrorDir(hindsightConfig), gpuDecision.enabled, { env: hindsightConfig.hindsight?.env, memLimit: hindsightConfig.hindsight?.mem_limit }, cpAccessKey);
+          },
+          log: (m) => console.log(source_default.gray(m))
+        });
+        switch (launchResult.outcome) {
+          case "split":
+            console.log(source_default.green(`
+  Hindsight recall split started: authority (pg0 + background) on ` + `${basePorts.apiPort}, ${recallPoolCfg.workers}-worker recall pool on ${publicApiPort}.
+`));
+            break;
+          case "degraded-single-container":
+            console.log(source_default.yellow(`
+  ! Recall pool failed (${launchResult.reason}); DEGRADED to a single ` + `container on the public port ${publicApiPort}. memory.config.url IS served, ` + `but the recall split is OFF \u2014 inspect \`docker logs ` + `${HINDSIGHT_RECALL_POOL_CONTAINER}\` and re-run \`switchroom memory setup ` + `--recreate\` once fixed, or set hindsight.recall_pool.enabled: false.
+`));
+            break;
+          case "authority-unhealthy":
+            console.error(source_default.red(`
+  Authority container did not become healthy on ${basePorts.apiPort}. ` + `The recall pool was NOT started and no single container could share its ` + `pg0. Investigate \`docker logs switchroom-hindsight\` and re-run ` + `\`switchroom memory setup --recreate\`.
+`));
+            process.exit(1);
+            break;
+          case "degrade-failed":
+            console.error(source_default.red(`
+  Recall pool did not become healthy on ${publicApiPort} AND the ` + `single-container fallback also failed to bind the public port. Inspect ` + `\`docker logs switchroom-hindsight\` and \`docker logs ` + `${HINDSIGHT_RECALL_POOL_CONTAINER}\`, then re-run \`switchroom memory setup ` + `--recreate\`.
 `));
+            process.exit(1);
+            break;
+        }
+      } else {
+        console.log(source_default.green(`
+  Hindsight container started (switchroom-hindsight) on port ${basePorts.apiPort}.
+`));
+      }
     } catch (err) {
       console.error(source_default.red(`
   Failed to start Hindsight: ${err.message}
 `));
       process.exit(1);
     }
-    const url = `http://127.0.0.1:${ports.apiPort}/mcp/`;
+    const url = `http://127.0.0.1:${publicApiPort}/mcp/`;
     const configPath = getConfigPath(program3);
     try {
       if (persistMemoryConfigUrl(configPath, provider, url)) {
@@ -107401,7 +108199,7 @@ Cross-agent reflection plan
     }
     console.log();
   }));
-  memory.command("repair").description("Verify and rebuild a bank's per-(bank, fact_type) vector index coverage (hindsight >= 0.8.5) \u2014 the fix for a restored/upgraded bank whose recall silently under-returns").option("--bank <id>", "Bank id to repair (mutually exclusive with --all)").option("--agent <name>", "Repair the bank belonging to this agent (resolves the bank id for you)").option("--all", "Repair every bank in the base schema and all discovered tenant schemas").option("--schema <name>", "Limit to a single schema (default: base + discovered tenant schemas)").option("--dry-run", "Report what would be repaired without creating or dropping any index").option("--container <name>", `Hindsight container name (default: ${HINDSIGHT_CONTAINER_NAME})`).action(withConfigError(async (opts) => {
+  memory.command("repair").description("Verify and rebuild a bank's per-(bank, fact_type) vector index coverage (hindsight >= 0.8.5) \u2014 the fix for a restored/upgraded bank whose recall silently under-returns").option("--bank <id>", "Bank id to repair (mutually exclusive with --all)").option("--agent <name>", "Repair the bank belonging to this agent (resolves the bank id for you)").option("--all", "Repair every bank in the base schema and all discovered tenant schemas").option("--schema <name>", "Limit to a single schema (default: base + discovered tenant schemas)").option("--dry-run", "Report what would be repaired without creating or dropping any index").option("--container <name>", `Hindsight container name (default: ${HINDSIGHT_CONTAINER_NAME2})`).action(withConfigError(async (opts) => {
     const config = getConfig(program3);
     if (opts.agent && opts.bank) {
       console.error(source_default.red("Pass either --agent or --bank, not both."));
@@ -112043,8 +112841,8 @@ init_embedded_examples();
 init_atomic();
 init_loader();
 init_scaffold();
-import { existsSync as existsSync85, readFileSync as readFileSync79, mkdirSync as mkdirSync47, statSync as statSync47, writeFileSync as writeFileSync33 } from "node:fs";
-import { execFileSync as execFileSync26 } from "node:child_process";
+import { existsSync as existsSync86, readFileSync as readFileSync79, mkdirSync as mkdirSync47, statSync as statSync47, writeFileSync as writeFileSync33 } from "node:fs";
+import { execFileSync as execFileSync27 } from "node:child_process";
 import { resolve as resolve46, dirname as dirname36 } from "node:path";
 init_state();
 init_vault();
@@ -112052,7 +112850,6 @@ init_manager();
 init_onboarding();
 init_gpu_detect();
 init_host_capabilities();
-init_hindsight();
 init_posthog();
 
 // src/cli/setup-posture-rewrite.ts
@@ -112443,6 +113240,9 @@ class SetupVerificationError extends Error {
 init_lifecycle();
 init_timezone();
 init_schema();
+
+// src/cli/setup-step-ui.ts
+init_source();
 var STEP_PENDING = source_default.gray("\u25cb");
 var STEP_ACTIVE = source_default.blue("->");
 var STEP_DONE = source_default.green("OK");
@@ -112453,6 +113253,315 @@ function stepHeaderTo(log, num3, title, status) {
   log(`
 ${status} ${source_default.bold(`Step ${num3}:`)} ${title}`);
 }
+
+// src/cli/setup-memory-backend.ts
+init_source();
+init_loader();
+init_hindsight();
+import { existsSync as existsSync85 } from "node:fs";
+var HINDSIGHT_READY_RETRIES = 5;
+var HINDSIGHT_READY_INTERVAL_MS = 1000;
+async function resolveLiteLLMForHindsight2(config, deps = {}) {
+  return resolveHindsightLiteLlm(config, deps);
+}
+function isMemoryBackendDisabled(config) {
+  const memoryBackend = config.memory?.backend ?? "hindsight";
+  return process.env.SWITCHROOM_MEMORY_BACKEND === "none" || memoryBackend === "none";
+}
+async function stepMemoryBackend(config, nonInteractive, switchroomConfigPath, deps = {}) {
+  stepHeader(6, "Memory backend", STEP_ACTIVE);
+  const sleep4 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const pickPorts = deps.pickPorts ?? pickHindsightPorts;
+  const preflightPorts = deps.preflightPorts ?? preflightHindsightPorts;
+  if (isMemoryBackendDisabled(config)) {
+    console.log(source_default.gray("  Memory backend disabled (set to 'none')."));
+    console.log(source_default.green(`  ${STEP_DONE} Skipped`));
+    return { hindsightExpected: false, optedOut: true };
+  }
+  let setupHindsight = true;
+  if (!nonInteractive) {
+    console.log(source_default.gray("  Hindsight will use Anthropic OAuth via the auth-broker. The fleet's"));
+    console.log(source_default.gray("  active account (auth.active) is shared \u2014 no OpenAI API key is needed."));
+    setupHindsight = await askYesNo("  Set up Hindsight memory? (recommended)", true);
+  }
+  if (!setupHindsight) {
+    console.log(source_default.gray("  Skipping Hindsight setup."));
+    console.log(source_default.green(`  ${STEP_DONE} Skipped`));
+    return { hindsightExpected: false, optedOut: false };
+  }
+  if (process.env.HINDSIGHT_API_LLM_API_KEY) {
+    console.log(source_default.gray("  Note: HINDSIGHT_API_LLM_API_KEY is set in your env but is no longer used. " + "You can remove it."));
+  }
+  try {
+    const vaultPath = resolvePath(config.vault?.path ?? "~/.switchroom/vault.enc");
+    const passphrase = process.env.SWITCHROOM_VAULT_PASSPHRASE;
+    if (passphrase && existsSync85(vaultPath)) {
+      const { getStringSecret: getStringSecret2 } = await Promise.resolve().then(() => (init_vault(), exports_vault));
+      const existing = getStringSecret2(passphrase, vaultPath, "hindsight-api-key");
+      if (existing) {
+        console.log(source_default.gray("  Note: legacy 'hindsight-api-key' is in your vault but is no longer used. You can remove it with `switchroom vault rm hindsight-api-key`."));
+      }
+    }
+  } catch {}
+  {
+    try {
+      const result = await ensureHindsightConsumer(switchroomConfigPath);
+      if (result.added) {
+        console.log(source_default.green(`  ${STEP_DONE} Registered auth.consumers[${HINDSIGHT_CONSUMER_NAME}] (follows the fleet active account)`));
+      } else {
+        console.log(source_default.gray(`  auth.consumers[${HINDSIGHT_CONSUMER_NAME}] already present.`));
+      }
+    } catch (err) {
+      console.log(source_default.yellow(`  Warning: could not write auth.consumers entry: ${err.message}`));
+    }
+  }
+  const dockerState = probeDockerAvailability(deps.dockerProbe);
+  if (dockerState !== "ok") {
+    const noCli = dockerState === "no-cli";
+    const headline = noCli ? "Docker is not installed (no `docker` command on PATH)." : "Docker is installed but its daemon is not responding.";
+    const remedy = noCli ? "Install Docker (https://docs.docker.com/get-docker/), then re-run `switchroom setup`" : "Start Docker (on macOS: open Docker Desktop; on Linux: `sudo systemctl start docker`), then re-run `switchroom setup`";
+    console.log(source_default.red(`  x ${headline}`));
+    console.log(source_default.gray("  Hindsight memory runs as a Docker container (and so does every agent)."));
+    console.log(source_default.gray(`  ${remedy} \u2014 or re-run with SWITCHROOM_MEMORY_BACKEND=none to skip memory setup.`));
+    throw new Error(`Memory backend setup failed: ${headline} ${remedy}, or set SWITCHROOM_MEMORY_BACKEND=none to skip it.`);
+  }
+  let recallPoolCfg;
+  try {
+    recallPoolCfg = resolveRecallPoolConfig(config.hindsight?.recall_pool);
+  } catch (err) {
+    console.log(source_default.yellow(`  ! Ignoring hindsight.recall_pool (${err.message}); starting the single-container topology.`));
+    recallPoolCfg = null;
+  }
+  if (recallPoolCfg) {
+    for (const conflict2 of splitDbPoolEnvConflicts(config.hindsight?.env, recallPoolCfg)) {
+      console.log(source_default.yellow(`  ! ${splitDbPoolEnvConflictWarning(conflict2)}`));
+    }
+  }
+  const startPool = deps.startRecallPool ?? startHindsightRecallPool;
+  const waitHealthy = deps.waitForHealthy ?? waitForHindsightHealthy;
+  const waitHealthyFor = (port, role) => waitHealthy(port, { role, workers: recallPoolCfg?.workers });
+  const poolIsRunning = deps.recallPoolRunningProbe ?? isHindsightRecallPoolRunning;
+  const stopPool = deps.stopRecallPool ?? stopHindsightRecallPool;
+  const parseUrlPort = (u) => {
+    try {
+      const p = Number(new URL(u ?? "").port);
+      return Number.isInteger(p) && p > 0 ? p : undefined;
+    } catch {
+      return;
+    }
+  };
+  const resolveLaunchSecrets = async () => {
+    const { litellm: litellmCfg, droppedRef: litellmDroppedRef } = await resolveLiteLLMForHindsight2(config, deps.getViaBrokerStructured ? { getViaBrokerStructured: deps.getViaBrokerStructured } : {});
+    if (litellmDroppedRef) {
+      console.log(source_default.yellow(`  ! ${hindsightLiteLlmDroppedKeyWarning(litellmDroppedRef)}`));
+    }
+    const cpAccessKey = await resolveHindsightCpAccessKey(config);
+    if (!cpAccessKey) {
+      console.log(source_default.yellow(`  ! ${HINDSIGHT_CP_NO_ACCESS_KEY_WARNING}`));
+    }
+    const resolvedLlm = await resolveHindsightLlmSecrets(config.hindsight?.llm, deps.getViaBrokerStructured ? { getViaBrokerStructured: deps.getViaBrokerStructured } : {});
+    for (const drop of await diffDroppedHindsightLlmVaultKeys(config.hindsight?.llm, resolvedLlm)) {
+      console.log(source_default.yellow(`  ! ${hindsightLlmDroppedKeyWarning(drop)}`));
+    }
+    return { litellmCfg, cpAccessKey, resolvedLlm };
+  };
+  const launchRecallPool = async (cfg, publicApiPort2, authorityApiPort, fallbackUiPort, secrets) => {
+    const startContainer = deps.startContainer ?? startHindsight;
+    const result = await launchRecallPoolHealthGated({
+      publicApiPort: publicApiPort2,
+      authorityApiPort,
+      workers: cfg.workers,
+      waitForHealthy: waitHealthyFor,
+      stopPool,
+      startPool: () => startPool({
+        cfg,
+        poolPort: publicApiPort2,
+        litellm: secrets.litellmCfg,
+        llm: secrets.resolvedLlm,
+        perf: {
+          env: splitContainerPerfEnv(config.hindsight?.env),
+          memLimit: config.hindsight?.mem_limit
+        },
+        cpAccessKey: secrets.cpAccessKey,
+        mirrorDir: hindsightConsumerMirrorDir(config)
+      }),
+      degradeToSingleContainer: () => {
+        stopPool();
+        (deps.stopContainer ?? stopHindsight)();
+        startContainer({ apiPort: publicApiPort2, uiPort: fallbackUiPort }, secrets.litellmCfg, undefined, secrets.resolvedLlm, hindsightConsumerMirrorDir(config), undefined, { env: config.hindsight?.env, memLimit: config.hindsight?.mem_limit }, secrets.cpAccessKey);
+      },
+      log: (m) => console.log(source_default.gray(m))
+    });
+    switch (result.outcome) {
+      case "split":
+        return "split";
+      case "degraded-single-container":
+        console.log(source_default.yellow(`  ! Recall pool failed (${result.reason}); DEGRADED to a single container on the public port ${publicApiPort2}. memory.config.url IS served, but the recall split is ` + `OFF \u2014 inspect \`docker logs ${HINDSIGHT_RECALL_POOL_CONTAINER}\` and re-run \`switchroom setup\` once fixed, or set hindsight.recall_pool.enabled: false.`));
+        return "degraded";
+      case "authority-unhealthy":
+        throw new Error(`Memory backend setup failed: the authority container did not become healthy on ${authorityApiPort}. Check \`docker logs switchroom-hindsight --tail 50\`, then re-run \`switchroom setup\`, or set hindsight.recall_pool.enabled: false to skip the split.`);
+      case "degrade-failed":
+        throw new Error(`Memory backend setup failed: the recall pool did not become healthy on ${publicApiPort2} AND the single-container fallback also failed to bind the public port. Inspect \`docker logs switchroom-hindsight --tail 50\` and \`docker logs ${HINDSIGHT_RECALL_POOL_CONTAINER}\`, then re-run \`switchroom setup\`, or set hindsight.recall_pool.enabled: false to skip the split.`);
+    }
+  };
+  if (isHindsightRunning(deps.dockerProbe)) {
+    if (recallPoolCfg && !poolIsRunning(deps.dockerProbe)) {
+      console.log(source_default.gray("  Authority container is up but the recall pool is not \u2014 restoring the pool..."));
+      const secrets = await resolveLaunchSecrets();
+      const { publicApiPort: publicApiPort2, basePorts: basePorts2 } = resolveHindsightLaunchPorts({
+        recallEnabled: true,
+        configUrlPort: parseUrlPort(config.memory?.config?.url),
+        reuseApiPort: undefined,
+        uiPort: 0,
+        defaultApiPort: HINDSIGHT_DEFAULT_API_PORT
+      });
+      const topo = await launchRecallPool(recallPoolCfg, publicApiPort2, basePorts2.apiPort, HINDSIGHT_DEFAULT_UI_PORT, secrets);
+      if (topo === "split") {
+        console.log(source_default.green(`  ${STEP_DONE} Recall pool restored on ${publicApiPort2} (authority on ${basePorts2.apiPort})`));
+      }
+      return { hindsightExpected: true, optedOut: false };
+    }
+    const staleRunningPorts = (deps.runningPortsProbe ?? getRunningHindsightPorts)();
+    const stalePlan = planStaleRecallPoolConvergence({
+      recallEnabled: recallPoolCfg !== null,
+      poolRunning: poolIsRunning(deps.dockerProbe),
+      authorityApiPort: staleRunningPorts?.apiPort,
+      configUrlPort: parseUrlPort(config.memory?.config?.url)
+    });
+    if (stalePlan.action !== "none") {
+      const staleSecrets = stalePlan.action === "relaunch-single-on-public" ? await resolveLaunchSecrets() : undefined;
+      const startContainer = deps.startContainer ?? startHindsight;
+      const staleResult = await convergeStaleRecallPool({
+        plan: stalePlan,
+        stopPool,
+        relaunchSingleOnPublic: (publicApiPort2) => {
+          stopPool();
+          (deps.stopContainer ?? stopHindsight)();
+          startContainer({
+            apiPort: publicApiPort2,
+            uiPort: staleRunningPorts?.uiPort ?? HINDSIGHT_DEFAULT_UI_PORT
+          }, staleSecrets.litellmCfg, undefined, staleSecrets.resolvedLlm, hindsightConsumerMirrorDir(config), undefined, { env: config.hindsight?.env, memLimit: config.hindsight?.mem_limit }, staleSecrets.cpAccessKey);
+        },
+        waitForHealthy: waitHealthyFor,
+        log: (m) => console.log(source_default.gray(m))
+      });
+      if (staleResult.outcome === "relaunch-failed") {
+        const msg = `hindsight.recall_pool is disabled, but the single container relaunched on the public port ${staleResult.publicApiPort} did not become healthy \u2014 nothing is ` + `serving fleet memory.`;
+        console.log(source_default.red(`  x ${msg}`));
+        throw new Error(`Memory backend setup failed: ${msg} Inspect \`docker logs switchroom-hindsight --tail 50\`, then re-run \`switchroom setup\`.`);
+      }
+      if (staleResult.outcome === "pool-stopped") {
+        console.log(source_default.green(`  ${STEP_DONE} Removed the orphan recall pool (hindsight.recall_pool is disabled)`));
+      } else if (staleResult.outcome === "relaunched-single") {
+        console.log(source_default.green(`  ${STEP_DONE} Converged to the declared single-container topology on ${staleResult.publicApiPort}`));
+      }
+      return { hindsightExpected: true, optedOut: false };
+    }
+    const runningPorts = staleRunningPorts;
+    if (publicPortIsUnserved({
+      configUrlPort: parseUrlPort(config.memory?.config?.url),
+      authorityApiPort: runningPorts?.apiPort,
+      poolRunning: poolIsRunning(deps.dockerProbe)
+    })) {
+      const publicPort = parseUrlPort(config.memory?.config?.url);
+      const msg = `switchroom-hindsight is running on port ${runningPorts?.apiPort}, but memory.config.url points at ${publicPort} and nothing is serving it \u2014 ` + `fleet memory is DOWN.`;
+      console.log(source_default.red(`  x ${msg}`));
+      throw new Error(`Memory backend setup failed: ${msg} Run \`switchroom memory setup --recreate\` to rebind it to ${publicPort}, or set hindsight.recall_pool.enabled: true to restore the recall pool on the public port.`);
+    }
+    console.log(source_default.green(`  ${STEP_DONE} Hindsight container already running (switchroom-hindsight)`));
+    return { hindsightExpected: true, optedOut: false };
+  }
+  if (isHindsightContainerExists(deps.dockerProbe)) {
+    console.log(source_default.gray("  Found stopped switchroom-hindsight container, removing..."));
+    stopHindsight();
+  }
+  stopPool();
+  let ports;
+  try {
+    ports = await pickPorts();
+  } catch (err) {
+    console.log(source_default.red(`  ${err.message}`));
+    throw new Error(`Memory backend setup failed: could not allocate Hindsight ports: ${err.message}. Free a port and re-run \`switchroom setup\`, or set SWITCHROOM_MEMORY_BACKEND=none to skip it.`);
+  }
+  if (ports.apiPort !== HINDSIGHT_DEFAULT_API_PORT) {
+    console.log(source_default.yellow(`  Port ${HINDSIGHT_DEFAULT_API_PORT} is already in use; using ${ports.apiPort}/${ports.uiPort} instead.`));
+  }
+  let conflict = await preflightPorts(ports);
+  if (conflict) {
+    const heldBy = conflict.holder ? ` (held by ${conflict.holder})` : "";
+    console.log(source_default.yellow(`  Chosen Hindsight port ${conflict.port} is occupied${heldBy}; selecting a free port instead of crash-looping.`));
+    try {
+      ports = await pickPorts();
+    } catch (err) {
+      console.log(source_default.red(`  ${err.message}`));
+      throw new Error(`Memory backend setup failed: could not allocate Hindsight ports after reassignment: ${err.message}. Free a port and re-run \`switchroom setup\`, or set SWITCHROOM_MEMORY_BACKEND=none to skip it.`);
+    }
+    conflict = await preflightPorts(ports);
+    if (conflict) {
+      const stillHeldBy = conflict.holder ? ` (held by ${conflict.holder})` : "";
+      const msg = `Refusing to start Hindsight: port ${conflict.port} is still occupied${stillHeldBy} after reassignment.`;
+      console.log(source_default.red(`  ${msg}`));
+      throw new Error(`Memory backend setup failed: ${msg} Free it and re-run \`switchroom setup\`, or set SWITCHROOM_MEMORY_BACKEND=none to skip it.`);
+    }
+    console.log(source_default.green(`  Reassigned Hindsight to port ${ports.apiPort}/${ports.uiPort}.`));
+  }
+  const { publicApiPort, basePorts } = resolveHindsightLaunchPorts({
+    recallEnabled: recallPoolCfg != null,
+    configUrlPort: parseUrlPort(config.memory?.config?.url),
+    reuseApiPort: ports.apiPort,
+    uiPort: ports.uiPort,
+    defaultApiPort: HINDSIGHT_DEFAULT_API_PORT
+  });
+  if (recallPoolCfg) {
+    const bgConflict = await preflightPorts({
+      apiPort: basePorts.apiPort,
+      uiPort: basePorts.apiPort
+    });
+    if (bgConflict) {
+      const heldBy = bgConflict.holder ? ` (held by ${bgConflict.holder})` : "";
+      const msg = `Refusing to start the hindsight recall split: authority port ${bgConflict.port} is occupied${heldBy}.`;
+      console.log(source_default.red(`  ${msg}`));
+      throw new Error(`Memory backend setup failed: ${msg} Free it and re-run \`switchroom setup\`, or set hindsight.recall_pool.enabled: false to skip the split.`);
+    }
+  }
+  const spin = spinner("Starting Hindsight Docker container...");
+  let launchSecrets;
+  try {
+    launchSecrets = await resolveLaunchSecrets();
+    const authorityEnv = recallPoolCfg ? splitContainerPerfEnv(config.hindsight?.env) : config.hindsight?.env;
+    const startContainer = deps.startContainer ?? startHindsight;
+    startContainer(basePorts, launchSecrets.litellmCfg, undefined, launchSecrets.resolvedLlm, hindsightConsumerMirrorDir(config), undefined, { env: authorityEnv, memLimit: config.hindsight?.mem_limit }, launchSecrets.cpAccessKey);
+    if (launchSecrets.litellmCfg) {
+      console.log(source_default.gray("  LiteLLM routing enabled (--network host, ANTHROPIC_BASE_URL set)."));
+    }
+  } catch (err) {
+    spin.stop(source_default.red(`Failed to start Hindsight: ${err.message}`));
+    console.log(source_default.gray(`  Make sure \`switchroom apply\` has run so the auth-broker consumer socket volume (auth-broker-${HINDSIGHT_CONSUMER_NAME}-sock) exists.`));
+    throw new Error(`Memory backend setup failed: ${err.message}. Fix the cause and re-run \`switchroom setup\`, or set SWITCHROOM_MEMORY_BACKEND=none to skip it.`);
+  }
+  let running = isHindsightRunning(deps.dockerProbe);
+  const retries = deps.readyRetries ?? HINDSIGHT_READY_RETRIES;
+  for (let i2 = 0;!running && i2 < retries; i2++) {
+    await sleep4(HINDSIGHT_READY_INTERVAL_MS);
+    running = isHindsightRunning(deps.dockerProbe);
+  }
+  if (!running) {
+    spin.stop(source_default.red("Hindsight container did not stay running after start"));
+    throw new Error("Memory backend setup failed: switchroom-hindsight did not stay running after start. Check `docker logs switchroom-hindsight --tail 50`, then re-run `switchroom setup`, or set SWITCHROOM_MEMORY_BACKEND=none to skip it.");
+  }
+  spin.stop(source_default.green(`${STEP_DONE} Hindsight container started (switchroom-hindsight)`));
+  if (recallPoolCfg) {
+    const topo = await launchRecallPool(recallPoolCfg, publicApiPort, basePorts.apiPort, basePorts.uiPort, launchSecrets);
+    if (topo === "split") {
+      console.log(source_default.green(`  ${STEP_DONE} Hindsight recall split started: authority (pg0 + background) on ${basePorts.apiPort}, ${recallPoolCfg.workers}-worker recall pool on ${publicApiPort}`));
+    }
+  }
+  console.log(source_default.gray(`  API: http://localhost:${publicApiPort}/mcp`));
+  console.log(source_default.gray(`  UI:  http://localhost:${basePorts.uiPort}`));
+  return { hindsightExpected: true, optedOut: false };
+}
+
+// src/cli/setup.ts
 function writeSwitchroomYaml(configPath, text) {
   let mode = 420;
   try {
@@ -112555,7 +113664,7 @@ async function stepConfigFile(configPath, nonInteractive) {
       existingConfig = null;
     }
   }
-  if (existingConfig && existsSync85(existingConfig)) {
+  if (existingConfig && existsSync86(existingConfig)) {
     if (!nonInteractive) {
       const useExisting = await askYesNo(`  Found ${source_default.cyan(existingConfig)}. Use it?`, true);
       if (!useExisting) {
@@ -112701,7 +113810,7 @@ async function resolveOrPromptToken(rawToken, label, config, nonInteractive) {
       try {
         const { openVault: openVault2 } = await Promise.resolve().then(() => (init_vault(), exports_vault));
         const vaultPath = resolvePath(config.vault?.path ?? "~/.switchroom/vault.enc");
-        if (existsSync85(vaultPath)) {
+        if (existsSync86(vaultPath)) {
           const secrets = openVault2(passphrase, vaultPath);
           const key = rawToken.replace("vault:", "");
           const entry = secrets[key];
@@ -112729,7 +113838,7 @@ async function resolveOrPromptToken(rawToken, label, config, nonInteractive) {
 async function storeTokenInVault(config, vaultRef, token) {
   const vaultPath = resolvePath(config.vault?.path ?? "~/.switchroom/vault.enc");
   const key = vaultRef.replace("vault:", "");
-  if (!existsSync85(vaultPath)) {
+  if (!existsSync86(vaultPath)) {
     console.log(source_default.gray("  Creating encrypted vault..."));
     let passphrase = process.env.SWITCHROOM_VAULT_PASSPHRASE;
     if (!passphrase) {
@@ -112876,145 +113985,6 @@ async function stepCreateTopics(config, botToken, nonInteractive) {
     }
   }
 }
-async function resolveLiteLLMForHindsight2(config, deps = {}) {
-  return resolveHindsightLiteLlm(config, deps);
-}
-function isMemoryBackendDisabled(config) {
-  const memoryBackend = config.memory?.backend ?? "hindsight";
-  return process.env.SWITCHROOM_MEMORY_BACKEND === "none" || memoryBackend === "none";
-}
-async function stepMemoryBackend(config, nonInteractive, switchroomConfigPath, deps = {}) {
-  stepHeader(6, "Memory backend", STEP_ACTIVE);
-  const sleep4 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
-  if (isMemoryBackendDisabled(config)) {
-    console.log(source_default.gray("  Memory backend disabled (set to 'none')."));
-    console.log(source_default.green(`  ${STEP_DONE} Skipped`));
-    return { hindsightExpected: false, optedOut: true };
-  }
-  let setupHindsight = true;
-  if (!nonInteractive) {
-    console.log(source_default.gray("  Hindsight will use Anthropic OAuth via the auth-broker. The fleet's"));
-    console.log(source_default.gray("  active account (auth.active) is shared \u2014 no OpenAI API key is needed."));
-    setupHindsight = await askYesNo("  Set up Hindsight memory? (recommended)", true);
-  }
-  if (!setupHindsight) {
-    console.log(source_default.gray("  Skipping Hindsight setup."));
-    console.log(source_default.green(`  ${STEP_DONE} Skipped`));
-    return { hindsightExpected: false, optedOut: false };
-  }
-  if (process.env.HINDSIGHT_API_LLM_API_KEY) {
-    console.log(source_default.gray("  Note: HINDSIGHT_API_LLM_API_KEY is set in your env but is no longer used. You can remove it."));
-  }
-  try {
-    const vaultPath = resolvePath(config.vault?.path ?? "~/.switchroom/vault.enc");
-    const passphrase = process.env.SWITCHROOM_VAULT_PASSPHRASE;
-    if (passphrase && existsSync85(vaultPath)) {
-      const existing = getStringSecret(passphrase, vaultPath, "hindsight-api-key");
-      if (existing) {
-        console.log(source_default.gray("  Note: legacy 'hindsight-api-key' is in your vault but is no longer used. You can remove it with `switchroom vault rm hindsight-api-key`."));
-      }
-    }
-  } catch {}
-  {
-    try {
-      const result = await ensureHindsightConsumer(switchroomConfigPath);
-      if (result.added) {
-        console.log(source_default.green(`  ${STEP_DONE} Registered auth.consumers[${HINDSIGHT_CONSUMER_NAME}] (follows the fleet active account)`));
-      } else {
-        console.log(source_default.gray(`  auth.consumers[${HINDSIGHT_CONSUMER_NAME}] already present.`));
-      }
-    } catch (err) {
-      console.log(source_default.yellow(`  Warning: could not write auth.consumers entry: ${err.message}`));
-    }
-  }
-  const dockerState = probeDockerAvailability(deps.dockerProbe);
-  if (dockerState !== "ok") {
-    const noCli = dockerState === "no-cli";
-    const headline = noCli ? "Docker is not installed (no `docker` command on PATH)." : "Docker is installed but its daemon is not responding.";
-    const remedy = noCli ? "Install Docker (https://docs.docker.com/get-docker/), then re-run `switchroom setup`" : "Start Docker (on macOS: open Docker Desktop; on Linux: `sudo systemctl start docker`), then re-run `switchroom setup`";
-    console.log(source_default.red(`  x ${headline}`));
-    console.log(source_default.gray("  Hindsight memory runs as a Docker container (and so does every agent)."));
-    console.log(source_default.gray(`  ${remedy} \u2014 or re-run with SWITCHROOM_MEMORY_BACKEND=none to skip memory setup.`));
-    throw new Error(`Memory backend setup failed: ${headline} ${remedy}, or set SWITCHROOM_MEMORY_BACKEND=none to skip it.`);
-  }
-  if (isHindsightRunning(deps.dockerProbe)) {
-    console.log(source_default.green(`  ${STEP_DONE} Hindsight container already running (switchroom-hindsight)`));
-    return { hindsightExpected: true, optedOut: false };
-  }
-  if (isHindsightContainerExists(deps.dockerProbe)) {
-    console.log(source_default.gray("  Found stopped switchroom-hindsight container, removing..."));
-    stopHindsight();
-  }
-  let ports;
-  try {
-    ports = await pickHindsightPorts();
-  } catch (err) {
-    console.log(source_default.red(`  ${err.message}`));
-    throw new Error(`Memory backend setup failed: could not allocate Hindsight ports: ${err.message}. Free a port and re-run \`switchroom setup\`, or set SWITCHROOM_MEMORY_BACKEND=none to skip it.`);
-  }
-  if (ports.apiPort !== HINDSIGHT_DEFAULT_API_PORT) {
-    console.log(source_default.yellow(`  Port ${HINDSIGHT_DEFAULT_API_PORT} is already in use; using ${ports.apiPort}/${ports.uiPort} instead.`));
-  }
-  let conflict = await preflightHindsightPorts(ports);
-  if (conflict) {
-    const heldBy = conflict.holder ? ` (held by ${conflict.holder})` : "";
-    console.log(source_default.yellow(`  Chosen Hindsight port ${conflict.port} is occupied${heldBy}; selecting a free port instead of crash-looping.`));
-    try {
-      ports = await pickHindsightPorts();
-    } catch (err) {
-      console.log(source_default.red(`  ${err.message}`));
-      throw new Error(`Memory backend setup failed: could not allocate Hindsight ports after reassignment: ${err.message}. Free a port and re-run \`switchroom setup\`, or set SWITCHROOM_MEMORY_BACKEND=none to skip it.`);
-    }
-    conflict = await preflightHindsightPorts(ports);
-    if (conflict) {
-      const stillHeldBy = conflict.holder ? ` (held by ${conflict.holder})` : "";
-      const msg = `Refusing to start Hindsight: port ${conflict.port} is still occupied${stillHeldBy} after reassignment.`;
-      console.log(source_default.red(`  ${msg}`));
-      throw new Error(`Memory backend setup failed: ${msg} Free it and re-run \`switchroom setup\`, or set SWITCHROOM_MEMORY_BACKEND=none to skip it.`);
-    }
-    console.log(source_default.green(`  Reassigned Hindsight to port ${ports.apiPort}/${ports.uiPort}.`));
-  }
-  const spin = spinner("Starting Hindsight Docker container...");
-  try {
-    const { litellm: litellmCfg, droppedRef: litellmDroppedRef } = await resolveLiteLLMForHindsight2(config, deps.getViaBrokerStructured ? { getViaBrokerStructured: deps.getViaBrokerStructured } : {});
-    if (litellmDroppedRef) {
-      console.log(source_default.yellow(`  ! ${hindsightLiteLlmDroppedKeyWarning(litellmDroppedRef)}`));
-    }
-    const cpAccessKey = await resolveHindsightCpAccessKey(config);
-    if (!cpAccessKey) {
-      console.log(source_default.yellow(`  ! ${HINDSIGHT_CP_NO_ACCESS_KEY_WARNING}`));
-    }
-    const resolvedLlm = await resolveHindsightLlmSecrets(config.hindsight?.llm, deps.getViaBrokerStructured ? { getViaBrokerStructured: deps.getViaBrokerStructured } : {});
-    for (const drop of await diffDroppedHindsightLlmVaultKeys(config.hindsight?.llm, resolvedLlm)) {
-      console.log(source_default.yellow(`  ! ${hindsightLlmDroppedKeyWarning(drop)}`));
-    }
-    const startContainer = deps.startContainer ?? startHindsight;
-    startContainer(ports, litellmCfg, undefined, resolvedLlm, hindsightConsumerMirrorDir(config), undefined, { env: config.hindsight?.env, memLimit: config.hindsight?.mem_limit }, cpAccessKey);
-    if (litellmCfg) {
-      console.log(source_default.gray("  LiteLLM routing enabled (--network host, ANTHROPIC_BASE_URL set)."));
-    }
-  } catch (err) {
-    spin.stop(source_default.red(`Failed to start Hindsight: ${err.message}`));
-    console.log(source_default.gray(`  Make sure \`switchroom apply\` has run so the auth-broker consumer socket volume (auth-broker-${HINDSIGHT_CONSUMER_NAME}-sock) exists.`));
-    throw new Error(`Memory backend setup failed: ${err.message}. Fix the cause and re-run \`switchroom setup\`, or set SWITCHROOM_MEMORY_BACKEND=none to skip it.`);
-  }
-  let running = isHindsightRunning(deps.dockerProbe);
-  const retries = deps.readyRetries ?? HINDSIGHT_READY_RETRIES;
-  for (let i2 = 0;!running && i2 < retries; i2++) {
-    await sleep4(HINDSIGHT_READY_INTERVAL_MS);
-    running = isHindsightRunning(deps.dockerProbe);
-  }
-  if (!running) {
-    spin.stop(source_default.red("Hindsight container did not stay running after start"));
-    throw new Error("Memory backend setup failed: switchroom-hindsight did not stay running after start. Check `docker logs switchroom-hindsight --tail 50`, then re-run `switchroom setup`, or set SWITCHROOM_MEMORY_BACKEND=none to skip it.");
-  }
-  spin.stop(source_default.green(`${STEP_DONE} Hindsight container started (switchroom-hindsight)`));
-  console.log(source_default.gray(`  API: http://localhost:${ports.apiPort}/mcp`));
-  console.log(source_default.gray(`  UI:  http://localhost:${ports.uiPort}`));
-  return { hindsightExpected: true, optedOut: false };
-}
-var HINDSIGHT_READY_RETRIES = 5;
-var HINDSIGHT_READY_INTERVAL_MS = 1000;
 function stepVoiceEngine() {
   stepHeader(7, "Voice engine", STEP_ACTIVE);
   let caps;
@@ -113151,13 +114121,13 @@ async function stepAutoUnlock(config, switchroomConfigPath, nonInteractive) {
     return;
   }
   const vaultPath = resolvePath(config.vault?.path ?? "~/.switchroom/vault.enc");
-  if (!existsSync85(vaultPath)) {
+  if (!existsSync86(vaultPath)) {
     console.log(source_default.gray("  Skipping (vault not created yet)."));
     return;
   }
   const credPathRaw = config.vault?.broker?.autoUnlockCredentialPath ?? "~/.switchroom/vault-auto-unlock";
   const credPath = resolvePath(credPathRaw);
-  if (config.vault?.broker?.autoUnlock === true && existsSync85(credPath)) {
+  if (config.vault?.broker?.autoUnlock === true && existsSync86(credPath)) {
     console.log(source_default.green(`  ${STEP_DONE} Already configured (${credPath})`));
     return;
   }
@@ -113235,7 +114205,7 @@ async function stepAutoUnlock(config, switchroomConfigPath, nonInteractive) {
   }
 }
 function persistApprovalAuthTelegramId(configPath) {
-  if (!existsSync85(configPath)) {
+  if (!existsSync86(configPath)) {
     throw new ConfigError(`Cannot persist vault.broker.approvalAuth: config not found at ${configPath}`);
   }
   const content = readFileSync79(configPath, "utf-8");
@@ -113246,7 +114216,7 @@ function persistApprovalAuthTelegramId(configPath) {
   return result.kind;
 }
 function persistDangerousMode(config, configPath) {
-  if (!existsSync85(configPath)) {
+  if (!existsSync86(configPath)) {
     throw new ConfigError(`Cannot persist dangerous_mode: config not found at ${configPath}`);
   }
   let content = readFileSync79(configPath, "utf-8");
@@ -113357,7 +114327,7 @@ var START_OUTPUT_TAIL_LINES = 12;
 function defaultStartAgent(name) {
   let out = "";
   try {
-    out = execFileSync26("switchroom", ["agent", "start", name], {
+    out = execFileSync27("switchroom", ["agent", "start", name], {
       stdio: ["ignore", "pipe", "pipe"],
       encoding: "utf-8"
     });
@@ -113385,7 +114355,7 @@ async function stepVerification(config, nonInteractive, deps = {}, expect = {})
   const findings = [];
   let applyPending = false;
   if (!nonInteractive && agentNames.length > 0) {
-    const composeExists = (deps.composeFileExists ?? (() => existsSync85(composeFilePath())))();
+    const composeExists = (deps.composeFileExists ?? (() => existsSync86(composeFilePath())))();
     if (!composeExists) {
       applyPending = true;
       log(source_default.gray("  Not started: `switchroom apply` has not generated the compose file yet."));
@@ -113482,7 +114452,7 @@ init_source();
 init_loader();
 init_lifecycle();
 init_compose_env();
-import { existsSync as existsSync88, mkdirSync as mkdirSync50, readFileSync as readFileSync82, realpathSync as realpathSync8, statSync as statSync49, chownSync as chownSync10 } from "node:fs";
+import { existsSync as existsSync89, mkdirSync as mkdirSync50, readFileSync as readFileSync82, realpathSync as realpathSync8, statSync as statSync49, chownSync as chownSync10 } from "node:fs";
 import { spawnSync as spawnSync20 } from "node:child_process";
 import { join as join92, dirname as dirname39 } from "node:path";
 import { homedir as homedir48 } from "node:os";
@@ -113929,7 +114899,7 @@ import {
   closeSync as closeSync15,
   copyFileSync as copyFileSync12,
   createWriteStream,
-  existsSync as existsSync86,
+  existsSync as existsSync87,
   lstatSync as lstatSync13,
   mkdirSync as mkdirSync48,
   openSync as openSync15,
@@ -114012,7 +114982,7 @@ function defaultSelfUpdateIO() {
       rmSync15(path7, { force: true });
     },
     exists(path7) {
-      return existsSync86(path7);
+      return existsSync87(path7);
     },
     dirname(path7) {
       return dirname37(path7);
@@ -114067,7 +115037,7 @@ init_install_cron2();
 
 // src/host-cli-self-heal/install-timer.ts
 import { spawnSync as spawnSync19 } from "node:child_process";
-import { existsSync as existsSync87, mkdirSync as mkdirSync49, readFileSync as readFileSync81, renameSync as renameSync22, writeFileSync as writeFileSync34 } from "node:fs";
+import { existsSync as existsSync88, mkdirSync as mkdirSync49, readFileSync as readFileSync81, renameSync as renameSync22, writeFileSync as writeFileSync34 } from "node:fs";
 import { dirname as dirname38 } from "node:path";
 var SERVICE_PATH = "/etc/systemd/system/switchroom-self-heal.service";
 var TIMER_PATH = "/etc/systemd/system/switchroom-self-heal.timer";
@@ -114114,7 +115084,7 @@ function renderTimer() {
 `;
 }
 function writeUnitIdempotent(path7, content) {
-  if (existsSync87(path7)) {
+  if (existsSync88(path7)) {
     try {
       if (readFileSync81(path7, "utf8") === content)
         return "unchanged";
@@ -114145,7 +115115,7 @@ function resolveOperatorUser(env2) {
 }
 function installSelfHealTimer(deps = {}) {
   const env2 = deps.env ?? process.env;
-  const systemdBooted = deps.systemdBooted ?? (() => existsSync87(SYSTEMD_MARKER));
+  const systemdBooted = deps.systemdBooted ?? (() => existsSync88(SYSTEMD_MARKER));
   const geteuid = deps.geteuid ?? (() => typeof process.geteuid === "function" ? process.geteuid() : undefined);
   const homeForUser = deps.homeForUser ?? homeFromPasswd;
   const servicePath = deps.servicePath ?? SERVICE_PATH;
@@ -114230,7 +115200,7 @@ var PACKAGED_INSTALL_KINDS = new Set([
 function runningFromSwitchroomCheckout(scriptPath) {
   let dir = dirname39(scriptPath);
   for (let i2 = 0;i2 < 12; i2++) {
-    if (existsSync88(join92(dir, ".git"))) {
+    if (existsSync89(join92(dir, ".git"))) {
       try {
         const pkg = JSON.parse(readFileSync82(join92(dir, "package.json"), "utf-8"));
         if (pkg.name === "switchroom")
@@ -114299,7 +115269,7 @@ function planUpdate(opts) {
         bundleDir: import.meta.dirname,
         execPath: process.execPath,
         scriptPath,
-        inContainer: process.env.SWITCHROOM_HOSTD_CONTEXT === "1" || existsSync88("/.dockerenv")
+        inContainer: process.env.SWITCHROOM_HOSTD_CONTEXT === "1" || existsSync89("/.dockerenv")
       });
       if (detection.kind !== "static-binary") {
         say(source_default.gray(`  host CLI not self-updated: ${detection.reason}
@@ -114382,7 +115352,7 @@ function planUpdate(opts) {
   steps.push({
     name: "pull-images",
     description: "Pull broker / kernel / agent images from GHCR",
-    skipReason: opts.skipImages ? "--skip-images flag set" : !existsSync88(composePath) ? `compose file not found at ${composePath} (run \`switchroom apply --compose-only\` first)` : undefined,
+    skipReason: opts.skipImages ? "--skip-images flag set" : !existsSync89(composePath) ? `compose file not found at ${composePath} (run \`switchroom apply --compose-only\` first)` : undefined,
     run: () => {
       const r = runner("docker", [
         "compose",
@@ -114617,7 +115587,7 @@ function planUpdate(opts) {
           bundleDir: import.meta.dirname,
           execPath: process.execPath,
           scriptPath,
-          inContainer: process.env.SWITCHROOM_HOSTD_CONTEXT === "1" || existsSync88("/.dockerenv")
+          inContainer: process.env.SWITCHROOM_HOSTD_CONTEXT === "1" || existsSync89("/.dockerenv")
         });
         const detail = `no shipped skills/ payload found for this install ` + `(${detection.kind}; ${describeShippedAssetSearch(resolution)})`;
         if (PACKAGED_INSTALL_KINDS.has(detection.kind)) {
@@ -114657,10 +115627,10 @@ function planUpdate(opts) {
       if (opts.syncBundledSkillsFn)
         return;
       const dest = join92(homedir48(), ".switchroom", "skills", "_bundled");
-      if (!existsSync88(dest)) {
+      if (!existsSync89(dest)) {
         return;
       }
-      const missing = getBuiltinDefaultSkillEntries().map((e) => e.key).filter((key) => !existsSync88(join92(dest, key)));
+      const missing = getBuiltinDefaultSkillEntries().map((e) => e.key).filter((key) => !existsSync89(join92(dest, key)));
       if (missing.length > 0) {
         throw new Error(`verify-bundled-skills: builtin default skill(s) missing from the pool after sync: ` + `${missing.join(", ")}. These ship in the CLI package and must exist in ${dest}. ` + `This is a broken sync or a packaging regression \u2014 the pool is not converged.`);
       }
@@ -114775,7 +115745,7 @@ function defaultStatusProbe(composePath) {
       let dir = dirname39(scriptPath);
       for (let i2 = 0;i2 < 8; i2++) {
         const pkgPath = join92(dir, "package.json");
-        if (existsSync88(pkgPath)) {
+        if (existsSync89(pkgPath)) {
           try {
             const pkg = JSON.parse(readFileSync82(pkgPath, "utf-8"));
             if (typeof pkg.version === "string")
@@ -114798,7 +115768,7 @@ function defaultStatusProbe(composePath) {
     warnings.push("could not resolve CLI version (no package.json found above the resolved script path)");
   }
   const services = [];
-  if (!existsSync88(composePath)) {
+  if (!existsSync89(composePath)) {
     warnings.push(`compose file not found at ${composePath}; service status unknown`);
     return { cliVersion, cliBuiltAt, services, warnings };
   }
@@ -115066,7 +116036,7 @@ import { homedir as homedir50 } from "node:os";
 
 // src/cli/rollout-pin-journal.ts
 import {
-  existsSync as existsSync89,
+  existsSync as existsSync90,
   readFileSync as readFileSync83,
   writeFileSync as writeFileSync35,
   renameSync as renameSync23,
@@ -115130,7 +116100,7 @@ function readPinJournal(configPath, warn = (m) => process.stderr.write(m)) {
   try {
     raw = readFileSync83(p, "utf8");
   } catch (e) {
-    if (existsSync89(p)) {
+    if (existsSync90(p)) {
       warn(`\u26a0\ufe0f  rollout pin journal: ${p} exists but could not be read ` + `(${e.message}). A provisional \`release.pin\` may be ` + `uncommitted \u2014 verify it host-side before the next reconcile.
 `);
     }
@@ -115202,7 +116172,7 @@ function commitPinPersist(configPath) {
     unlinkSync17(p);
     return null;
   } catch (e) {
-    if (!existsSync89(p))
+    if (!existsSync90(p))
       return null;
     return `rollout pin journal: FAILED to clear ${p} after a SUCCESSFUL roll ` + `(${e.message}). Delete it host-side \u2014 while it exists, ` + `recovery may revert a proven \`release.pin\`.`;
   }
@@ -116130,7 +117100,7 @@ init_helpers();
 init_lifecycle();
 init_resolve_version();
 import { execSync as execSync3 } from "node:child_process";
-import { existsSync as existsSync90, readFileSync as readFileSync85 } from "node:fs";
+import { existsSync as existsSync91, readFileSync as readFileSync85 } from "node:fs";
 import { dirname as dirname41, join as join94 } from "node:path";
 function getClaudeCodeVersion() {
   try {
@@ -116182,10 +117152,10 @@ function locateSwitchroomInstallDir() {
   let dir = import.meta.dirname;
   for (let i2 = 0;i2 < 10 && dir && dir !== "/"; i2++) {
     const pkgPath = join94(dir, "package.json");
-    if (existsSync90(pkgPath)) {
+    if (existsSync91(pkgPath)) {
       try {
         const pkg = JSON.parse(readFileSync85(pkgPath, "utf-8"));
-        if (pkg.name === "switchroom" && existsSync90(join94(dir, ".git"))) {
+        if (pkg.name === "switchroom" && existsSync91(join94(dir, ".git"))) {
           return dir;
         }
       } catch {}
@@ -116366,7 +117336,7 @@ init_merge();
 
 // src/agents/session-retention.ts
 import {
-  existsSync as existsSync91,
+  existsSync as existsSync92,
   readdirSync as readdirSync31,
   statSync as statSync52,
   unlinkSync as unlinkSync18
@@ -116377,7 +117347,7 @@ var DEFAULT_SESSION_RETENTION_MAX_AGE_DAYS = 30;
 var MIN_KEEP = 2;
 function collectSessionJsonl(claudeConfigDir) {
   const projects = join95(claudeConfigDir, "projects");
-  if (!existsSync91(projects))
+  if (!existsSync92(projects))
     return [];
   const found = [];
   const walk2 = (dir) => {
@@ -116509,7 +117479,7 @@ function registerHandoffCommand(program3) {
 // src/issues/store.ts
 import {
   closeSync as closeSync16,
-  existsSync as existsSync92,
+  existsSync as existsSync93,
   mkdirSync as mkdirSync52,
   openSync as openSync16,
   readdirSync as readdirSync32,
@@ -116548,7 +117518,7 @@ var ISSUES_FILE = "issues.jsonl";
 var ISSUES_LOCK = "issues.lock";
 function readAll(stateDir) {
   const path7 = join96(stateDir, ISSUES_FILE);
-  if (!existsSync92(path7))
+  if (!existsSync93(path7))
     return [];
   let raw;
   try {
@@ -116625,7 +117595,7 @@ function record(stateDir, input, nowFn = Date.now) {
   });
 }
 function resolve51(stateDir, fingerprint, nowFn = Date.now) {
-  if (!existsSync92(join96(stateDir, ISSUES_FILE)))
+  if (!existsSync93(join96(stateDir, ISSUES_FILE)))
     return 0;
   return withLock(stateDir, () => {
     const all = readAll(stateDir);
@@ -116643,7 +117613,7 @@ function resolve51(stateDir, fingerprint, nowFn = Date.now) {
   });
 }
 function resolveAllBySource(stateDir, source, nowFn = Date.now) {
-  if (!existsSync92(join96(stateDir, ISSUES_FILE)))
+  if (!existsSync93(join96(stateDir, ISSUES_FILE)))
     return 0;
   return withLock(stateDir, () => {
     const all = readAll(stateDir);
@@ -116661,7 +117631,7 @@ function resolveAllBySource(stateDir, source, nowFn = Date.now) {
   });
 }
 function prune(stateDir, opts = {}) {
-  if (!existsSync92(join96(stateDir, ISSUES_FILE)))
+  if (!existsSync93(join96(stateDir, ISSUES_FILE)))
     return 0;
   return withLock(stateDir, () => {
     const all = readAll(stateDir);
@@ -117011,14 +117981,14 @@ function relTime(deltaMs) {
 
 // src/cli/deps.ts
 init_source();
-import { existsSync as existsSync95 } from "node:fs";
+import { existsSync as existsSync96 } from "node:fs";
 import { homedir as homedir53 } from "node:os";
 import { join as join99, resolve as resolve52 } from "node:path";
 
 // src/deps/python.ts
 import { createHash as createHash18 } from "node:crypto";
 import {
-  existsSync as existsSync93,
+  existsSync as existsSync94,
   mkdirSync as mkdirSync53,
   readFileSync as readFileSync87,
   rmSync as rmSync16,
@@ -117026,7 +117996,7 @@ import {
 } from "node:fs";
 import { dirname as dirname42, join as join97 } from "node:path";
 import { homedir as homedir51 } from "node:os";
-import { execFileSync as execFileSync27 } from "node:child_process";
+import { execFileSync as execFileSync28 } from "node:child_process";
 
 class PythonEnvError extends Error {
   stderr;
@@ -117046,7 +118016,7 @@ function ensurePythonEnv(opts) {
   const { skillName, requirementsPath, force = false } = opts;
   const cacheRoot = opts.cacheRoot ?? defaultPythonCacheRoot();
   const hostPython = opts.pythonBin ?? "python3";
-  if (!existsSync93(requirementsPath)) {
+  if (!existsSync94(requirementsPath)) {
     throw new PythonEnvError(`requirements file not found: ${requirementsPath}`);
   }
   const venvDir = join97(cacheRoot, skillName);
@@ -117055,7 +118025,7 @@ function ensurePythonEnv(opts) {
   const pythonBin = join97(binDir, "python");
   const pipBin = join97(binDir, "pip");
   const targetHash = hashFile(requirementsPath);
-  if (!force && existsSync93(stampPath) && existsSync93(pythonBin)) {
+  if (!force && existsSync94(stampPath) && existsSync94(pythonBin)) {
     const existingHash = readFileSync87(stampPath, "utf8").trim();
     if (existingHash === targetHash) {
       return {
@@ -117068,12 +118038,12 @@ function ensurePythonEnv(opts) {
       };
     }
   }
-  if (existsSync93(venvDir)) {
+  if (existsSync94(venvDir)) {
     rmSync16(venvDir, { recursive: true, force: true });
   }
   mkdirSync53(dirname42(venvDir), { recursive: true });
   try {
-    execFileSync27(hostPython, ["-m", "venv", venvDir], { stdio: "pipe" });
+    execFileSync28(hostPython, ["-m", "venv", venvDir], { stdio: "pipe" });
   } catch (err) {
     const e = err;
     throw new PythonEnvError(`Failed to create venv for skill "${skillName}" with ${hostPython}: ${e.message}`, e.stderr?.toString());
@@ -117085,7 +118055,7 @@ function ensurePythonEnv(opts) {
     delete childEnv.PIP_TARGET;
     delete childEnv.PIP_PREFIX;
     delete childEnv.PYTHONUSERBASE;
-    execFileSync27(pipBin, ["install", "--disable-pip-version-check", "-r", requirementsPath], { stdio: "pipe", env: childEnv });
+    execFileSync28(pipBin, ["install", "--disable-pip-version-check", "-r", requirementsPath], { stdio: "pipe", env: childEnv });
   } catch (err) {
     const e = err;
     throw new PythonEnvError(`Failed to install requirements for skill "${skillName}": ${e.message}`, e.stderr?.toString());
@@ -117106,7 +118076,7 @@ function ensurePythonEnv(opts) {
 import { createHash as createHash19 } from "node:crypto";
 import {
   copyFileSync as copyFileSync13,
-  existsSync as existsSync94,
+  existsSync as existsSync95,
   mkdirSync as mkdirSync54,
   readFileSync as readFileSync88,
   rmSync as rmSync17,
@@ -117114,7 +118084,7 @@ import {
 } from "node:fs";
 import { dirname as dirname43, join as join98 } from "node:path";
 import { homedir as homedir52 } from "node:os";
-import { execFileSync as execFileSync28 } from "node:child_process";
+import { execFileSync as execFileSync29 } from "node:child_process";
 
 class NodeEnvError extends Error {
   stderr;
@@ -117146,7 +118116,7 @@ function hashDepInputs(packageJsonPath) {
   hasher.update(readFileSync88(packageJsonPath));
   for (const lockName of ALL_LOCKFILES) {
     const lockPath = join98(sourceDir, lockName);
-    if (existsSync94(lockPath)) {
+    if (existsSync95(lockPath)) {
       hasher.update(`
 `);
       hasher.update(lockName);
@@ -117161,7 +118131,7 @@ function ensureNodeEnv(opts) {
   const { skillName, packageJsonPath, force = false } = opts;
   const cacheRoot = opts.cacheRoot ?? defaultNodeCacheRoot();
   const installer = opts.installer ?? "bun";
-  if (!existsSync94(packageJsonPath)) {
+  if (!existsSync95(packageJsonPath)) {
     throw new NodeEnvError(`package.json not found: ${packageJsonPath}`);
   }
   const sourceDir = dirname43(packageJsonPath);
@@ -117170,7 +118140,7 @@ function ensureNodeEnv(opts) {
   const nodeModulesDir = join98(envDir, "node_modules");
   const binDir = join98(nodeModulesDir, ".bin");
   const targetHash = hashDepInputs(packageJsonPath);
-  if (!force && existsSync94(stampPath) && existsSync94(nodeModulesDir)) {
+  if (!force && existsSync95(stampPath) && existsSync95(nodeModulesDir)) {
     const existingHash = readFileSync88(stampPath, "utf8").trim();
     if (existingHash === targetHash) {
       return {
@@ -117182,7 +118152,7 @@ function ensureNodeEnv(opts) {
       };
     }
   }
-  if (existsSync94(envDir)) {
+  if (existsSync95(envDir)) {
     rmSync17(envDir, { recursive: true, force: true });
   }
   mkdirSync54(envDir, { recursive: true });
@@ -117190,7 +118160,7 @@ function ensureNodeEnv(opts) {
   let copiedLockfile = false;
   for (const lockName of LOCKFILES_FOR[installer]) {
     const lockPath = join98(sourceDir, lockName);
-    if (existsSync94(lockPath)) {
+    if (existsSync95(lockPath)) {
       copyFileSync13(lockPath, join98(envDir, lockName));
       copiedLockfile = true;
     }
@@ -117198,10 +118168,10 @@ function ensureNodeEnv(opts) {
   try {
     if (installer === "bun") {
       const args = copiedLockfile ? ["install", "--frozen-lockfile"] : ["install"];
-      execFileSync28("bun", args, { cwd: envDir, stdio: "pipe" });
+      execFileSync29("bun", args, { cwd: envDir, stdio: "pipe" });
     } else {
       const args = copiedLockfile ? ["ci"] : ["install"];
-      execFileSync28("npm", args, { cwd: envDir, stdio: "pipe" });
+      execFileSync29("npm", args, { cwd: envDir, stdio: "pipe" });
     }
   } catch (err) {
     const e = err;
@@ -117226,22 +118196,22 @@ function registerDepsCommand(program3) {
   const deps = program3.command("deps").description("Manage cached per-skill dependency environments");
   deps.command("rebuild <skill>").description("Rebuild the Python venv and/or Node node_modules cache for a skill").option("-p, --python", "Rebuild only the Python env").option("-n, --node", "Rebuild only the Node env").action(async (skill, opts) => {
     const skillsRoot = builtinSkillsRoot();
-    if (!existsSync95(skillsRoot)) {
+    if (!existsSync96(skillsRoot)) {
       console.error(source_default.red(`Bundled skills pool dir not found at ${skillsRoot} \u2014 run \`switchroom update\` to install it.`));
       process.exit(1);
     }
     const skillDir = join99(skillsRoot, skill);
-    if (!existsSync95(skillDir)) {
+    if (!existsSync96(skillDir)) {
       console.error(source_default.red(`Unknown skill: ${skill} (no dir at ${skillDir})`));
       process.exit(1);
     }
     const requirementsPath = join99(skillDir, "requirements.txt");
     const packageJsonPath = join99(skillDir, "package.json");
-    const wantPython = opts.python ?? (!opts.python && !opts.node && existsSync95(requirementsPath));
-    const wantNode = opts.node ?? (!opts.python && !opts.node && existsSync95(packageJsonPath));
+    const wantPython = opts.python ?? (!opts.python && !opts.node && existsSync96(requirementsPath));
+    const wantNode = opts.node ?? (!opts.python && !opts.node && existsSync96(packageJsonPath));
     let did = 0;
     if (wantPython) {
-      if (!existsSync95(requirementsPath)) {
+      if (!existsSync96(requirementsPath)) {
         console.error(source_default.red(`Skill "${skill}" has no requirements.txt at ${requirementsPath}`));
         process.exit(1);
       }
@@ -117265,7 +118235,7 @@ function registerDepsCommand(program3) {
       }
     }
     if (wantNode) {
-      if (!existsSync95(packageJsonPath)) {
+      if (!existsSync96(packageJsonPath)) {
         console.error(source_default.red(`Skill "${skill}" has no package.json at ${packageJsonPath}`));
         process.exit(1);
       }
@@ -117298,7 +118268,7 @@ function registerDepsCommand(program3) {
 // src/cli/workspace.ts
 init_helpers();
 init_loader();
-import { existsSync as existsSync96 } from "node:fs";
+import { existsSync as existsSync97 } from "node:fs";
 import { resolve as resolve53, sep as sep5 } from "node:path";
 import { spawnSync as spawnSync23 } from "node:child_process";
 
@@ -118075,7 +119045,7 @@ function registerWorkspaceCommand(program3) {
     if (!dir)
       return;
     const gitDir = resolve53(dir, ".git");
-    if (!existsSync96(gitDir)) {
+    if (!existsSync97(gitDir)) {
       process.stdout.write(`Workspace is not a git repository. Re-run \`switchroom agent create ${agentName}\` ` + `or manually \`git init\` in ${dir} to enable versioning.
 `);
       return;
@@ -118129,7 +119099,7 @@ function registerWorkspaceCommand(program3) {
     if (!dir)
       return;
     const gitDir = resolve53(dir, ".git");
-    if (!existsSync96(gitDir)) {
+    if (!existsSync97(gitDir)) {
       process.stdout.write(`Workspace is not a git repository.
 `);
       return;
@@ -118154,7 +119124,7 @@ function resolveAgentWorkspaceDirOrExit(program3, agentName) {
   const agentsDir = resolveAgentsDir(config);
   const agentDir = resolve53(agentsDir, agentName);
   const dir = resolveAgentWorkspaceDir(agentDir);
-  if (!existsSync96(dir)) {
+  if (!existsSync97(dir)) {
     process.stderr.write(`workspace: ${dir} does not exist yet. Run \`switchroom setup\` or \`switchroom agent scaffold ${agentName}\` to seed it.
 `);
     return;
@@ -118190,7 +119160,7 @@ function safeParseInt(value, fallback) {
 init_helpers();
 init_loader();
 init_merge();
-import { copyFileSync as copyFileSync14, existsSync as existsSync97, readFileSync as readFileSync89, writeFileSync as writeFileSync39 } from "node:fs";
+import { copyFileSync as copyFileSync14, existsSync as existsSync98, readFileSync as readFileSync89, writeFileSync as writeFileSync39 } from "node:fs";
 import { join as join100, resolve as resolve54 } from "node:path";
 init_scaffold();
 init_profiles();
@@ -118208,7 +119178,7 @@ function resolveSoulTargetOrExit(program3, agentName) {
   const agentsDir = resolveAgentsDir(config);
   const agentDir = resolve54(agentsDir, agentName);
   const workspaceDir = resolveAgentWorkspaceDir(agentDir);
-  if (!existsSync97(workspaceDir)) {
+  if (!existsSync98(workspaceDir)) {
     console.error(`soul: ${workspaceDir} does not exist yet. Run \`switchroom setup\` ` + `or \`switchroom agent scaffold ${agentName}\` to seed it.`);
     process.exit(1);
   }
@@ -118234,7 +119204,7 @@ function registerSoulCommand(program3) {
     const t = resolveSoulTargetOrExit(program3, agentName);
     if (!t)
       return;
-    if (!existsSync97(t.soulPath)) {
+    if (!existsSync98(t.soulPath)) {
       console.error(`soul: ${t.soulPath} does not exist yet \u2014 run ` + `\`switchroom soul reset ${agentName}\` to seed it.`);
       process.exit(1);
     }
@@ -118249,7 +119219,7 @@ function registerSoulCommand(program3) {
       console.error(`soul: profile "${t.profileName}" ships no SOUL.md.hbs \u2014 ` + `nothing to re-seed from.`);
       process.exit(1);
     }
-    const exists = existsSync97(t.soulPath);
+    const exists = existsSync98(t.soulPath);
     if (exists && !opts.yes) {
       if (!isInteractive()) {
         console.error(`soul: ${t.soulPath} already exists. Re-run with --yes to ` + `replace it (the current file is backed up to SOUL.md.bak).`);
@@ -118264,7 +119234,7 @@ function registerSoulCommand(program3) {
     let backupPath;
     if (exists) {
       backupPath = `${t.soulPath}.bak`;
-      if (existsSync97(backupPath)) {
+      if (existsSync98(backupPath)) {
         backupPath = `${t.soulPath}.bak.${Date.now()}`;
       }
       copyFileSync14(t.soulPath, backupPath);
@@ -118283,7 +119253,7 @@ function registerSoulCommand(program3) {
 // src/cli/debug.ts
 init_helpers();
 init_loader();
-import { existsSync as existsSync98, readFileSync as readFileSync90, readdirSync as readdirSync33, statSync as statSync54 } from "node:fs";
+import { existsSync as existsSync99, readFileSync as readFileSync90, readdirSync as readdirSync33, statSync as statSync54 } from "node:fs";
 import { resolve as resolve55, join as join101 } from "node:path";
 import { createHash as createHash20 } from "node:crypto";
 init_merge();
@@ -118296,7 +119266,7 @@ function estimateTokens(bytes) {
 }
 function readMcpServerNames(agentDir) {
   const mcpPath = join101(agentDir, ".mcp.json");
-  if (!existsSync98(mcpPath))
+  if (!existsSync99(mcpPath))
     return [];
   try {
     const parsed = JSON.parse(readFileSync90(mcpPath, "utf-8"));
@@ -118310,7 +119280,7 @@ function sha2562(content) {
 }
 function findLatestTranscriptJsonl(claudeConfigDir) {
   const projectsDir = join101(claudeConfigDir, "projects");
-  if (!existsSync98(projectsDir))
+  if (!existsSync99(projectsDir))
     return;
   try {
     const entries = readdirSync33(projectsDir, { withFileTypes: true });
@@ -118320,7 +119290,7 @@ function findLatestTranscriptJsonl(claudeConfigDir) {
         continue;
       const projectPath = join101(projectsDir, entry.name);
       const transcriptPath = join101(projectPath, "transcript.jsonl");
-      if (!existsSync98(transcriptPath))
+      if (!existsSync99(transcriptPath))
         continue;
       const stat3 = statSync54(transcriptPath);
       if (!latest || stat3.mtimeMs > latest.mtime) {
@@ -118383,7 +119353,7 @@ function registerDebugCommand(program3) {
     }
     const agentsDir = resolveAgentsDir(config);
     const agentDir = resolve55(agentsDir, agentName);
-    if (!existsSync98(agentDir)) {
+    if (!existsSync99(agentDir)) {
       console.error(`Agent directory not found: ${agentDir}`);
       process.exit(1);
     }
@@ -118438,7 +119408,7 @@ function registerDebugCommand(program3) {
     }
     console.log(`=== Append System Prompt (per-session) ===
 `);
-    const handoffContent = existsSync98(handoffPath) ? readFileSync90(handoffPath, "utf-8") : "";
+    const handoffContent = existsSync99(handoffPath) ? readFileSync90(handoffPath, "utf-8") : "";
     if (handoffContent.trim().length > 0) {
       console.log(`-- Handoff Briefing (${formatBytes(handoffContent.length)}) --`);
       console.log(handoffContent);
@@ -118449,7 +119419,7 @@ function registerDebugCommand(program3) {
     }
     console.log(`=== CLAUDE.md (auto-loaded by Claude Code) ===
 `);
-    const claudeMdContent = existsSync98(claudeMdPath) ? readFileSync90(claudeMdPath, "utf-8") : "";
+    const claudeMdContent = existsSync99(claudeMdPath) ? readFileSync90(claudeMdPath, "utf-8") : "";
     if (claudeMdContent.trim().length > 0) {
       console.log(`(${formatBytes(claudeMdContent.length)})`);
       console.log(claudeMdContent);
@@ -118460,7 +119430,7 @@ function registerDebugCommand(program3) {
     }
     console.log(`=== Persona (SOUL.md) ===
 `);
-    const soulMdContent = existsSync98(soulMdPath) ? readFileSync90(soulMdPath, "utf-8") : existsSync98(workspaceSoulMdPath) ? readFileSync90(workspaceSoulMdPath, "utf-8") : "";
+    const soulMdContent = existsSync99(soulMdPath) ? readFileSync90(soulMdPath, "utf-8") : existsSync99(workspaceSoulMdPath) ? readFileSync90(workspaceSoulMdPath, "utf-8") : "";
     if (soulMdContent.trim().length > 0) {
       console.log(`(${formatBytes(soulMdContent.length)})`);
       console.log(soulMdContent);
@@ -118524,8 +119494,8 @@ function registerDebugCommand(program3) {
     const fleetDir = join101(agentsDir, "..", "fleet");
     const fleetInvPath = join101(fleetDir, "switchroom-invariants.md");
     const fleetClaudePath = join101(fleetDir, "CLAUDE.md");
-    const fleetInvBytes = existsSync98(fleetInvPath) ? readFileSync90(fleetInvPath, "utf-8").length : 0;
-    const fleetClaudeBytes = existsSync98(fleetClaudePath) ? readFileSync90(fleetClaudePath, "utf-8").length : 0;
+    const fleetInvBytes = existsSync99(fleetInvPath) ? readFileSync90(fleetInvPath, "utf-8").length : 0;
+    const fleetClaudeBytes = existsSync99(fleetClaudePath) ? readFileSync90(fleetClaudePath, "utf-8").length : 0;
     const fleetBytes = fleetInvBytes + fleetClaudeBytes;
     const totalBytes = stableBytes + perSessionBytes + claudeMdBytes + fleetBytes + perTurnBytes + userBytes;
     console.log(`Stable prefix:     ${formatBytes(stableBytes).padEnd(20)} (cache-hot; includes SOUL.md ${soulMdBytes.toLocaleString()}B)`);
@@ -118557,8 +119527,8 @@ function registerDebugCommand(program3) {
 init_source();
 
 // src/worktree/claim.ts
-import { execFileSync as execFileSync29 } from "node:child_process";
-import { closeSync as closeSync17, mkdirSync as mkdirSync56, openSync as openSync17, existsSync as existsSync100, unlinkSync as unlinkSync21 } from "node:fs";
+import { execFileSync as execFileSync30 } from "node:child_process";
+import { closeSync as closeSync17, mkdirSync as mkdirSync56, openSync as openSync17, existsSync as existsSync101, unlinkSync as unlinkSync21 } from "node:fs";
 import { join as join103, resolve as resolve57 } from "node:path";
 import { homedir as homedir55 } from "node:os";
 import { randomBytes as randomBytes16 } from "node:crypto";
@@ -118570,7 +119540,7 @@ import {
   readFileSync as readFileSync91,
   readdirSync as readdirSync34,
   unlinkSync as unlinkSync20,
-  existsSync as existsSync99,
+  existsSync as existsSync100,
   renameSync as renameSync25
 } from "node:fs";
 import { join as join102, resolve as resolve56 } from "node:path";
@@ -118684,7 +119654,7 @@ function expandHome(p) {
 }
 async function claimWorktree(input, codeRepos) {
   const repoPath = resolveRepoPath(input.repo, codeRepos);
-  if (!existsSync100(repoPath)) {
+  if (!existsSync101(repoPath)) {
     throw new Error(`Repository path does not exist: ${repoPath}`);
   }
   let concurrencyCap = DEFAULT_CONCURRENCY;
@@ -118726,7 +119696,7 @@ async function claimWorktree(input, codeRepos) {
     releaseLock();
   }
   try {
-    execFileSync29("git", ["worktree", "add", "-b", branch, worktreePath], {
+    execFileSync30("git", ["worktree", "add", "-b", branch, worktreePath], {
       cwd: repoPath,
       stdio: "pipe"
     });
@@ -118739,8 +119709,8 @@ async function claimWorktree(input, codeRepos) {
 }
 
 // src/worktree/release.ts
-import { execFileSync as execFileSync30 } from "node:child_process";
-import { existsSync as existsSync101 } from "node:fs";
+import { execFileSync as execFileSync31 } from "node:child_process";
+import { existsSync as existsSync102 } from "node:fs";
 function releaseWorktree(input) {
   const { id } = input;
   const record2 = readRecord(id);
@@ -118748,9 +119718,9 @@ function releaseWorktree(input) {
     return { released: true };
   }
   let gitSuccess = true;
-  if (existsSync101(record2.path)) {
+  if (existsSync102(record2.path)) {
     try {
-      execFileSync30("git", ["worktree", "remove", "--force", record2.path], {
+      execFileSync31("git", ["worktree", "remove", "--force", record2.path], {
         cwd: record2.repo,
         stdio: "pipe"
       });
@@ -118786,8 +119756,8 @@ function listWorktrees() {
 }
 
 // src/worktree/reaper.ts
-import { execFileSync as execFileSync31 } from "node:child_process";
-import { existsSync as existsSync102 } from "node:fs";
+import { execFileSync as execFileSync32 } from "node:child_process";
+import { existsSync as existsSync103 } from "node:fs";
 var STALE_THRESHOLD_MS = 10 * 60 * 1000;
 function reapSkipReasonText(action) {
   switch (action) {
@@ -118804,7 +119774,7 @@ function reapSkipReasonText(action) {
 function probePathInUse(path10) {
   let probeRan = false;
   try {
-    execFileSync31("fuser", [path10], { stdio: "pipe" });
+    execFileSync32("fuser", [path10], { stdio: "pipe" });
     return "in-use";
   } catch (err) {
     if (err.code !== "ENOENT") {
@@ -118812,7 +119782,7 @@ function probePathInUse(path10) {
     }
   }
   try {
-    const out = execFileSync31("lsof", ["-t", path10], {
+    const out = execFileSync32("lsof", ["-t", path10], {
       stdio: ["ignore", "pipe", "ignore"]
     }).toString().trim();
     probeRan = true;
@@ -118827,7 +119797,7 @@ function probePathInUse(path10) {
 }
 function hasUncommittedChanges(_repoPath, worktreePath) {
   try {
-    const out = execFileSync31("git", ["-C", worktreePath, "status", "--porcelain"], { stdio: "pipe" }).toString();
+    const out = execFileSync32("git", ["-C", worktreePath, "status", "--porcelain"], { stdio: "pipe" }).toString();
     return out.trim().length > 0;
   } catch {
     return true;
@@ -118835,7 +119805,7 @@ function hasUncommittedChanges(_repoPath, worktreePath) {
 }
 function defaultRemoveWorktree(repoPath, worktreePath) {
   try {
-    execFileSync31("git", ["worktree", "remove", "--force", worktreePath], {
+    execFileSync32("git", ["worktree", "remove", "--force", worktreePath], {
       cwd: repoPath,
       stdio: "pipe"
     });
@@ -118848,7 +119818,7 @@ function planReaper(nowMs, deps = {}) {
   const plan = [];
   for (const record2 of listRecords()) {
     const heartbeatAge = now2 - new Date(record2.heartbeatAt).getTime();
-    const worktreeExists = existsSync102(record2.path);
+    const worktreeExists = existsSync103(record2.path);
     if (!worktreeExists) {
       plan.push({
         record: record2,
@@ -118927,9 +119897,9 @@ function runReaper(nowMs, deps = {}) {
 }
 
 // src/worktree/gc.ts
-import { execFileSync as execFileSync32 } from "node:child_process";
+import { execFileSync as execFileSync33 } from "node:child_process";
 import {
-  existsSync as existsSync103,
+  existsSync as existsSync104,
   readFileSync as readFileSync92,
   readdirSync as readdirSync35,
   statSync as statSync55,
@@ -119054,7 +120024,7 @@ function classifyTaskTree(i2) {
     return "skip-unmerged";
   return "reap";
 }
-var defaultExec3 = (file, args, cwd) => execFileSync32(file, args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).toString();
+var defaultExec3 = (file, args, cwd) => execFileSync33(file, args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).toString();
 function defaultPrSignal(repo, branch, exec) {
   try {
     const out = exec("gh", [
@@ -119108,7 +120078,7 @@ function trashRoot() {
   return resolve58(process.env.SWITCHROOM_WORKTREE_TRASH ?? join104(homedir56(), ".switchroom", "worktree-gc-trash"));
 }
 function planGc(roots, deps = {}, taskTreeRoots = []) {
-  const exists = deps.existsSync ?? existsSync103;
+  const exists = deps.existsSync ?? existsSync104;
   const readDir = deps.readDir ?? ((p) => readdirSync35(p));
   const readFile4 = deps.readFile ?? ((p) => readFileSync92(p, "utf8"));
   const stat3 = deps.stat ?? ((p) => statSync55(p));
@@ -119427,7 +120397,7 @@ function selectPurgeTargets(entries, olderThanDays) {
   return entries.filter((e) => e.ageDays >= olderThanDays).map((e) => e.path);
 }
 function listTrashEntries(nowMs, deps = {}) {
-  const exists = deps.existsSync ?? existsSync103;
+  const exists = deps.existsSync ?? existsSync104;
   const readDir = deps.readDir ?? ((p) => readdirSync35(p));
   const root = trashRoot();
   if (!exists(root))
@@ -119480,7 +120450,7 @@ function defaultTaskTreeRoots() {
   for (const name of names.sort()) {
     for (const sub of ["home/work", "home/workspace"]) {
       const r = join104(agentsDir, name, sub);
-      if (existsSync103(r))
+      if (existsSync104(r))
         roots.push(r);
     }
   }
@@ -120491,7 +121461,7 @@ function registerM365McpLauncherCommand(program3) {
 // src/cli/notion-mcp-launcher.ts
 init_scaffold_integration();
 import { spawn as spawn7 } from "node:child_process";
-import { existsSync as existsSync104, mkdirSync as mkdirSync60, writeFileSync as writeFileSync43 } from "node:fs";
+import { existsSync as existsSync105, mkdirSync as mkdirSync60, writeFileSync as writeFileSync43 } from "node:fs";
 import { dirname as dirname45 } from "node:path";
 var HEARTBEAT_WRITE_INTERVAL_MS = 30 * 1000;
 var DEFAULT_HEARTBEAT_PATH = "/state/agent/notion-launcher.heartbeat.json";
@@ -120503,7 +121473,7 @@ function buildNotionMcpArgs(opts) {
 function defaultWriteHeartbeat(path10, contents) {
   try {
     const dir = dirname45(path10);
-    if (!existsSync104(dir))
+    if (!existsSync105(dir))
       mkdirSync60(dir, { recursive: true });
     writeFileSync43(path10, contents);
   } catch {}
@@ -120619,6 +121589,92 @@ import { mkdirSync as mkdirSync61, readFileSync as readFileSync93, renameSync as
 import { tmpdir as tmpdir5 } from "node:os";
 import { join as join107 } from "node:path";
 import { createInterface as createInterface7 } from "node:readline";
+
+// src/memory/hindsight-knowledge-admin.ts
+var KNOWLEDGE_SEARCH_LIMIT_MIN = 1;
+var KNOWLEDGE_SEARCH_LIMIT_MAX = 50;
+var KNOWLEDGE_SEARCH_LIMIT_DEFAULT = 10;
+function clampKnowledgeSearchLimit(limit) {
+  if (limit === undefined || !Number.isFinite(limit)) {
+    return KNOWLEDGE_SEARCH_LIMIT_DEFAULT;
+  }
+  return Math.min(KNOWLEDGE_SEARCH_LIMIT_MAX, Math.max(KNOWLEDGE_SEARCH_LIMIT_MIN, Math.trunc(limit)));
+}
+var KNOWLEDGE_ADMIN_TIMEOUT_MS = 15000;
+var KNOWLEDGE_PAGE_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
+
+class KnowledgeAdmin {
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  get fetchImpl() {
+    return this.opts.fetchImpl ?? fetch;
+  }
+  knowledgeBasePath() {
+    const base = this.opts.apiBaseUrl.replace(/\/+$/, "");
+    return `${base}/v1/default/banks/${encodeURIComponent(this.opts.bankId)}/knowledge-base`;
+  }
+  async get(url) {
+    const ctl = new AbortController;
+    const timer = setTimeout(() => ctl.abort(), this.opts.timeoutMs ?? KNOWLEDGE_ADMIN_TIMEOUT_MS);
+    try {
+      return await this.fetchImpl(url, {
+        method: "GET",
+        headers: {
+          accept: "application/json",
+          ...this.opts.bankId ? { "X-Bank-Id": this.opts.bankId } : {}
+        },
+        signal: ctl.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async search(args) {
+    const params = new URLSearchParams({
+      q: args.query,
+      limit: String(clampKnowledgeSearchLimit(args.limit))
+    });
+    const res = await this.get(`${this.knowledgeBasePath()}/search?${params}`);
+    if (!res.ok) {
+      throw new Error(`searching knowledge pages in bank '${this.opts.bankId}' failed: HTTP ${res.status}`);
+    }
+    const parsed = await res.json();
+    const results = Array.isArray(parsed.results) ? parsed.results : [];
+    return {
+      results,
+      total: typeof parsed.total === "number" ? parsed.total : results.length
+    };
+  }
+  async getPage(args) {
+    if (!KNOWLEDGE_PAGE_ID_PATTERN.test(args.page_id)) {
+      throw new Error(`'${args.page_id}' is not a knowledge page id. Ids look like ` + `'kp-<hex>' (letters, digits, '-' and '_' only) and come from ` + `search_knowledge_pages or get_knowledge_tree.`);
+    }
+    const res = await this.get(`${this.knowledgeBasePath()}/pages/${encodeURIComponent(args.page_id)}`);
+    if (res.status === 404) {
+      throw new Error(`no knowledge page '${args.page_id}' in bank '${this.opts.bankId}'. ` + `Page ids come from search_knowledge_pages or get_knowledge_tree.`);
+    }
+    if (!res.ok) {
+      throw new Error(`reading knowledge page '${args.page_id}' in bank ` + `'${this.opts.bankId}' failed: HTTP ${res.status}`);
+    }
+    const page = await res.json();
+    if (typeof page.markdown !== "string") {
+      throw new Error(`knowledge page '${args.page_id}' in bank '${this.opts.bankId}' came ` + `back with no markdown body \u2014 the response had no string 'markdown' ` + `field, so there is nothing to read.`);
+    }
+    return page;
+  }
+  async tree() {
+    const res = await this.get(`${this.knowledgeBasePath()}/tree`);
+    if (!res.ok) {
+      throw new Error(`listing the knowledge tree in bank '${this.opts.bankId}' failed: HTTP ${res.status}`);
+    }
+    const parsed = await res.json();
+    return { roots: Array.isArray(parsed.roots) ? parsed.roots : [] };
+  }
+}
+
+// src/cli/hindsight-mcp-shim.ts
 init_hindsight();
 var SHIM_SUPPORTED_PROTOCOL_VERSIONS = [
   "2025-06-18",
@@ -120687,9 +121743,80 @@ var SYNTHESIZED_TOOL_TABLE = {
         description: "Exact name of the directive to reactivate."
       }
     }
+  },
+  search_knowledge_pages: {
+    description: "Search YOUR OWN knowledge pages \u2014 the curated, continuously-refreshed " + "summaries of what this bank knows \u2014 with hybrid full-text + semantic " + "search. Reach for this before re-deriving a standing answer from raw " + "recall: a page is already synthesized, where recall returns fragments. " + "Returns ranked hits with a relevance snippet and a page id; read the " + "whole page with get_knowledge_page. Read-only, and only ever your own " + "memory bank. An empty knowledge base returns no results, not an error.",
+    required: ["query"],
+    props: {
+      query: {
+        type: "string",
+        description: "What to look for, in natural language."
+      },
+      limit: {
+        type: "integer",
+        minimum: KNOWLEDGE_SEARCH_LIMIT_MIN,
+        maximum: KNOWLEDGE_SEARCH_LIMIT_MAX,
+        description: `Maximum hits to return (${KNOWLEDGE_SEARCH_LIMIT_MIN}-` + `${KNOWLEDGE_SEARCH_LIMIT_MAX}, default ${KNOWLEDGE_SEARCH_LIMIT_DEFAULT}).`
+      }
+    }
+  },
+  get_knowledge_page: {
+    description: "Read one of YOUR OWN knowledge pages in full, by the page id returned " + "by search_knowledge_pages or get_knowledge_tree. Returns the complete " + "markdown document (YAML frontmatter + synthesized body). Prefer this " + "over rebuilding the same understanding from scratch. Read-only: it " + "returns the page as it currently stands and never triggers a refresh.",
+    required: ["page_id"],
+    props: {
+      page_id: {
+        type: "string",
+        description: "Id of the page to read, from search_knowledge_pages or " + "get_knowledge_tree."
+      }
+    }
+  },
+  get_knowledge_tree: {
+    description: "List YOUR OWN knowledge base as a folder/page tree \u2014 every page's id, " + "name, source query, tags and staleness flag. Call this to see what " + "this bank already knows before reading anything else; is_stale=true " + "means the page MAY be behind newer memories, not that it is wrong. " + "Read-only, and only ever your own memory bank.",
+    required: [],
+    props: {}
   }
 };
 var SYNTHESIZED_TOOL_NAMES = Object.keys(SYNTHESIZED_TOOL_TABLE);
+var INTEGER_STRING_PATTERN = /^-?(?:0|[1-9]\d*)$/;
+function coerceSynthesizedArg(toolName, key, propSchema, value) {
+  const schema = propSchema ?? {};
+  if (schema.type !== "integer") {
+    if (typeof value !== "string" || value.length === 0) {
+      return {
+        ok: false,
+        text: `${toolName}: '${key}' must be a non-empty string.`
+      };
+    }
+    return { ok: true, value };
+  }
+  const min = schema.minimum;
+  const max = schema.maximum;
+  const range = min !== undefined && max !== undefined ? ` between ${min} and ${max}` : "";
+  let n;
+  if (typeof value === "number") {
+    n = value;
+  } else if (typeof value === "string" && INTEGER_STRING_PATTERN.test(value)) {
+    n = Number(value);
+  } else {
+    return {
+      ok: false,
+      text: `${toolName}: '${key}' must be an integer${range}.`
+    };
+  }
+  if (!Number.isSafeInteger(n)) {
+    return {
+      ok: false,
+      text: `${toolName}: '${key}' must be an integer${range}.`
+    };
+  }
+  if (min !== undefined && n < min || max !== undefined && n > max) {
+    return {
+      ok: false,
+      text: `${toolName}: '${key}' must be an integer${range} \u2014 got ${n}. ` + `Re-issue the call with a value in range.`
+    };
+  }
+  return { ok: true, value: n };
+}
 function buildSynthesizedToolsList() {
   return Object.entries(SYNTHESIZED_TOOL_TABLE).map(([name, { description, required, props }]) => ({
     name,
@@ -120768,6 +121895,52 @@ var DEFAULT_RECALL_MAX_TOKENS = 1024;
 var DEFAULT_REFLECT_MAX_TOKENS = 1024;
 var DEFAULT_RECALL_BUDGET = "low";
 var DEFAULT_REFLECT_BUDGET = "mid";
+var KNOWLEDGE_RESPONSE_MAX_CHARS = 16384;
+var KNOWLEDGE_TREE_MARKER_RESERVE = 256;
+function capKnowledgeResponse(text) {
+  if (text.length <= KNOWLEDGE_RESPONSE_MAX_CHARS)
+    return text;
+  const omitted = text.length - KNOWLEDGE_RESPONSE_MAX_CHARS;
+  return text.slice(0, KNOWLEDGE_RESPONSE_MAX_CHARS) + `
+
+\u2026truncated at ${KNOWLEDGE_RESPONSE_MAX_CHARS} chars \u2014 ${omitted} ` + `chars omitted. This is a PARTIAL read; narrow it with ` + `search_knowledge_pages rather than treating the above as the whole.`;
+}
+function countKnowledgeNodes(nodes) {
+  let n = 0;
+  for (const node of nodes)
+    n += 1 + countKnowledgeNodes(node.children ?? []);
+  return n;
+}
+function takeKnowledgeNodes(nodes, budget) {
+  const out = [];
+  for (const node of nodes) {
+    if (budget.left <= 0)
+      break;
+    budget.left -= 1;
+    out.push(node.children === undefined ? node : { ...node, children: takeKnowledgeNodes(node.children, budget) });
+  }
+  return out;
+}
+function renderKnowledgeTree(roots) {
+  const total = countKnowledgeNodes(roots);
+  const whole = JSON.stringify(roots);
+  if (whole.length <= KNOWLEDGE_RESPONSE_MAX_CHARS)
+    return whole;
+  const charBudget = KNOWLEDGE_RESPONSE_MAX_CHARS - KNOWLEDGE_TREE_MARKER_RESERVE;
+  let allowed = total;
+  let kept = takeKnowledgeNodes(roots, { left: allowed });
+  let json = JSON.stringify(kept);
+  while (json.length > charBudget && allowed > 0) {
+    allowed = Math.max(0, Math.min(allowed - 1, Math.floor(allowed * (charBudget / json.length))));
+    kept = takeKnowledgeNodes(roots, { left: allowed });
+    json = JSON.stringify(kept);
+  }
+  const shown = countKnowledgeNodes(kept);
+  if (shown === total)
+    return json;
+  return json + `
+\u2026${total - shown} of ${total} nodes omitted \u2014 the knowledge tree was ` + `truncated to fit the response budget. This is a PARTIAL listing; use ` + `search_knowledge_pages to find a specific page.`;
+}
 var VALID_BUDGETS = new Set(["low", "mid", "high"]);
 function resolveClampMaxTokens(envVal, fallback) {
   if (envVal === undefined || envVal === "")
@@ -121102,6 +122275,17 @@ class HindsightShim {
     }
     return this.directiveAdminCache;
   }
+  knowledgeAdminCache = null;
+  get knowledgeAdmin() {
+    if (!this.knowledgeAdminCache) {
+      this.knowledgeAdminCache = new KnowledgeAdmin({
+        apiBaseUrl: this.opts.apiBaseUrl ?? this.opts.url.replace(/\/mcp\/?$/, ""),
+        bankId: this.opts.bankId,
+        ...this.opts.fetchImpl ? { fetchImpl: this.opts.fetchImpl } : {}
+      });
+    }
+    return this.knowledgeAdminCache;
+  }
   async synthesizedCall(name, rawArgs) {
     const fail4 = (text) => ({
       content: [{ type: "text", text }],
@@ -121114,26 +122298,23 @@ class HindsightShim {
     if (unknown.length > 0) {
       return fail4(`${name} does not accept ${unknown.map((u) => `'${u}'`).join(", ")}. ` + `Accepted arguments: ${[...allowed].join(", ")}. ` + (unknown.includes("bank_id") ? "This tool always operates on your own memory bank; there is no " + "way to target another agent's bank through it." : ""));
     }
+    const clean3 = {};
     for (const key of Object.keys(args)) {
-      if (typeof args[key] !== "string" || args[key].length === 0) {
-        return fail4(`${name}: '${key}' must be a non-empty string.`);
-      }
+      const coerced = coerceSynthesizedArg(name, key, spec.props[key], args[key]);
+      if (!coerced.ok)
+        return fail4(coerced.text);
+      clean3[key] = coerced.value;
     }
     for (const req of spec.required) {
-      if (args[req] === undefined) {
+      if (clean3[req] === undefined) {
         return fail4(`${name} requires '${req}'.`);
       }
     }
     if (!this.opts.bankId) {
-      return fail4(`${name} is unavailable: this agent has no HINDSIGHT_BANK_ID, so ` + "there is no bank to pin the change to.");
+      return fail4(`${name} is unavailable: this agent has no HINDSIGHT_BANK_ID, so ` + "there is no bank to pin it to.");
     }
     try {
-      const text = name === "deactivate_directive" ? await this.directiveAdmin.deactivate({
-        name: args.name,
-        ...typeof args.superseded_by === "string" ? { supersededBy: args.superseded_by } : {}
-      }) : await this.directiveAdmin.reactivate({
-        name: args.name
-      });
+      const text = await this.runSynthesized(name, clean3);
       return { content: [{ type: "text", text }], isError: false };
     } catch (err) {
       if (err instanceof DirectivePairInconsistentError) {
@@ -121142,6 +122323,42 @@ class HindsightShim {
       return fail4(`${name} failed: ${String(err)}`);
     }
   }
+  async runSynthesized(name, args) {
+    switch (name) {
+      case "deactivate_directive":
+        return this.directiveAdmin.deactivate({
+          name: args.name,
+          ...typeof args.superseded_by === "string" ? { supersededBy: args.superseded_by } : {}
+        });
+      case "reactivate_directive":
+        return this.directiveAdmin.reactivate({ name: args.name });
+      case "search_knowledge_pages": {
+        const res = await this.knowledgeAdmin.search({
+          query: args.query,
+          ...typeof args.limit === "number" ? { limit: args.limit } : {}
+        });
+        if (res.results.length === 0) {
+          return "No knowledge pages matched that query in your memory bank. " + "The bank may have no pages yet \u2014 get_knowledge_tree lists what " + "exists.";
+        }
+        return capKnowledgeResponse(JSON.stringify({ total: res.total, results: res.results }, null, 2));
+      }
+      case "get_knowledge_page": {
+        const page = await this.knowledgeAdmin.getPage({
+          page_id: args.page_id
+        });
+        return capKnowledgeResponse(page.markdown);
+      }
+      case "get_knowledge_tree": {
+        const tree = await this.knowledgeAdmin.tree();
+        if (tree.roots.length === 0) {
+          return "Your knowledge base has no pages yet. Pages are synthesized from " + "mental models \u2014 propose one to start it.";
+        }
+        return renderKnowledgeTree(tree.roots);
+      }
+      default:
+        throw new Error(`${name} is advertised as a synthesized tool but has no dispatch arm`);
+    }
+  }
   async toolsCall(params) {
     const called = params;
     if (called?.name && SYNTHESIZED_TOOL_NAMES.includes(called.name)) {
@@ -121921,7 +123138,7 @@ function runRedactStdin() {
 }
 
 // src/cli/status-ask.ts
-import { readFileSync as readFileSync95, existsSync as existsSync105, readdirSync as readdirSync37 } from "node:fs";
+import { readFileSync as readFileSync95, existsSync as existsSync106, readdirSync as readdirSync37 } from "node:fs";
 import { join as join108 } from "node:path";
 import { homedir as homedir57 } from "node:os";
 
@@ -122244,7 +123461,7 @@ function runReport(opts) {
 function resolveSources(explicitPath) {
   if (explicitPath != null && explicitPath.trim() !== "") {
     const trimmed = explicitPath.trim();
-    if (!existsSync105(trimmed)) {
+    if (!existsSync106(trimmed)) {
       process.stderr.write(`status-ask report: ${trimmed}: file not found
 `);
       process.exit(1);
@@ -122260,7 +123477,7 @@ function resolveSources(explicitPath) {
   } catch {
     agentsDir = join108(homedir57(), ".switchroom", "agents");
   }
-  if (!existsSync105(agentsDir))
+  if (!existsSync106(agentsDir))
     return [];
   const sources = [];
   let entries;
@@ -122271,7 +123488,7 @@ function resolveSources(explicitPath) {
   }
   for (const name of entries) {
     const path10 = join108(agentsDir, name, "runtime-metrics.jsonl");
-    if (existsSync105(path10)) {
+    if (existsSync106(path10)) {
       sources.push({ path: path10, agent: name });
     }
   }
@@ -122302,7 +123519,7 @@ init_paths();
 import {
   chownSync as chownSync12,
   closeSync as closeSync18,
-  existsSync as existsSync106,
+  existsSync as existsSync107,
   fsyncSync as fsyncSync8,
   mkdirSync as mkdirSync62,
   openSync as openSync18,
@@ -122432,7 +123649,7 @@ function deleteSkillsOverlayEntry(agent, slug, opts = {}) {
   const paths = overlayPathsFor(agent, opts);
   return withAgentLock(paths, () => {
     const finalPath = join109(paths.skillsDir, `${slug}.yaml`);
-    if (!existsSync106(finalPath))
+    if (!existsSync107(finalPath))
       return false;
     unlinkSync22(finalPath);
     return true;
@@ -122440,7 +123657,7 @@ function deleteSkillsOverlayEntry(agent, slug, opts = {}) {
 }
 function listSkillsOverlayEntries(agent, opts = {}) {
   const paths = overlayPathsFor(agent, opts);
-  if (!existsSync106(paths.skillsDir))
+  if (!existsSync107(paths.skillsDir))
     return [];
   const out = [];
   for (const name of readdirSync38(paths.skillsDir)) {
@@ -122459,7 +123676,7 @@ function deleteOverlayEntry(agent, slug, opts = {}) {
   const paths = overlayPathsFor(agent, opts);
   return withAgentLock(paths, () => {
     const finalPath = join109(paths.scheduleDir, `${slug}.yaml`);
-    if (!existsSync106(finalPath))
+    if (!existsSync107(finalPath))
       return false;
     unlinkSync22(finalPath);
     return true;
@@ -122467,7 +123684,7 @@ function deleteOverlayEntry(agent, slug, opts = {}) {
 }
 function listOverlayEntries(agent, opts = {}) {
   const paths = overlayPathsFor(agent, opts);
-  if (!existsSync106(paths.scheduleDir))
+  if (!existsSync107(paths.scheduleDir))
     return [];
   const out = [];
   for (const name of readdirSync38(paths.scheduleDir)) {
@@ -122695,7 +123912,7 @@ function reconcileAgentCronOnly(agent) {
 // src/cli/agent-config-pending.ts
 import {
   closeSync as closeSync19,
-  existsSync as existsSync107,
+  existsSync as existsSync108,
   fsyncSync as fsyncSync9,
   mkdirSync as mkdirSync63,
   openSync as openSync19,
@@ -122752,7 +123969,7 @@ function stagePendingScheduleEntry(opts) {
 }
 function listPendingScheduleEntries(agent, opts = {}) {
   const dir = pendingDir(agent, opts);
-  if (!existsSync107(dir))
+  if (!existsSync108(dir))
     return [];
   const out = [];
   for (const name of readdirSync39(dir).sort()) {
@@ -122761,7 +123978,7 @@ function listPendingScheduleEntries(agent, opts = {}) {
     const stageId = name.slice(0, -".meta.json".length);
     const metaPath = join110(dir, name);
     const yamlPath = join110(dir, `${stageId}.yaml`);
-    if (!existsSync107(yamlPath))
+    if (!existsSync108(yamlPath))
       continue;
     try {
       const meta = JSON.parse(readFileSync97(metaPath, "utf-8"));
@@ -122780,7 +123997,7 @@ function commitPendingScheduleEntry(opts) {
   const slug = match.meta.entry.name ?? match.stageId;
   const paths = overlayPathsFor(opts.agent, { root: opts.root });
   const finalPath = join110(paths.scheduleDir, `${slug}.yaml`);
-  if (existsSync107(finalPath)) {
+  if (existsSync108(finalPath)) {
     return { committed: false, reason: "slug_collision" };
   }
   renameSync29(match.yamlPath, finalPath);
@@ -122802,8 +124019,8 @@ function denyPendingScheduleEntry(opts) {
 }
 
 // src/cli/agent-config-write.ts
-import { existsSync as existsSync108, readFileSync as readFileSync98 } from "node:fs";
-import { execFileSync as execFileSync33 } from "node:child_process";
+import { existsSync as existsSync109, readFileSync as readFileSync98 } from "node:fs";
+import { execFileSync as execFileSync34 } from "node:child_process";
 
 // src/scheduler/schedule-report.ts
 var TIER_WEIGHT = { poll: 0, action: 0, cheap: 1, main: 5 };
@@ -123192,7 +124409,7 @@ function scheduleRemove(opts) {
   }
   let priorContent = null;
   try {
-    if (existsSync108(match.path))
+    if (existsSync109(match.path))
       priorContent = readFileSync98(match.path, "utf-8");
   } catch {}
   deleteOverlayEntry(agent, match.slug, { root: opts.root });
@@ -123396,10 +124613,10 @@ function registerAgentConfigWriteCommands(program3) {
     }
     let blob;
     if (opts.jsonl) {
-      blob = existsSync108(opts.jsonl) ? readFileSync98(opts.jsonl, "utf-8") : "";
+      blob = existsSync109(opts.jsonl) ? readFileSync98(opts.jsonl, "utf-8") : "";
     } else {
       try {
-        blob = execFileSync33("docker", ["exec", `switchroom-${agent}`, "cat", "/state/agent/scheduler.jsonl"], {
+        blob = execFileSync34("docker", ["exec", `switchroom-${agent}`, "cat", "/state/agent/scheduler.jsonl"], {
           encoding: "utf-8",
           stdio: ["ignore", "pipe", "ignore"]
         });
@@ -123428,7 +124645,7 @@ function registerAgentConfigWriteCommands(program3) {
 
 // src/cli/agent-config-skill-write.ts
 var import_yaml24 = __toESM(require_dist(), 1);
-import { existsSync as existsSync109 } from "node:fs";
+import { existsSync as existsSync110 } from "node:fs";
 init_reconcile_default_skills();
 init_agent_config();
 var import_yaml25 = __toESM(require_dist(), 1);
@@ -123508,7 +124725,7 @@ function skillInstall(opts) {
   }
   const poolDir = opts.bundledSkillsPoolDir ?? getBundledSkillsPoolDir();
   const skillPath = join111(poolDir, skillName);
-  if (!existsSync109(skillPath)) {
+  if (!existsSync110(skillPath)) {
     return err("E_SKILL_NOT_FOUND", `bundled skill not found at ${skillPath}. The operator needs to ` + `place the skill at this path before the agent can opt in.`);
   }
   const yamlText = import_yaml24.stringify({ skills: [skillName] });
@@ -123678,7 +124895,7 @@ init_source();
 import {
   chmodSync as chmodSync18,
   closeSync as closeSync20,
-  existsSync as existsSync110,
+  existsSync as existsSync111,
   lstatSync as lstatSync14,
   mkdirSync as mkdirSync64,
   mkdtempSync as mkdtempSync5,
@@ -123887,7 +125104,7 @@ function validatePayload(name, files) {
 function diffSummary(currentDir, files) {
   const lines = [];
   const currentFiles = {};
-  if (existsSync110(currentDir)) {
+  if (existsSync111(currentDir)) {
     const walk2 = (sub) => {
       for (const ent of readdirSync40(sub, { withFileTypes: true })) {
         const full = join112(sub, ent.name);
@@ -123923,7 +125140,7 @@ function diffSummary(currentDir, files) {
 `);
 }
 function writePayload(poolDir, name, files) {
-  if (!existsSync110(poolDir)) {
+  if (!existsSync111(poolDir)) {
     mkdirSync64(poolDir, { recursive: true, mode: 493 });
   }
   const target = join112(poolDir, name);
@@ -123973,9 +125190,9 @@ function writePayload(poolDir, name, files) {
     try {
       rmSync20(staging, { recursive: true, force: true });
     } catch {}
-    if (oldRename && existsSync110(oldRename)) {
+    if (oldRename && existsSync111(oldRename)) {
       try {
-        if (existsSync110(target)) {
+        if (existsSync111(target)) {
           rmSync20(target, { recursive: true, force: true });
         }
         renameSync30(oldRename, target);
@@ -123996,7 +125213,7 @@ function registerSkillCommand(program3) {
       files = loadFromStdin();
     } else {
       const fromPath = resolve60(opts.from);
-      if (!existsSync110(fromPath)) {
+      if (!existsSync111(fromPath)) {
         fail4(`--from path does not exist: ${opts.from}`);
       }
       const st = statSync58(fromPath);
@@ -124057,7 +125274,7 @@ init_source();
 import {
   chmodSync as chmodSync19,
   closeSync as closeSync21,
-  existsSync as existsSync111,
+  existsSync as existsSync112,
   lstatSync as lstatSync15,
   mkdirSync as mkdirSync65,
   mkdtempSync as mkdtempSync6,
@@ -124080,14 +125297,14 @@ var PERSONAL_SKILLS_SUBPATH2 = "personal-skills";
 function resolveConfigSkillsDir(agent) {
   const override = process.env.SWITCHROOM_CONFIG_DIR;
   const candidate = override ? resolve61(override) : join113(homedir59(), ".switchroom-config");
-  if (!existsSync111(candidate))
+  if (!existsSync112(candidate))
     return null;
   return join113(candidate, "agents", agent, PERSONAL_SKILLS_SUBPATH2);
 }
 var MIRROR_PRIOR_TTL_MS = 24 * 60 * 60 * 1000;
 function sweepMirrorPriors(configSkillsRoot) {
   try {
-    if (!existsSync111(configSkillsRoot))
+    if (!existsSync112(configSkillsRoot))
       return;
     const now2 = Date.now();
     for (const ent of readdirSync41(configSkillsRoot)) {
@@ -124123,7 +125340,7 @@ function mirrorToConfigRepo(agent, name, liveSkillDir) {
     }
     if (liveSkillDir === null) {
       sweepMirrorPriors(configSkillsRoot);
-      if (existsSync111(dest)) {
+      if (existsSync112(dest)) {
         const trash = join113(configSkillsRoot, `.${name}-trash-${Date.now()}`);
         renameSync31(dest, trash);
       }
@@ -124148,7 +125365,7 @@ function mirrorToConfigRepo(agent, name, liveSkillDir) {
     };
     walk2(liveSkillDir, staging);
     chmodSync19(staging, 493);
-    if (existsSync111(dest)) {
+    if (existsSync112(dest)) {
       const prior = join113(configSkillsRoot, `.${name}-prior-${Date.now()}`);
       renameSync31(dest, prior);
     }
@@ -124189,7 +125406,7 @@ function trashDir(agentsRoot, agent) {
 }
 function countPersonalSkills(agentsRoot, agent) {
   const skillsDir = join113(agentsRoot, agent, ".claude", "skills");
-  if (!existsSync111(skillsDir))
+  if (!existsSync112(skillsDir))
     return 0;
   let n = 0;
   for (const ent of readdirSync41(skillsDir, { withFileTypes: true })) {
@@ -124298,7 +125515,7 @@ function behavioralValidate(files) {
 }
 function sweepTrash(agentsRoot, agent) {
   const trash = trashDir(agentsRoot, agent);
-  if (!existsSync111(trash))
+  if (!existsSync112(trash))
     return;
   const now2 = Date.now();
   for (const ent of readdirSync41(trash, { withFileTypes: true })) {
@@ -124361,9 +125578,9 @@ function writePersonalSkill(targetDir, files) {
     try {
       rmSync21(staging, { recursive: true, force: true });
     } catch {}
-    if (oldRename && existsSync111(oldRename)) {
+    if (oldRename && existsSync112(oldRename)) {
       try {
-        if (existsSync111(targetDir)) {
+        if (existsSync112(targetDir)) {
           rmSync21(targetDir, { recursive: true, force: true });
         }
         renameSync31(oldRename, targetDir);
@@ -124429,7 +125646,7 @@ function loadFiles(opts) {
     return loadFromStdin2();
   }
   const p = resolve61(opts.from);
-  if (!existsSync111(p)) {
+  if (!existsSync112(p)) {
     fail5(`--from path does not exist: ${opts.from}`);
   }
   const st = statSync59(p);
@@ -124491,7 +125708,7 @@ function resolveCloneSource(source, opts) {
   const slug = m[2];
   const root = tier === "bundled" ? opts.bundledRoot ?? defaultBundledRoot() : opts.sharedRoot ?? defaultSharedRoot();
   const dir = join113(root, slug);
-  if (!existsSync111(dir)) {
+  if (!existsSync112(dir)) {
     fail5(`clone source ${JSON.stringify(source)} not found at ${dir}; ` + `check \`switchroom skill search --tier ${tier}\``, 1);
   }
   const st = lstatSync15(dir);
@@ -124638,7 +125855,7 @@ function listPersonalAction(opts) {
   sweepTrash(agentsRoot, agent);
   const skillsDir = join113(agentsRoot, agent, ".claude", "skills");
   const personal = [];
-  if (existsSync111(skillsDir)) {
+  if (existsSync112(skillsDir)) {
     for (const ent of readdirSync41(skillsDir, { withFileTypes: true })) {
       if (!ent.isDirectory())
         continue;
@@ -124824,10 +126041,10 @@ function registerSelfImproveProposeSkillCommand(program3) {
 import { createConnection as createConnection5 } from "node:net";
 import { homedir as homedir61 } from "node:os";
 import { join as join118, resolve as resolve62, sep as sep6 } from "node:path";
-import { existsSync as existsSync116, readFileSync as readFileSync106, realpathSync as realpathSync10 } from "node:fs";
+import { existsSync as existsSync117, readFileSync as readFileSync106, realpathSync as realpathSync10 } from "node:fs";
 
 // src/self-improve/apply-guard.ts
-import { existsSync as existsSync114, lstatSync as lstatSync16, readFileSync as readFileSync104, statSync as statSync61 } from "node:fs";
+import { existsSync as existsSync115, lstatSync as lstatSync16, readFileSync as readFileSync104, statSync as statSync61 } from "node:fs";
 
 // src/self-improve/config.ts
 function intEnv(name, def) {
@@ -124848,7 +126065,7 @@ function resolveSelfImproveConfig() {
 }
 
 // src/self-improve/eval-gate.ts
-import { existsSync as existsSync112, readFileSync as readFileSync102, readdirSync as readdirSync42, statSync as statSync60 } from "node:fs";
+import { existsSync as existsSync113, readFileSync as readFileSync102, readdirSync as readdirSync42, statSync as statSync60 } from "node:fs";
 import { join as join115 } from "node:path";
 import { spawnSync as spawnSync26 } from "node:child_process";
 function evalsJsonPath(skillDir) {
@@ -124856,7 +126073,7 @@ function evalsJsonPath(skillDir) {
 }
 function skillHasEvals(skillDir) {
   const p = evalsJsonPath(skillDir);
-  if (!existsSync112(p))
+  if (!existsSync113(p))
     return false;
   try {
     const parsed = JSON.parse(readFileSync102(p, "utf-8"));
@@ -124867,7 +126084,7 @@ function skillHasEvals(skillDir) {
 }
 function aggregateBenchmark(benchmarkDir, repoRoot, pythonBin = process.env.SWITCHROOM_PYTHON ?? "python3") {
   const script = join115(repoRoot, "skills", "skill-creator", "scripts", "aggregate_benchmark.py");
-  if (!existsSync112(script)) {
+  if (!existsSync113(script)) {
     return { ok: false, error: `aggregate_benchmark.py not found at ${script}` };
   }
   const r = spawnSync26(pythonBin, [script, benchmarkDir], {
@@ -124899,7 +126116,7 @@ function isBenchmarkDir(dir) {
   if (hasEvalDirs(dir))
     return true;
   const runs = join115(dir, "runs");
-  return existsSync112(runs) && hasEvalDirs(runs);
+  return existsSync113(runs) && hasEvalDirs(runs);
 }
 function resolveBenchmarkDir(baseDir, explicit) {
   if (explicit != null && explicit.length > 0) {
@@ -124978,7 +126195,7 @@ function floatEnv(name, def) {
 import {
   closeSync as closeSync22,
   copyFileSync as copyFileSync15,
-  existsSync as existsSync113,
+  existsSync as existsSync114,
   mkdirSync as mkdirSync66,
   openSync as openSync22,
   readFileSync as readFileSync103,
@@ -125125,7 +126342,7 @@ function caseFingerprint(prompt) {
 }
 function readEvalsDoc(skillDir) {
   const p = evalsJsonPath(skillDir);
-  if (!existsSync113(p))
+  if (!existsSync114(p))
     return null;
   try {
     const parsed = JSON.parse(readFileSync103(p, "utf-8"));
@@ -125149,7 +126366,7 @@ function appendEvalCase(skillDir, slug, input) {
     return { ok: false, reason: parsed.error };
   const ec = parsed.case;
   const existingDoc = readEvalsDoc(skillDir);
-  if (existingDoc === null && existsSync113(evalsJsonPath(skillDir))) {
+  if (existingDoc === null && existsSync114(evalsJsonPath(skillDir))) {
     return {
       ok: false,
       reason: "evals.json exists but is unparseable or malformed \u2014 refusing to " + "overwrite it (fix or remove the file first)"
@@ -125181,7 +126398,7 @@ function heldOutPath(stateDir) {
 }
 function heldOutHasFingerprint(stateDir, slug, fp) {
   const path10 = heldOutPath(stateDir);
-  if (!existsSync113(path10))
+  if (!existsSync114(path10))
     return false;
   let text;
   try {
@@ -125233,7 +126450,7 @@ function baselineEvalsPath(stateDir, slug) {
 }
 function evalsSha256(skillDir) {
   const p = evalsJsonPath(skillDir);
-  if (!existsSync113(p))
+  if (!existsSync114(p))
     return null;
   try {
     return createHash21("sha256").update(readFileSync103(p)).digest("hex");
@@ -125243,7 +126460,7 @@ function evalsSha256(skillDir) {
 }
 function readManifest(stateDir) {
   const p = manifestPath(stateDir);
-  if (!existsSync113(p))
+  if (!existsSync114(p))
     return {};
   try {
     const parsed = JSON.parse(readFileSync103(p, "utf-8"));
@@ -125285,7 +126502,7 @@ function ownsSkill(skillDir) {
 // src/self-improve/eval-case-proposals.ts
 import {
   closeSync as closeSync23,
-  existsSync as existsSync115,
+  existsSync as existsSync116,
   mkdirSync as mkdirSync67,
   openSync as openSync23,
   readFileSync as readFileSync105,
@@ -125301,7 +126518,7 @@ function isRecord2(v) {
 }
 function readEvalCaseProposals(stateDir) {
   const p = proposalsPath(stateDir);
-  if (!existsSync115(p))
+  if (!existsSync116(p))
     return [];
   let raw;
   try {
@@ -125498,7 +126715,7 @@ function registerApply(parent) {
       }));
       process.exit(0);
     }
-    if (!existsSync116(proposal.skill_dir)) {
+    if (!existsSync117(proposal.skill_dir)) {
       fail7(`skill dir gone: ${proposal.skill_dir}`);
     }
     const { dir, resolvedDir } = authorizeApplyTarget(proposal.skill_dir, proposal.skill_slug);
@@ -125611,7 +126828,7 @@ function registerSelfImproveBenchCommand(program3) {
 init_esm();
 init_helpers();
 var import_yaml26 = __toESM(require_dist(), 1);
-import { existsSync as existsSync117, readdirSync as readdirSync44, readFileSync as readFileSync107, statSync as statSync62 } from "node:fs";
+import { existsSync as existsSync118, readdirSync as readdirSync44, readFileSync as readFileSync107, statSync as statSync62 } from "node:fs";
 import { homedir as homedir63 } from "node:os";
 import { join as join120, resolve as resolve63 } from "node:path";
 var PERSONAL_PREFIX2 = "personal-";
@@ -125628,7 +126845,7 @@ function defaultBundledRoot2() {
 }
 function readSkillFrontmatter(skillDir) {
   const mdPath = join120(skillDir, "SKILL.md");
-  if (!existsSync117(mdPath))
+  if (!existsSync118(mdPath))
     return null;
   let content;
   try {
@@ -125672,7 +126889,7 @@ function listPersonalSkills(agent, agentsRoot = defaultAgentsRoot()) {
   if (!AGENT_NAME_RE3.test(agent))
     return [];
   const skillsDir = join120(agentsRoot, agent, ".claude/skills");
-  if (!existsSync117(skillsDir))
+  if (!existsSync118(skillsDir))
     return [];
   const out = [];
   let entries;
@@ -125710,7 +126927,7 @@ function listPersonalSkills(agent, agentsRoot = defaultAgentsRoot()) {
   return out;
 }
 function listSharedSkills(sharedRoot = defaultSharedRoot2()) {
-  if (!existsSync117(sharedRoot))
+  if (!existsSync118(sharedRoot))
     return [];
   const out = [];
   let entries;
@@ -125748,7 +126965,7 @@ function listSharedSkills(sharedRoot = defaultSharedRoot2()) {
   return out;
 }
 function listBundledSkills(bundledRoot = defaultBundledRoot2()) {
-  if (!existsSync117(bundledRoot))
+  if (!existsSync118(bundledRoot))
     return [];
   const out = [];
   let entries;
@@ -125907,7 +127124,7 @@ init_helpers();
 init_docker_socket();
 init_operator_uid();
 import {
-  existsSync as existsSync119,
+  existsSync as existsSync120,
   mkdirSync as mkdirSync68,
   readdirSync as readdirSync45,
   writeFileSync as writeFileSync49,
@@ -126290,7 +127507,7 @@ function resolveHostdSkillsTarget(hostHome) {
     console.warn(`switchroom hostd install: ~/.switchroom/skills is a symlink whose target ` + `does not resolve (dangling) \u2014 skipping the skills bind mount. Bundled ` + `skills will be unavailable to rollout/update until the symlink is fixed.`);
     return;
   }
-  if (!existsSync119(target)) {
+  if (!existsSync120(target)) {
     console.warn(`switchroom hostd install: ~/.switchroom/skills resolves to "${target}", ` + `which does not exist \u2014 skipping the skills bind mount. Bundled skills ` + `will be unavailable to rollout/update until the symlink target exists.`);
     return;
   }
@@ -126304,7 +127521,7 @@ function hostdComposePath() {
 }
 function backupExistingCompose() {
   const p = hostdComposePath();
-  if (!existsSync119(p))
+  if (!existsSync120(p))
     return null;
   const ts = new Date().toISOString().replace(/[:.]/g, "-");
   const bak = `${p}.bak-${ts}`;
@@ -126403,7 +127620,7 @@ function doStatus() {
   const composeYml = hostdComposePath();
   console.log(source_default.bold("switchroom-hostd"));
   console.log("");
-  if (!existsSync119(composeYml)) {
+  if (!existsSync120(composeYml)) {
     console.log(source_default.yellow("  compose:    not installed"));
     console.log(source_default.dim("              run `switchroom hostd install` to set up."));
     return;
@@ -126424,14 +127641,14 @@ function doStatus() {
   } else {
     console.log(source_default.green(`  container:  ${ps.stdout.trim()}`));
   }
-  if (existsSync119(dir)) {
+  if (existsSync120(dir)) {
     const entries = [];
     try {
       for (const name of readdirSync45(dir)) {
         if (name === "docker-compose.yml" || name.startsWith("docker-compose.yml."))
           continue;
         const sockPath = join121(dir, name, "sock");
-        if (existsSync119(sockPath)) {
+        if (existsSync120(sockPath)) {
           const st = statSync63(sockPath);
           if ((st.mode & 61440) === 49152) {
             entries.push(`${name} \u2192 ${sockPath}`);
@@ -126450,7 +127667,7 @@ function doStatus() {
 }
 function doUninstall() {
   const composeYml = hostdComposePath();
-  if (!existsSync119(composeYml)) {
+  if (!existsSync120(composeYml)) {
     console.log(source_default.yellow("  No hostd install detected (no compose file at this path)."));
     return;
   }
@@ -126474,7 +127691,7 @@ function registerHostdCommand(program3) {
   hostd.command("uninstall").description("Stop the hostd container. Leaves the compose file in place for re-install.").action(() => doUninstall());
   hostd.command("audit").description("Tail and filter the hostd audit log (privileged-verb call history)").option("--tail <n>", "Number of matching entries to show (default: 50)", "50").option("--agent <name>", "Filter to a specific caller agent").option("--op <verb>", "Filter to a specific hostd verb (e.g. update_apply, agent_restart)").option("--error", "Show only failed (error/denied) entries").option("--verbose", "Show the captured stderr / error tail under each failed row").option("--path <file>", "Override audit log path (for debugging)").action((opts) => {
     const logPath = opts.path ?? defaultAuditLogPath2();
-    if (!existsSync119(logPath)) {
+    if (!existsSync120(logPath)) {
       console.error(source_default.yellow(`Audit log not found at ${logPath}.`) + source_default.gray(`
 The log is created when hostd handles its first privileged-verb request.`));
       return;
@@ -126523,7 +127740,7 @@ init_source();
 init_helpers();
 init_operator_uid();
 init_compose();
-import { chownSync as chownSync13, existsSync as existsSync120, mkdirSync as mkdirSync69, writeFileSync as writeFileSync50, copyFileSync as copyFileSync17 } from "node:fs";
+import { chownSync as chownSync13, existsSync as existsSync121, mkdirSync as mkdirSync69, writeFileSync as writeFileSync50, copyFileSync as copyFileSync17 } from "node:fs";
 import { homedir as homedir65 } from "node:os";
 import { join as join122 } from "node:path";
 import { spawnSync as spawnSync30 } from "node:child_process";
@@ -126634,7 +127851,7 @@ function webdComposePath() {
 }
 function backupExistingCompose2() {
   const p = webdComposePath();
-  if (!existsSync120(p))
+  if (!existsSync121(p))
     return null;
   const ts = new Date().toISOString().replace(/[:.]/g, "-");
   const bak = `${p}.bak-${ts}`;
@@ -126742,7 +127959,7 @@ function doStatus2() {
   const composeYml = webdComposePath();
   console.log(source_default.bold("switchroom-web"));
   console.log("");
-  if (!existsSync120(composeYml)) {
+  if (!existsSync121(composeYml)) {
     console.log(source_default.yellow("  compose:    not installed"));
     console.log(source_default.dim("              run `switchroom webd install` to set up."));
     return;
@@ -126766,7 +127983,7 @@ function doStatus2() {
 }
 function doUninstall2() {
   const composeYml = webdComposePath();
-  if (!existsSync120(composeYml)) {
+  if (!existsSync121(composeYml)) {
     console.log(source_default.yellow("  No web-service install detected (no compose file at this path)."));
     return;
   }
@@ -127252,9 +128469,9 @@ function printDeepDiveBrief(targets) {
 
 // src/cli/hindsight-watch.ts
 init_source();
-import { existsSync as existsSync125, readdirSync as readdirSync50 } from "node:fs";
+import { existsSync as existsSync126, readdirSync as readdirSync50 } from "node:fs";
 import { homedir as homedir69 } from "node:os";
-import { join as join125, resolve as resolve66 } from "node:path";
+import { join as join126, resolve as resolve66 } from "node:path";
 
 // src/host-control/config-degraded.ts
 import { connect as connect3 } from "node:net";
@@ -127451,16 +128668,16 @@ function readLlmSignals(series) {
 }
 
 // src/hindsight-watch/recall-log.ts
-import { closeSync as closeSync24, existsSync as existsSync124, openSync as openSync24, readdirSync as readdirSync48, readSync as readSync6, statSync as statSync64 } from "node:fs";
-import { join as join124 } from "node:path";
+import { closeSync as closeSync24, existsSync as existsSync125, openSync as openSync24, readdirSync as readdirSync48, readSync as readSync6, statSync as statSync64 } from "node:fs";
+import { join as join125 } from "node:path";
 var RECALL_WINDOW_ROWS = 200;
 var RECALL_MAX_TAIL_BYTES = 1024 * 1024;
 var RECALL_MAX_ROW_AGE_MS = 24 * 60 * 60 * 1000;
 function recallLogPath2(agentDir) {
-  return join124(agentDir, ".claude", "plugins", "data", "hindsight-memory-inline", "state", "recall_log.jsonl");
+  return join125(agentDir, ".claude", "plugins", "data", "hindsight-memory-inline", "state", "recall_log.jsonl");
 }
 function readRecallLogTail2(path10, windowRows = RECALL_WINDOW_ROWS) {
-  if (!existsSync124(path10))
+  if (!existsSync125(path10))
     return [];
   let text;
   let truncatedHead = false;
@@ -127605,7 +128822,7 @@ function probeRecallLogs(agentsDir, now2, windowRows = RECALL_WINDOW_ROWS, maxAg
   const all = [];
   let agents = 0;
   for (const name of names) {
-    const rows = withinWindow(readRecallLogTail2(recallLogPath2(join124(agentsDir, name)), windowRows), now2, maxAgeMs);
+    const rows = withinWindow(readRecallLogTail2(recallLogPath2(join125(agentsDir, name)), windowRows), now2, maxAgeMs);
     if (rows.length > 0)
       agents++;
     all.push(...rows);
@@ -128663,7 +129880,7 @@ function registerHindsightWatchCommand(program3) {
       process.exitCode = runInstallCron(opts.cronUser);
       return;
     }
-    const agentsDir = opts.agentsDir ?? process.env.SWITCHROOM_AGENTS_DIR ?? join125(process.env.SWITCHROOM_HOME ?? process.env.HOME ?? homedir69(), ".switchroom", "agents");
+    const agentsDir = opts.agentsDir ?? process.env.SWITCHROOM_AGENTS_DIR ?? join126(process.env.SWITCHROOM_HOME ?? process.env.HOME ?? homedir69(), ".switchroom", "agents");
     const statePath = opts.state ?? defaultStatePath2();
     const log = (m) => {
       process.stderr.write(`${m}
@@ -128779,7 +129996,7 @@ function collectRelayCandidates(agentsDir) {
   const candidates = [];
   for (const name of readdirSync50(agentsDir).sort()) {
     const sock = resolve66(agentsDir, name, "telegram", "gateway.sock");
-    if (existsSync125(sock))
+    if (existsSync126(sock))
       candidates.push({ agent: name, sock });
   }
   return orderRelayCandidates(candidates);
@@ -128802,7 +130019,7 @@ async function notifyOperator(agentsDir, text, log) {
 // src/cli/hindsight-bench.ts
 init_source();
 import { mkdirSync as mkdirSync71, readFileSync as readFileSync113, writeFileSync as writeFileSync52 } from "node:fs";
-import { dirname as dirname51, resolve as resolve67 } from "node:path";
+import { dirname as dirname52, resolve as resolve67 } from "node:path";
 
 // src/hindsight-bench/anonymise.ts
 function pseudonym(n, width) {
@@ -129930,7 +131147,7 @@ function readResult(path10) {
 }
 function writeOut(path10, body) {
   const abs = resolve67(path10);
-  mkdirSync71(dirname51(abs), { recursive: true });
+  mkdirSync71(dirname52(abs), { recursive: true });
   writeFileSync52(abs, body);
   process.stderr.write(`${source_default.green("\u2713")} wrote ${abs}
 `);
@@ -130135,13 +131352,13 @@ async function runMeasureMode(opts) {
 
 // src/cli/openrouter-watch.ts
 init_source();
-import { existsSync as existsSync127, readdirSync as readdirSync51 } from "node:fs";
+import { existsSync as existsSync128, readdirSync as readdirSync51 } from "node:fs";
 import { homedir as homedir71 } from "node:os";
-import { join as join126, resolve as resolve69 } from "node:path";
+import { join as join127, resolve as resolve69 } from "node:path";
 
 // src/openrouter/install-cron.ts
-import { existsSync as existsSync126, mkdirSync as mkdirSync72, readFileSync as readFileSync114, renameSync as renameSync33, writeFileSync as writeFileSync53 } from "node:fs";
-import { dirname as dirname52 } from "node:path";
+import { existsSync as existsSync127, mkdirSync as mkdirSync72, readFileSync as readFileSync114, renameSync as renameSync33, writeFileSync as writeFileSync53 } from "node:fs";
+import { dirname as dirname53 } from "node:path";
 var CRON_PATH3 = "/etc/cron.d/openrouter-watch";
 var CRON_SCHEDULE2 = "17 * * * *";
 var CRON_LOG_PATH3 = "/var/log/openrouter-watch.log";
@@ -130158,14 +131375,14 @@ function renderCron3(opts) {
 function installCron3(opts) {
   const path10 = opts.path ?? CRON_PATH3;
   const content = renderCron3(opts);
-  if (existsSync126(path10)) {
+  if (existsSync127(path10)) {
     try {
       if (readFileSync114(path10, "utf8") === content) {
         return { status: "unchanged", path: path10, content };
       }
     } catch {}
   }
-  mkdirSync72(dirname52(path10), { recursive: true });
+  mkdirSync72(dirname53(path10), { recursive: true });
   const tmp = `${path10}.${process.pid}.tmp`;
   writeFileSync53(tmp, content, { mode: 420 });
   renameSync33(tmp, path10);
@@ -130174,7 +131391,7 @@ function installCron3(opts) {
 // src/openrouter/state.ts
 import { mkdirSync as mkdirSync73, readFileSync as readFileSync115, renameSync as renameSync34, writeFileSync as writeFileSync54 } from "node:fs";
 import { homedir as homedir70 } from "node:os";
-import { dirname as dirname53, resolve as resolve68 } from "node:path";
+import { dirname as dirname54, resolve as resolve68 } from "node:path";
 function defaultStatePath3(home2 = process.env.SWITCHROOM_HOME ?? process.env.HOME ?? homedir70()) {
   return resolve68(home2, ".switchroom", "openrouter-watch", "state.json");
 }
@@ -130201,7 +131418,7 @@ function loadState2(path10) {
   return out;
 }
 function saveState2(path10, state) {
-  mkdirSync73(dirname53(path10), { recursive: true, mode: 448 });
+  mkdirSync73(dirname54(path10), { recursive: true, mode: 448 });
   const tmp = `${path10}.${process.pid}.tmp`;
   const payload = { v: 1, ...state };
   writeFileSync54(tmp, JSON.stringify(payload, null, 2) + `
@@ -130292,7 +131509,7 @@ function registerOpenRouterWatchCommand(program3) {
       process.exitCode = runInstallCron2(opts.cronUser);
       return;
     }
-    const agentsDir = opts.agentsDir ?? process.env.SWITCHROOM_AGENTS_DIR ?? join126(process.env.SWITCHROOM_HOME ?? process.env.HOME ?? homedir71(), ".switchroom", "agents");
+    const agentsDir = opts.agentsDir ?? process.env.SWITCHROOM_AGENTS_DIR ?? join127(process.env.SWITCHROOM_HOME ?? process.env.HOME ?? homedir71(), ".switchroom", "agents");
     const statePath = opts.state ?? defaultStatePath3();
     const log = (m) => {
       process.stderr.write(`${m}
@@ -130391,7 +131608,7 @@ async function notifyOperator2(agentsDir, text, log) {
   try {
     for (const name of readdirSync51(agentsDir).sort()) {
       const sock = resolve69(agentsDir, name, "telegram", "gateway.sock");
-      if (existsSync127(sock))
+      if (existsSync128(sock))
         candidates.push({ agent: name, sock });
     }
   } catch (e) {
@@ -130412,7 +131629,7 @@ init_sync();
 init_install_cron2();
 init_flock();
 import { homedir as homedir72 } from "node:os";
-import { join as join127 } from "node:path";
+import { join as join128 } from "node:path";
 function switchroomHome() {
   return process.env.SWITCHROOM_HOME ?? process.env.HOME ?? homedir72();
 }
@@ -130424,9 +131641,9 @@ function resolveSyncOptions(configPath, opts) {
       cfg = loaded.config_repo;
   } catch {}
   const home2 = switchroomHome();
-  const repoPath = opts.path ? resolvePath(opts.path) : cfg.path ? resolvePath(cfg.path) : join127(home2, ".switchroom-config");
-  const livePath = process.env.SWITCHROOM_CONFIG ?? join127(home2, ".switchroom", "switchroom.yaml");
-  const agentsDir = process.env.SWITCHROOM_AGENTS_DIR ?? join127(home2, ".switchroom", "agents");
+  const repoPath = opts.path ? resolvePath(opts.path) : cfg.path ? resolvePath(cfg.path) : join128(home2, ".switchroom-config");
+  const livePath = process.env.SWITCHROOM_CONFIG ?? join128(home2, ".switchroom", "switchroom.yaml");
+  const agentsDir = process.env.SWITCHROOM_AGENTS_DIR ?? join128(home2, ".switchroom", "agents");
   const push = opts.push === false ? false : cfg.push ?? true;
   const remote = opts.remote ?? cfg.remote ?? "origin";
   const requirePrivate = opts.requirePrivate ?? cfg.require_private ?? true;