switchroom 0.17.6 → 0.18.3

package/dist/cli/switchroom.js

@@ -13542,7 +13542,7 @@ var init_zod = __esm(() => {
 function isValidTimezone(value) {
   return TIMEZONE_REGEX.test(value);
 }
-var CodeRepoEntrySchema, AgentBindMountSchema, HttpDiffPollSchema, PollSpecSchema, TelegramMessageActionSchema, WebhookActionSchema, ActionSpecSchema, ScheduleEntrySchema, AgentSoulSchema, AgentToolsSchema, AgentMemorySchema, HookEntrySchema, AgentHooksSchema, SubagentSchema, SessionSchema, SessionContinuitySchema, webhookDispatchRule, TelegramChannelSchema, ChannelsSchema, TIMEZONE_REGEX, ApproverIdSchema, GoogleWorkspaceTierSchema, GoogleWorkspaceConfigSchema, LiteLLMConfigSchema, MicrosoftWorkspaceConfigSchema, NotionWorkspaceConfigSchema, AgentGoogleWorkspaceConfigSchema, AgentMicrosoftWorkspaceConfigSchema, AgentNotionWorkspaceConfigSchema, ReactionsSchema, ReactionDispatchSchema, ReleaseBlock, NetworkIsolationSchema, servesField, knowsField, profileFields, ProfileSchema, _omitExtends, defaultsFields, AgentDefaultsSchema, DEFAULT_PROFILE = "default", AgentSchema, TelegramConfigSchema, MemoryBackendConfigSchema, VaultConfigSchema, QuotaConfigSchema, AutoReleaseCheckSchema, HostControlConfigSchema, WebServiceConfigSchema, FleetHealthConfigSchema, HostdConfigSchema, CronEgressSchema, CronConfigSchema, UserSchema, SwitchroomConfigSchema;
+var CodeRepoEntrySchema, AgentBindMountSchema, HttpDiffPollSchema, PollSpecSchema, TelegramMessageActionSchema, WebhookActionSchema, ActionSpecSchema, ScheduleEntrySchema, AgentSoulSchema, AgentToolsSchema, AgentMemorySchema, HookEntrySchema, AgentHooksSchema, SubagentSchema, SessionSchema, SessionContinuitySchema, webhookDispatchRule, TelegramChannelSchema, ChannelsSchema, TIMEZONE_REGEX, ApproverIdSchema, GoogleWorkspaceTierSchema, GoogleWorkspaceConfigSchema, LiteLLMConfigSchema, HindsightPerOpLlmSchema, HindsightConfigSchema, MicrosoftWorkspaceConfigSchema, NotionWorkspaceConfigSchema, AgentGoogleWorkspaceConfigSchema, AgentMicrosoftWorkspaceConfigSchema, AgentNotionWorkspaceConfigSchema, ReactionsSchema, ReactionDispatchSchema, ReleaseBlock, NetworkIsolationSchema, servesField, knowsField, profileFields, ProfileSchema, _omitExtends, defaultsFields, AgentDefaultsSchema, DEFAULT_PROFILE = "default", AgentSchema, TelegramConfigSchema, MemoryBackendConfigSchema, VaultConfigSchema, QuotaConfigSchema, AutoReleaseCheckSchema, HostControlConfigSchema, WebServiceConfigSchema, FleetHealthConfigSchema, HostdConfigSchema, CronEgressSchema, CronConfigSchema, UserSchema, SwitchroomConfigSchema;
 var init_schema = __esm(() => {
   init_zod();
   CodeRepoEntrySchema = exports_external.object({
@@ -13656,8 +13656,35 @@ var init_schema = __esm(() => {
     auto_recall: exports_external.boolean().default(true).describe("Auto-search memories before each response"),
     file: exports_external.boolean().default(true).describe("Maintain a curated workspace MEMORY.md file (seeded once, " + "auto-loaded every turn). Set false for hindsight-only memory: " + "the file is not seeded or re-created, so once migrated into " + "Hindsight and deleted it stays gone. Recall + directives carry " + "the memory instead. Cascade: override (per-agent wins over default)."),
     isolation: exports_external.enum(["default", "strict"]).default("default").describe("strict = never shared cross-agent, default = eligible for reflect"),
-    bank_mission: exports_external.string().optional().describe("Bank-level mission statement used during recall to contextualize results"),
-    retain_mission: exports_external.string().optional().describe("Instructions for the fact extraction LLM during retain"),
+    bank_mission: exports_external.string().optional().describe("Bank-level mission statement used during recall to contextualize " + "results. NOTE: this is an alias for the Hindsight engine's " + "`reflect_mission` field (verified live: switchroom's bank_mission " + "lands in `config.reflect_mission`). Prefer `reflect_mission` going " + "forward; `bank_mission` is retained for back-compat. If both are " + "set, `reflect_mission` wins. Cascade: override."),
+    reflect_mission: exports_external.string().optional().describe("Mission/context steering Hindsight Reflect operations (the bank's " + "'who am I / what matters' framing applied during recall). The " + "engine-accurate name for what `bank_mission` sets. Cascade: override."),
+    retain_mission: exports_external.string().optional().describe("Instructions for the fact extraction LLM during retain. Cascade: override."),
+    mental_models: exports_external.array(exports_external.object({
+      name: exports_external.string().min(1).describe("Stable model name (identity key for idempotent ensure). Two " + "declarations with the same name in one agent are rejected."),
+      source_query: exports_external.string().min(1).max(2000).describe("The reflection query the model answers, semantically " + "refreshed from the bank's content. Capped at 2000 chars \u2014 a " + "standing reflection query, not a document; the ceiling also " + "bounds what an agent-proposed model can smuggle past the " + "operator approval card."),
+      refresh_after_consolidation: exports_external.boolean().optional().describe("Refresh this model after each consolidation. Defaults OFF \u2014 " + "refresh adds bounded background model-spend + timeout risk " + "(RFC Phase 5), so it is opt-in per model."),
+      max_tokens: exports_external.number().int().positive().max(8192).optional().describe("Cap on the synthesized model's token size. Upper-bounded at " + "8192 \u2014 a mental model is a standing summary, not a corpus; the " + "ceiling also caps what an agent-proposed model can request.")
+    })).superRefine((models, ctx) => {
+      const seen = new Set;
+      for (let i = 0;i < models.length; i++) {
+        const key = models[i].name;
+        if (seen.has(key)) {
+          ctx.addIssue({
+            code: exports_external.ZodIssueCode.custom,
+            path: [i, "name"],
+            message: `duplicate mental_models name "${key}" \u2014 model names must be ` + `unique within an agent (they are the idempotent-ensure key)`
+          });
+        }
+        seen.add(key);
+      }
+    }).optional().describe("Operator-declared, per-specialist Hindsight mental models (RFC " + "Phase 5). Named, opt-in curated reflections this agent's bank should " + "carry \u2014 e.g. a coach's 'training-plan-state' or a lawyer's " + "'open-matters'. Ensured idempotently at scaffold/reconcile: NOTHING " + "is created unless declared here (zero declarations = zero models, " + "matching post-#2447 behaviour), and no fixed identity model is " + "reintroduced \u2014 'who the user is' stays owned by dedicated profile " + "banks (users.*.profile_bank), never a per-agent model. Per-agent " + "ONLY: intentionally not accepted at the defaults/profile tier, so a " + "model can never be fleet-seeded \u2014 each specialist opts in on its own " + "(the invariant-clean inverse of the retired blind auto-seeding)."),
+    observations_mission: exports_external.string().optional().describe("Steers what the observation-consolidation LLM synthesises from raw " + "facts (the higher-order 'what patterns matter' lens). Cascade: override."),
+    disposition: exports_external.object({
+      skepticism: exports_external.number().int().min(1).max(5).optional().describe("How much the bank doubts unverified claims (1-5; engine default 3)."),
+      literalism: exports_external.number().int().min(1).max(5).optional().describe("How literally the bank reads statements vs inferring intent (1-5; engine default 3)."),
+      empathy: exports_external.number().int().min(1).max(5).optional().describe("How much the bank weights emotional/relational context (1-5; engine default 3).")
+    }).optional().describe("Personality traits (1-5 each) steering how this bank frames recall, " + "reflect, and observation synthesis \u2014 a coach leans empathy-high, a " + "lawyer/analyst leans skepticism/literalism-high. Maps to the engine's " + "flat `disposition_skepticism`/`_literalism`/`_empathy` fields. " + "Cascade: per-key merge (an agent overrides individual traits and " + "inherits the rest, matching `recall`)."),
+    directive_capture_nudge: exports_external.boolean().optional().describe("Deterministic directive-capture nudge (issue #2848 Stage B). When " + "on (switchroom default true \u2014 Stage A measured a ~55% miss rate on " + "durable corrections), the auto-recall hook regex-detects correction " + '/ standing-rule-shaped inbound ("always/never \u2026", "from now on \u2026", ' + `"stop doing \u2026", a stated preference, "that's wrong, it's \u2026") and ` + "appends a terse advisory to the turn's context telling the model to " + "persist the rule with mcp__hindsight__create_directive if it IS " + "durable. Detection is pure regex \u2014 the model does the judgment " + "in-session and calls create_directive itself (no model callsite, no " + "silent hook-side write). Set false to disable per-agent. " + "Cascade: override (per-agent wins over default)."),
     recall: exports_external.object({
       max_memories: exports_external.number().int().min(0).optional().describe("Cap on the number of memories injected into the prompt by " + "auto-recall, regardless of token budget. Plugin default is 12. " + "0 disables the cap (all memories Hindsight returns are injected)."),
       cache_ttl_secs: exports_external.number().int().min(0).optional().describe("Per-session recall cache TTL in seconds. When > 0, identical " + "(prompt, bank) within the same session reuse the cached recall " + "result instead of round-tripping to Hindsight. 0 disables. " + "Default is 600 (10 min) for switchroom-managed agents."),
@@ -13667,7 +13694,11 @@ var init_schema = __esm(() => {
       sender_banks: exports_external.record(exports_external.string(), exports_external.string()).optional().describe("Per-speaker recall routing: a map of Telegram sender \u2192 extra " + "recall bank. When a message arrives, the agent also recalls the " + "speaker's bank (matched by Telegram username \u2014 a leading @ is " + "optional \u2014 or numeric user_id), merged " + "into its own results \u2014 so each trusted user gets their own " + "profile context. Additive recall scoping within the single " + "tenant: never an access boundary (who may drive an agent stays " + "the per-agent user assignment in `access.allowFrom`). Author the " + "banks via `switchroom memory profile`."),
       skip_trivial: exports_external.boolean().optional().describe("Skip recall on plausibly-stateless trivial turns (time/date/" + "greeting). Switchroom default true \u2014 saves the recall arm + " + "injected tokens on turns that never need memory, guarded so it " + "never skips a turn that references user/project/session state. " + "Set false to always run recall."),
       topic_filter_mode: exports_external.enum(["soft-preamble", "hard-filter"]).optional().describe("Supergroup-mode cross-topic memory behaviour. Default " + "(unset) \u2192 soft-preamble: recall returns memories from all " + "topics, and a 'Current topic: \u2026' preamble tells the model " + "to self-scope. hard-filter: drop any recalled memory whose " + "metadata.thread_id differs from the active inbound's topic. " + "Flip to hard-filter when the recall_log shows binding " + "failures (model surfacing the right memory but applying " + "it to the wrong topic).")
-    }).optional().describe("Auto-recall tuning knobs")
+    }).optional().describe("Auto-recall tuning knobs"),
+    retain: exports_external.object({
+      every_n_turns: exports_external.number().int().min(1).optional().describe("How often the Stop hook fires auto-retention, in turns. The " + "vendor plugin default is 10 (a short session can end before " + "retention ever fires); switchroom's scaffold default is 3. " + "Lower = more frequent, smaller retains + tighter crash " + "durability (at 1, every turn is retained before a restart can " + "lose it); higher = fewer, larger retains + less LLM churn. " + "Raised from the historical 1 to 3 because the local reasoning " + "consolidation model (Ollama gpt-oss-20b) ran away on the large " + "overlapping every-turn payloads. Set to 1 for the old " + "every-turn crash-durability guarantee. Min 1. Cascade: " + "per-field merge (agent wins over default)."),
+      overlap_turns: exports_external.number().int().min(0).optional().describe("Extra recent turns included in each chunked retain window on " + "top of `every_n_turns`, so window = overlap_turns + " + "every_n_turns recent turns. Vendor default is 2; switchroom's " + "scaffold default is 1 (smaller payloads for the local " + "reasoning consolidation model). Higher = more redundant " + "context re-sent per fire. Min 0. Cascade: per-field merge.")
+    }).optional().describe("Auto-retain (Stop-hook consolidation) cadence knobs")
   }).optional();
   HookEntrySchema = exports_external.object({
     command: exports_external.string().describe("Shell command to run. Supports ${CLAUDE_CONFIG_DIR} and ${CLAUDE_PLUGIN_ROOT} substitution."),
@@ -13845,6 +13876,21 @@ var init_schema = __esm(() => {
     small_fast_model: exports_external.string().optional().describe("Model id exported as ANTHROPIC_SMALL_FAST_MODEL for the claude CLI's " + "background/fast lane, e.g. 'claude-haiku-4-5-20251001'."),
     tags: exports_external.record(exports_external.string(), exports_external.string()).optional().describe("Extra key/value metadata tags attached to the provisioned LiteLLM " + "virtual key. Merged per-key across cascade layers (agent wins).")
   }).optional().describe("LiteLLM routing config \u2014 opt-in per-agent virtual-key auto-provisioning " + "+ routing env. Default OFF. See LiteLLMConfigSchema doc for the full flow.");
+  HindsightPerOpLlmSchema = exports_external.object({
+    model: exports_external.string().min(1).optional().describe("Per-op model (upstream `HINDSIGHT_API_<OP>_LLM_MODEL`). Absent \u2192 " + "inherit the global `hindsight.llm.model`."),
+    provider: exports_external.string().min(1).optional().describe("Per-op provider (upstream `HINDSIGHT_API_<OP>_LLM_PROVIDER`). " + "Absent \u2192 inherit the global `hindsight.llm.provider`."),
+    base_url: exports_external.string().min(1).optional().describe("Per-op base URL (upstream `HINDSIGHT_API_<OP>_LLM_BASE_URL`). " + "Optional passthrough; absent \u2192 inherit the global."),
+    api_key: exports_external.string().min(1).optional().describe("Per-op API key (upstream `HINDSIGHT_API_<OP>_LLM_API_KEY`). Literal " + "or `vault:` reference. Optional passthrough; absent \u2192 inherit global.")
+  }).describe("Per-operation LLM override. Every field optional; an unset field (or " + "an omitted op block) inherits the global `hindsight.llm.*`, which is " + "already the engine's fallback \u2014 switchroom emits only the vars set.");
+  HindsightConfigSchema = exports_external.object({
+    llm: exports_external.object({
+      provider: exports_external.string().min(1).optional().describe("Hindsight LLM provider (upstream `HINDSIGHT_API_LLM_PROVIDER`). " + "Defaults to `claude-code` (subscription-honest, broker-fed OAuth). " + "Any litellm-routable provider the upstream image supports is valid. " + "Serves as the GLOBAL default for every op absent a per-op override."),
+      model: exports_external.string().min(1).optional().describe("Hindsight LLM model (upstream `HINDSIGHT_API_LLM_MODEL`). Defaults " + "to HINDSIGHT_DEFAULT_MODEL. Any model your LiteLLM proxy can route " + "is valid, e.g. `openrouter/z-ai/glm-5.2` when routing through the " + "fleet proxy. With provider=claude-code this value is ALSO exported " + "as `ANTHROPIC_MODEL` to the claude subprocess. Serves as the GLOBAL " + "default for every op absent a per-op override."),
+      retain: HindsightPerOpLlmSchema.optional().describe("Per-op override for the `retain` LLM op (memory ingestion). Emits " + "`HINDSIGHT_API_RETAIN_LLM_*`. Absent \u2192 uses the global model/provider."),
+      reflect: HindsightPerOpLlmSchema.optional().describe("Per-op override for the `reflect` LLM op (synthesis / mental-model " + "refresh). Emits `HINDSIGHT_API_REFLECT_LLM_*`. Absent \u2192 uses global."),
+      consolidation: HindsightPerOpLlmSchema.optional().describe("Per-op override for the `consolidation` LLM op (background memory " + "merge). Emits `HINDSIGHT_API_CONSOLIDATION_LLM_*`. Absent \u2192 global.")
+    }).optional().describe("LLM knob for the hindsight container. The flat `provider`/`model` set " + "the global default (backward-compatible); optional `retain`/`reflect`/" + "`consolidation` blocks override individual ops. All fields optional; " + "unset fields fall back to the hard-coded defaults.")
+  });
   MicrosoftWorkspaceConfigSchema = exports_external.object({
     microsoft_client_id: exports_external.string().min(1).optional().describe("Microsoft OAuth application (client) ID from Entra portal " + "(literal string or vault reference e.g. " + "'vault:microsoft-oauth-client-id'). OPTIONAL \u2014 omit it to use " + "switchroom's shipped default Microsoft app (zero-config). " + "Set it only to bring your own Entra app (BYO)."),
     microsoft_client_secret: exports_external.string().min(1).optional().describe("Microsoft OAuth client secret. Optional \u2014 public-client apps " + "(Mobile + Desktop platform with 'Allow public client flows' " + "enabled) work without a secret; confidential clients pass " + "one. Either literal or vault reference e.g. " + "'vault:microsoft-oauth-client-secret'."),
@@ -13922,6 +13968,7 @@ var init_schema = __esm(() => {
       auto_recall: exports_external.boolean().optional(),
       file: exports_external.boolean().optional(),
       isolation: exports_external.enum(["default", "strict"]).optional(),
+      directive_capture_nudge: exports_external.boolean().optional(),
       recall: exports_external.object({
         max_memories: exports_external.number().int().min(0).optional(),
         cache_ttl_secs: exports_external.number().int().min(0).optional(),
@@ -14092,6 +14139,7 @@ var init_schema = __esm(() => {
     config: exports_external.object({
       provider: exports_external.string().default("ollama").describe("Embedding provider (ollama, openai, anthropic)"),
       model: exports_external.string().optional().describe("Embedding model (e.g., 'nomic-embed-text')"),
+      llm_model: exports_external.string().optional().describe("LiteLLM model name for Hindsight's LLM ops (retain/reflect/" + "consolidation) when the top-level `litellm.enabled` carve-out is " + "on. Defaults to a cheap OpenRouter model (routed via LiteLLM's " + "model-mapped path, not the Anthropic OAuth pass-through) to keep " + "background memory-op cost off the Claude subscription quota. Set " + "to a `claude-*` model name to route it back through the OAuth " + "pass-through instead. Has no effect when litellm is disabled."),
       api_key: exports_external.string().optional().describe("API key or vault reference for embedding provider"),
       docker_service: exports_external.boolean().default(true).describe("Whether to include Hindsight in docker-compose"),
       url: exports_external.string().url("Hindsight URL must be a valid URL (no shell-special characters)").optional().describe("Hindsight MCP endpoint URL (e.g., http://localhost:18888/mcp/). Defaults to http://localhost:8888/mcp/.")
@@ -14169,6 +14217,7 @@ var init_schema = __esm(() => {
     telegram: TelegramConfigSchema,
     release: ReleaseBlock.optional().describe("Fleet-wide default release-channel pin / pointer for the update " + "flow. Either `channel` (dev|rc|latest) or `pin` (sha-<hex>|v<semver>) " + "\u2014 mutually exclusive. Per-agent `release` REPLACES this entirely."),
     memory: MemoryBackendConfigSchema.optional(),
+    hindsight: HindsightConfigSchema.optional().describe("Fleet-singleton Hindsight (memory backend) configuration. Currently " + "just the LLM knob (provider + model) used for retain/reflect/" + "consolidation. Both fields optional; when unset the container falls " + "back to provider=claude-code + the hard-coded HINDSIGHT_DEFAULT_MODEL " + "so nothing changes for operators who don't set it. Read at container " + "launch by startHindsight() (src/setup/hindsight.ts) \u2014 takes effect on " + "the next `switchroom apply` / `memory setup --recreate`."),
     vault: VaultConfigSchema.optional(),
     auth: exports_external.object({
       active: exports_external.string().min(1).optional().describe("Fleet-wide active Anthropic account label. Every agent without " + "an explicit `agent.auth.override` uses this account. See " + "docs/auth.md for the full model. Set by `switchroom auth use <label>`."),
@@ -14617,6 +14666,16 @@ function mergeAgentConfig(defaultsIn, agentIn) {
         continue;
       if (k === "recall" && base.recall && typeof v === "object" && v !== null && !Array.isArray(v)) {
         combined[k] = { ...base.recall, ...v };
+      } else if (k === "retain" && base.retain && typeof v === "object" && v !== null && !Array.isArray(v)) {
+        combined[k] = {
+          ...base.retain,
+          ...v
+        };
+      } else if (k === "disposition" && base.disposition && typeof v === "object" && v !== null && !Array.isArray(v)) {
+        combined[k] = {
+          ...base.disposition,
+          ...v
+        };
       } else {
         combined[k] = v;
       }
@@ -15065,7 +15124,7 @@ function resolveAgentsDir(config) {
   if (override && override.length > 0 && override.startsWith("/")) {
     return override;
   }
-  return resolveDualPath(config.switchroom.agents_dir);
+  return resolveDualPath(config.switchroom.agents_dir || "~/.switchroom/agents");
 }
 function resolvePath(pathStr) {
   return resolveDualPath(pathStr);
@@ -15122,9 +15181,839 @@ var init_users = __esm(() => {
   init_merge();
 });
 
+// src/agents/pane-lock.ts
+function withPaneLock(key, fn) {
+  const tail = tails.get(key) ?? Promise.resolve();
+  const run = tail.then(() => fn());
+  const next = run.then(() => {}, () => {});
+  tails.set(key, next);
+  next.then(() => {
+    if (tails.get(key) === next)
+      tails.delete(key);
+  });
+  return run;
+}
+var tails;
+var init_pane_lock = __esm(() => {
+  tails = new Map;
+});
+
+// src/agents/inject.ts
+var exports_inject = {};
+__export(exports_inject, {
+  validateInjectCommand: () => validateInjectCommand,
+  normalizeInjectCommand: () => normalizeInjectCommand,
+  makeTmuxRunner: () => makeTmuxRunner,
+  isTuiChromeLine: () => isTuiChromeLine,
+  injectSlashCommandWith: () => injectSlashCommandWith,
+  injectSlashCommand: () => injectSlashCommand,
+  diffPane: () => diffPane,
+  dedupeInjectQueue: () => dedupeInjectQueue,
+  InjectError: () => InjectError,
+  INJECT_COMMANDS: () => INJECT_COMMANDS,
+  INJECT_BLOCKLIST: () => INJECT_BLOCKLIST,
+  INJECT_BLOCKED: () => INJECT_BLOCKED,
+  INJECT_ALLOWLIST: () => INJECT_ALLOWLIST
+});
+import { execFileSync } from "node:child_process";
+function validateInjectCommand(command) {
+  if (typeof command !== "string" || command.trim().length === 0) {
+    throw new InjectError("invalid", "command is empty");
+  }
+  const trimmed = command.trim();
+  if (!trimmed.startsWith("/")) {
+    throw new InjectError("invalid", `command must start with "/": got ${trimmed}`);
+  }
+  const bare = trimmed.split(/\s+/, 1)[0].toLowerCase();
+  const blockedMeta = INJECT_BLOCKED.get(bare);
+  if (blockedMeta) {
+    throw new InjectError("blocked", `${bare} is explicitly blocked from inject (${blockedMeta.reason}).`);
+  }
+  if (!INJECT_COMMANDS.has(bare)) {
+    const allowed = [...INJECT_COMMANDS.keys()].sort().join(", ");
+    throw new InjectError("not_allowed", `${bare} is not in the inject allowlist. Allowed: ${allowed}`);
+  }
+  return bare;
+}
+function normalizeInjectCommand(command) {
+  return command.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function dedupeInjectQueue(commands) {
+  const seen = new Set;
+  const out = [];
+  for (const raw of commands) {
+    if (typeof raw !== "string")
+      continue;
+    const key = normalizeInjectCommand(raw);
+    if (key.length === 0)
+      continue;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    out.push(raw.trim());
+  }
+  return out;
+}
+function defaultSocketName(agentName) {
+  return `switchroom-${agentName}`;
+}
+function makeTmuxRunner(tmuxBin) {
+  return {
+    capture(socket, session) {
+      try {
+        return execFileSync(tmuxBin, ["-L", socket, "capture-pane", "-p", "-t", session, "-S", "-200"], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+      } catch {
+        return null;
+      }
+    },
+    send(socket, session, args) {
+      const [subcmd, ...rest] = args;
+      const flagEnd = rest.findIndex((a) => !a.startsWith("-"));
+      const flagsBeforeKeys = flagEnd === -1 ? rest : rest.slice(0, flagEnd);
+      const keys = flagEnd === -1 ? [] : rest.slice(flagEnd);
+      execFileSync(tmuxBin, ["-L", socket, subcmd, ...flagsBeforeKeys, "-t", session, ...keys], { stdio: ["pipe", "pipe", "pipe"] });
+    },
+    hasSession(socket, session) {
+      try {
+        execFileSync(tmuxBin, ["-L", socket, "has-session", "-t", session], {
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+function sleep(ms) {
+  return new Promise((res) => setTimeout(res, ms));
+}
+function isTuiChromeLine(line) {
+  const t = line.trim();
+  if (t.length === 0)
+    return false;
+  if (/^[\s\-_\u2502\u2500\u256d\u256e\u2570\u256f\u250c\u2510\u2514\u2518|]+$/.test(t))
+    return true;
+  if (/^[\u256d\u256e\u2570\u256f\u2502\s]*[>)\u276f][\u256d\u256e\u2570\u256f\u2502\s]*$/.test(t))
+    return true;
+  if (/accept edits on/i.test(t))
+    return true;
+  if (/shift\+tab to cycle/i.test(t))
+    return true;
+  if (/for agents/i.test(t))
+    return true;
+  if (/\? for shortcuts/i.test(t))
+    return true;
+  if (/bypassing permissions/i.test(t))
+    return true;
+  if (t === "copy")
+    return true;
+  return false;
+}
+function diffPane(before, after, command) {
+  if (command) {
+    const escaped = command.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const lines = after.split(`
+`);
+    let anchorIdx = -1;
+    for (let i = lines.length - 1;i >= 0; i--) {
+      if (/[\u276f>]\s+/.test(lines[i]) && lines[i].includes(escaped)) {
+        anchorIdx = i;
+        break;
+      }
+    }
+    if (anchorIdx >= 0) {
+      const tail = lines.slice(anchorIdx + 1);
+      const trimmed = [];
+      for (const raw of tail) {
+        const line = raw.trimEnd();
+        if (line.length === 0 && trimmed.length === 0)
+          continue;
+        if (isTuiChromeLine(line))
+          continue;
+        trimmed.push(line);
+      }
+      while (trimmed.length > 0 && trimmed[trimmed.length - 1].length === 0) {
+        trimmed.pop();
+      }
+      const affordances = /^(esc to cancel|press any key|\u21b5 select)/i;
+      while (trimmed.length > 0 && affordances.test(trimmed[trimmed.length - 1].trim())) {
+        trimmed.pop();
+      }
+      if (trimmed.length > 0) {
+        return { output: trimmed.join(`
+`), anchored: true };
+      }
+    }
+  }
+  const beforeSet = new Set(before.split(`
+`).map((l) => l.trimEnd()));
+  const newLines = [];
+  for (const raw of after.split(`
+`)) {
+    const line = raw.trimEnd();
+    if (line.length === 0)
+      continue;
+    if (beforeSet.has(line))
+      continue;
+    if (isTuiChromeLine(line))
+      continue;
+    newLines.push(line);
+  }
+  return { output: newLines.join(`
+`), anchored: false };
+}
+async function injectSlashCommand(agentName, command, opts = {}) {
+  validateInjectCommand(command);
+  const tmuxBin = opts.tmuxBin ?? "tmux";
+  const socket = opts.socketName ?? defaultSocketName(agentName);
+  const session = opts.sessionName ?? agentName;
+  const settleMs = opts.settleMs ?? 2000;
+  const timeoutMs = opts.timeoutMs ?? 5000;
+  return withPaneLock(`${socket}:${session}`, () => injectSlashCommandWith(makeTmuxRunner(tmuxBin), {
+    socket,
+    session,
+    command: command.trim(),
+    settleMs,
+    timeoutMs
+  }));
+}
+async function injectSlashCommandWith(runner, args) {
+  const { socket, session, command, settleMs, timeoutMs } = args;
+  let bareVerb;
+  try {
+    bareVerb = validateInjectCommand(command);
+  } catch (err) {
+    if (err instanceof InjectError) {
+      return {
+        outcome: "failed",
+        output: "",
+        truncated: false,
+        command: command.trim().split(/\s+/, 1)[0]?.toLowerCase() ?? "",
+        meta: null,
+        errorCode: err.code,
+        errorMessage: err.message
+      };
+    }
+    throw err;
+  }
+  const meta = INJECT_COMMANDS.get(bareVerb) ?? null;
+  if (!runner.hasSession(socket, session)) {
+    return {
+      outcome: "failed",
+      output: "",
+      truncated: false,
+      command: bareVerb,
+      meta,
+      errorCode: "session_missing",
+      errorMessage: `tmux session "${session}" on socket "${socket}" not found. ` + `Is the agent running under the tmux supervisor (the default)? ` + `If experimental.legacy_pty=true is set, inject is unsupported.`
+    };
+  }
+  const before = runner.capture(socket, session) ?? "";
+  try {
+    runner.send(socket, session, ["send-keys", "-l", command]);
+    runner.send(socket, session, ["send-keys", "Enter"]);
+  } catch (err) {
+    return {
+      outcome: "failed",
+      output: "",
+      truncated: false,
+      command: bareVerb,
+      meta,
+      errorCode: "tmux_failed",
+      errorMessage: `tmux send-keys failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const start = Date.now();
+  let last = before;
+  let stableSince = null;
+  while (Date.now() - start < timeoutMs) {
+    await sleep(POLL_INTERVAL_MS);
+    const cur = runner.capture(socket, session) ?? "";
+    if (cur === last && cur !== before) {
+      if (stableSince === null) {
+        stableSince = Date.now();
+      } else if (Date.now() - stableSince >= POLL_INTERVAL_MS) {
+        last = cur;
+        break;
+      }
+    } else {
+      stableSince = null;
+    }
+    last = cur;
+    if (Date.now() - start >= settleMs && cur !== before) {
+      break;
+    }
+  }
+  const { output: rawOutput, anchored } = diffPane(before, last, command);
+  let output = rawOutput;
+  let truncated = false;
+  const bytes = Buffer.byteLength(output, "utf-8");
+  if (bytes > OUTPUT_BYTE_CAP) {
+    while (Buffer.byteLength(output, "utf-8") > OUTPUT_BYTE_CAP) {
+      output = output.slice(Math.floor(output.length * 0.1) + 1);
+    }
+    truncated = true;
+  }
+  if (meta?.dialog) {
+    try {
+      runner.send(socket, session, ["send-keys", "Escape"]);
+    } catch {}
+  }
+  if (output.trim().length === 0) {
+    return {
+      outcome: "ok_no_output",
+      output: "",
+      truncated: false,
+      command: bareVerb,
+      meta,
+      ...anchored ? {} : { diagnostic: "anchor_missing" }
+    };
+  }
+  return {
+    outcome: "ok",
+    output,
+    truncated,
+    command: bareVerb,
+    meta,
+    ...truncated ? { diagnostic: "truncated_output" } : {}
+  };
+}
+var INJECT_COMMANDS, INJECT_ALLOWLIST, INJECT_BLOCKED, INJECT_BLOCKLIST, InjectError, POLL_INTERVAL_MS = 150, OUTPUT_BYTE_CAP = 3000;
+var init_inject = __esm(() => {
+  init_pane_lock();
+  INJECT_COMMANDS = new Map([
+    ["/cost", { description: "Show session cost", expectsOutput: true, dialog: true }],
+    ["/status", { description: "Show session status", expectsOutput: true, dialog: true }],
+    ["/usage", { description: "Show plan quota", expectsOutput: true, dialog: true }],
+    ["/hooks", { description: "List configured hooks", expectsOutput: true, dialog: true }],
+    ["/memory", { description: "Open memory picker", expectsOutput: true, dialog: true }],
+    ["/model", { description: "Open model picker", expectsOutput: true }],
+    [
+      "/clear",
+      {
+        description: "Clear session screen",
+        expectsOutput: false,
+        silentNote: "context cleared \u2014 fresh slate"
+      }
+    ],
+    [
+      "/compact",
+      {
+        description: "Compact conversation history",
+        expectsOutput: false,
+        silentNote: "compaction runs silently"
+      }
+    ]
+  ]);
+  INJECT_ALLOWLIST = new Set(INJECT_COMMANDS.keys());
+  INJECT_BLOCKED = new Map([
+    ["/login", { reason: "would mutate auth state" }],
+    ["/logout", { reason: "would terminate the agent's auth session" }],
+    ["/exit", { reason: "would kill the agent process" }],
+    ["/quit", { reason: "would kill the agent process" }],
+    [
+      "/effort",
+      {
+        reason: "leaves a blocking confirmation modal open and wedges the pane; use the /effort command (it drives the modal), not raw inject"
+      }
+    ]
+  ]);
+  INJECT_BLOCKLIST = new Set(INJECT_BLOCKED.keys());
+  InjectError = class InjectError extends Error {
+    code;
+    constructor(code, message) {
+      super(message);
+      this.name = "InjectError";
+      this.code = code;
+    }
+  };
+});
+
+// src/agents/model-picker.ts
+var init_model_picker = __esm(() => {
+  init_inject();
+  init_pane_lock();
+});
+
+// telegram-plugin/gateway/model-command.ts
+function isClaudeModel(name) {
+  const lower = name.toLowerCase();
+  if (MODEL_ALIASES.includes(lower))
+    return true;
+  return lower.startsWith("claude-");
+}
+var MODEL_ALIASES;
+var init_model_command = __esm(() => {
+  init_model_picker();
+  MODEL_ALIASES = ["opus", "sonnet", "haiku", "fable", "default"];
+});
+
+// src/util/atomic.ts
+var exports_atomic = {};
+__export(exports_atomic, {
+  writeConfigFileSync: () => writeConfigFileSync,
+  atomicWriteJsonSync: () => atomicWriteJsonSync,
+  atomicWriteFileSync: () => atomicWriteFileSync
+});
+import { randomBytes } from "node:crypto";
+import { closeSync as closeSync2, constants, fsyncSync, openSync as openSync2, renameSync, rmSync, writeSync } from "node:fs";
+function atomicWriteFileSync(destPath, contents, mode = 384) {
+  const tmp = `${destPath}.tmp-${process.pid}-${randomBytes(4).toString("hex")}`;
+  const buf = typeof contents === "string" ? Buffer.from(contents, "utf-8") : contents;
+  let fd = null;
+  try {
+    fd = openSync2(tmp, TMP_OPEN_FLAGS, mode);
+    writeSync(fd, buf, 0, buf.length, 0);
+    fsyncSync(fd);
+    closeSync2(fd);
+    fd = null;
+    renameSync(tmp, destPath);
+  } catch (err) {
+    if (fd !== null) {
+      try {
+        closeSync2(fd);
+      } catch {}
+    }
+    try {
+      rmSync(tmp, { force: true });
+    } catch {}
+    throw err;
+  }
+}
+function atomicWriteJsonSync(destPath, value, mode = 384) {
+  atomicWriteFileSync(destPath, JSON.stringify(value, null, 2) + `
+`, mode);
+}
+function writeConfigFileSync(destPath, contents, mode = 420) {
+  try {
+    atomicWriteFileSync(destPath, contents, mode);
+  } catch (err) {
+    const code = err.code;
+    if (code !== "EBUSY" && code !== "EXDEV" && code !== "EINVAL") {
+      throw err;
+    }
+    const buf = typeof contents === "string" ? Buffer.from(contents, "utf-8") : contents;
+    let fd = null;
+    try {
+      fd = openSync2(destPath, constants.O_WRONLY | constants.O_TRUNC, mode);
+      writeSync(fd, buf, 0, buf.length, 0);
+      fsyncSync(fd);
+      closeSync2(fd);
+      fd = null;
+    } catch (fallbackErr) {
+      if (fd !== null) {
+        try {
+          closeSync2(fd);
+        } catch {}
+      }
+      throw fallbackErr;
+    }
+  }
+}
+var TMP_OPEN_FLAGS;
+var init_atomic = __esm(() => {
+  TMP_OPEN_FLAGS = constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW ?? 0);
+});
+
+// src/setup/hindsight.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { createServer } from "node:net";
+function hindsightImageRef(tag) {
+  const t = tag?.trim();
+  if (!t)
+    return HINDSIGHT_IMAGE;
+  const v = t.replace(/^v/, "");
+  return `${HINDSIGHT_IMAGE_REPO}:v${v}`;
+}
+function isPortFree(port) {
+  return new Promise((resolve4) => {
+    const server = createServer();
+    server.once("error", () => resolve4(false));
+    server.once("listening", () => {
+      server.close(() => resolve4(true));
+    });
+    server.listen(port, "127.0.0.1");
+  });
+}
+function describePortHolder(port) {
+  const probes = [
+    ["ss", ["-ltnpH", `sport = :${port}`]],
+    ["lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN"]]
+  ];
+  for (const [cmd, args] of probes) {
+    try {
+      const out = execFileSync2(cmd, args, {
+        stdio: "pipe",
+        encoding: "utf-8"
+      }).trim();
+      if (!out)
+        continue;
+      const ssMatch = out.match(/users:\(\("([^"]+)",pid=(\d+)/);
+      if (ssMatch)
+        return `pid ${ssMatch[2]} (${ssMatch[1]})`;
+      const firstDataLine = out.split(`
+`).map((l) => l.trim()).find((l) => l && !/^COMMAND\b/.test(l));
+      if (firstDataLine) {
+        const parts = firstDataLine.split(/\s+/);
+        if (cmd === "lsof" && parts.length >= 2) {
+          return `pid ${parts[1]} (${parts[0]})`;
+        }
+        return firstDataLine.slice(0, 80);
+      }
+    } catch {}
+  }
+  return null;
+}
+async function preflightHindsightPorts(ports) {
+  for (const port of [ports.apiPort, ports.uiPort]) {
+    if (!await isPortFree(port)) {
+      return { port, holder: describePortHolder(port) };
+    }
+  }
+  return null;
+}
+async function findFreePort(start, maxAttempts = 50) {
+  for (let i = 0;i < maxAttempts; i++) {
+    const port = start + i;
+    if (port < 1024)
+      continue;
+    if (await isPortFree(port)) {
+      return port;
+    }
+  }
+  return null;
+}
+async function pickHindsightPorts() {
+  if (await isPortFree(HINDSIGHT_DEFAULT_API_PORT) && await isPortFree(HINDSIGHT_DEFAULT_UI_PORT)) {
+    return {
+      apiPort: HINDSIGHT_DEFAULT_API_PORT,
+      uiPort: HINDSIGHT_DEFAULT_UI_PORT
+    };
+  }
+  const apiPort = await findFreePort(18888);
+  const uiPort = await findFreePort(19999);
+  if (apiPort === null || uiPort === null) {
+    throw new Error("Could not find a free port for Hindsight. " + "Stop whatever is using 18888 / 19999 and retry.");
+  }
+  return { apiPort, uiPort };
+}
+function isDockerAvailable() {
+  try {
+    execFileSync2("docker", ["--version"], { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isHindsightRunning() {
+  try {
+    const output = execFileSync2("docker", ["ps", "--filter", "name=switchroom-hindsight", "--format", "{{.Status}}"], { stdio: "pipe", encoding: "utf-8" });
+    return output.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function isHindsightContainerExists() {
+  try {
+    const output = execFileSync2("docker", ["ps", "-a", "--filter", "name=switchroom-hindsight", "--format", "{{.Names}}"], { stdio: "pipe", encoding: "utf-8" });
+    return output.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function resolveHindsightPerOpLlm(llm) {
+  const out = [];
+  if (!llm)
+    return out;
+  for (const op of HINDSIGHT_LLM_OPS) {
+    const cfg = llm[op];
+    if (!cfg)
+      continue;
+    const prefix = `HINDSIGHT_API_${op.toUpperCase()}_LLM`;
+    const model = cfg.model?.trim();
+    const provider = cfg.provider?.trim();
+    const baseUrl = cfg.base_url?.trim();
+    const apiKey = cfg.api_key?.trim();
+    if (model)
+      out.push([`${prefix}_MODEL`, model]);
+    if (provider)
+      out.push([`${prefix}_PROVIDER`, provider]);
+    if (baseUrl)
+      out.push([`${prefix}_BASE_URL`, baseUrl]);
+    if (apiKey)
+      out.push([`${prefix}_API_KEY`, apiKey]);
+  }
+  return out;
+}
+function resolveHindsightLlm(llm, litellm) {
+  const provider = llm?.provider?.trim() || "claude-code";
+  const model = llm?.model?.trim() || (litellm ? litellm.model ?? HINDSIGHT_DEFAULT_LITELLM_MODEL : HINDSIGHT_DEFAULT_MODEL);
+  return { provider, model };
+}
+function startHindsight(ports, litellm, imageTag, llm) {
+  const apiPort = ports?.apiPort ?? HINDSIGHT_DEFAULT_API_PORT;
+  const uiPort = ports?.uiPort ?? HINDSIGHT_DEFAULT_UI_PORT;
+  const { provider: llmProvider, model: llmModel } = resolveHindsightLlm(llm, litellm);
+  const perOpLlm = resolveHindsightPerOpLlm(llm);
+  const envArgs = [
+    "-e",
+    `HINDSIGHT_API_MAX_OBSERVATIONS_PER_SCOPE=${HINDSIGHT_DEFAULT_MAX_OBSERVATIONS_PER_SCOPE}`,
+    "-e",
+    `HINDSIGHT_API_LLM_PROVIDER=${llmProvider}`,
+    "-e",
+    `HINDSIGHT_API_LLM_MODEL=${llmModel}`,
+    ...perOpLlm.flatMap(([k, v]) => ["-e", `${k}=${v}`]),
+    "-e",
+    `HINDSIGHT_API_MCP_STATELESS=${HINDSIGHT_DEFAULT_MCP_STATELESS}`,
+    "-e",
+    `HINDSIGHT_API_RERANKER_LOCAL_BUCKET_BATCHING=${HINDSIGHT_DEFAULT_RERANKER_BUCKET_BATCHING}`,
+    "-e",
+    `HINDSIGHT_API_RERANKER_MAX_CANDIDATES=${HINDSIGHT_DEFAULT_RERANKER_MAX_CANDIDATES}`,
+    "-e",
+    `HINDSIGHT_API_RERANKER_LOCAL_MAX_CONCURRENT=${HINDSIGHT_DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT}`,
+    "-e",
+    `HINDSIGHT_API_RECALL_MAX_CONCURRENT=${HINDSIGHT_DEFAULT_RECALL_MAX_CONCURRENT}`,
+    "-e",
+    `HINDSIGHT_API_REFLECT_WALL_TIMEOUT=${HINDSIGHT_DEFAULT_REFLECT_WALL_TIMEOUT_S}`,
+    "-e",
+    `HINDSIGHT_API_CONSOLIDATION_LLM_BATCH_SIZE=${HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_BATCH_SIZE}`,
+    "-e",
+    `HINDSIGHT_API_WORKER_CONSOLIDATION_MAX_SLOTS=${HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_SLOTS}`,
+    "-e",
+    `HINDSIGHT_API_CONSOLIDATION_LLM_PARALLELISM=${HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_PARALLELISM}`,
+    "-e",
+    `HINDSIGHT_API_CONSOLIDATION_MAX_MEMORIES_PER_ROUND=${HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND}`
+  ];
+  if (llmProvider === "claude-code") {
+    envArgs.push("-e", `ANTHROPIC_MODEL=${llmModel}`);
+  }
+  if (litellm) {
+    const litellmRoot = litellm.baseUrl.replace(/\/+$/, "");
+    const anthropicBaseUrl = isClaudeModel(llmModel) ? `${litellmRoot}/anthropic` : litellmRoot;
+    envArgs.push("-e", `HINDSIGHT_API_PORT=${apiPort}`, "-e", `HINDSIGHT_CP_DATAPLANE_API_URL=http://localhost:${apiPort}`, "-e", `ANTHROPIC_BASE_URL=${anthropicBaseUrl}`, "-e", `ANTHROPIC_CUSTOM_HEADERS=x-litellm-api-key: Bearer ${litellm.apiKey}
+x-litellm-customer-id: hindsight
+x-litellm-tags: service:hindsight`);
+  }
+  const args = [
+    "run",
+    "-d",
+    "--name",
+    "switchroom-hindsight",
+    "--restart",
+    "always",
+    `--memory=${HINDSIGHT_DEFAULT_MEM_LIMIT}`,
+    `--memory-reservation=${HINDSIGHT_DEFAULT_MEM_RESERVATION}`,
+    `--pids-limit=${HINDSIGHT_DEFAULT_PIDS_LIMIT}`,
+    `--shm-size=${HINDSIGHT_DEFAULT_SHM_SIZE}`,
+    "--health-cmd",
+    litellm ? `python3 -c 'import urllib.request,sys; sys.exit(0 if urllib.request.urlopen("http://localhost:${apiPort}/health",timeout=4).getcode()==200 else 1)'` : HINDSIGHT_HEALTHCHECK_CMD,
+    "--health-interval",
+    "30s",
+    "--health-timeout",
+    "5s",
+    "--health-retries",
+    "3",
+    "--health-start-period",
+    "60s"
+  ];
+  if (litellm) {
+    args.push("--network", "host");
+  } else {
+    args.push("-p", `127.0.0.1:${apiPort}:8888`, "-p", `127.0.0.1:${uiPort}:9999`);
+  }
+  args.push("-v", "switchroom-hindsight-data:/home/hindsight/.pg0", "-v", "switchroom-hindsight-backups:/backups", "-v", `${HINDSIGHT_BROKER_SOCK_VOLUME}:/run/switchroom/auth-broker`, "--tmpfs", `/run/claude-creds:rw,mode=0700,uid=${HINDSIGHT_DEFAULT_UID},gid=${HINDSIGHT_DEFAULT_UID}`, ...envArgs, hindsightImageRef(imageTag));
+  execFileSync2("docker", args, { stdio: "pipe" });
+}
+function stopHindsight() {
+  try {
+    execFileSync2("docker", ["stop", "switchroom-hindsight"], { stdio: "pipe" });
+  } catch {}
+  try {
+    execFileSync2("docker", ["rm", "switchroom-hindsight"], { stdio: "pipe" });
+  } catch {}
+}
+function pullHindsightImage(imageTag) {
+  execFileSync2("docker", ["pull", hindsightImageRef(imageTag)], { stdio: "inherit" });
+}
+function getRunningHindsightPorts() {
+  const CONTAINER_API_PORT = 8888;
+  const CONTAINER_UI_PORT = 9999;
+  const readPort = (containerPort) => {
+    try {
+      const out = execFileSync2("docker", ["port", "switchroom-hindsight", `${containerPort}/tcp`], { stdio: "pipe", encoding: "utf-8" });
+      const m = out.split(`
+`).map((l) => l.trim()).find((l) => l.length > 0);
+      if (!m)
+        return null;
+      const port = Number(m.slice(m.lastIndexOf(":") + 1));
+      return Number.isInteger(port) && port > 0 ? port : null;
+    } catch {
+      return null;
+    }
+  };
+  const apiPort = readPort(CONTAINER_API_PORT);
+  if (apiPort !== null) {
+    const uiPort = readPort(CONTAINER_UI_PORT) ?? (apiPort === HINDSIGHT_DEFAULT_API_PORT ? HINDSIGHT_DEFAULT_UI_PORT : 19999);
+    return { apiPort, uiPort };
+  }
+  return getHindsightPortsFromEnv();
+}
+function getHindsightPortsFromEnv() {
+  let env2;
+  try {
+    env2 = execFileSync2("docker", ["inspect", "--format", "{{.Config.Env}}", "switchroom-hindsight"], { stdio: "pipe", encoding: "utf-8" });
+  } catch {
+    return null;
+  }
+  const readVar = (name) => {
+    const re = new RegExp(`(?:^|[\\s\\[])${name}=([^\\s\\]]+)`);
+    const m = env2.match(re);
+    if (!m)
+      return null;
+    const n = Number(m[1]);
+    return Number.isInteger(n) && n > 0 ? n : null;
+  };
+  const apiPort = readVar("HINDSIGHT_API_PORT");
+  if (apiPort === null)
+    return null;
+  const uiPort = readVar("HINDSIGHT_UI_PORT") ?? (apiPort === HINDSIGHT_DEFAULT_API_PORT ? HINDSIGHT_DEFAULT_UI_PORT : 19999);
+  return { apiPort, uiPort };
+}
+function getHindsightStatus() {
+  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;
+  } catch {
+    return null;
+  }
+}
+function generateHindsightComposeSnippet(llm) {
+  const { provider: llmProvider, model: llmModel } = resolveHindsightLlm(llm);
+  const perOpLlm = resolveHindsightPerOpLlm(llm);
+  const environment = [
+    `      - HINDSIGHT_API_MAX_OBSERVATIONS_PER_SCOPE=${HINDSIGHT_DEFAULT_MAX_OBSERVATIONS_PER_SCOPE}`,
+    `      - HINDSIGHT_API_LLM_PROVIDER=${llmProvider}`,
+    `      - HINDSIGHT_API_LLM_MODEL=${llmModel}`,
+    ...perOpLlm.map(([k, v]) => `      - ${k}=${v}`),
+    ...llmProvider === "claude-code" ? [`      - ANTHROPIC_MODEL=${llmModel}`] : [],
+    `      - HINDSIGHT_CP_DATAPLANE_API_URL=http://localhost:8888`
+  ];
+  return [
+    "services:",
+    "  switchroom-hindsight:",
+    `    image: ${HINDSIGHT_IMAGE}`,
+    "    container_name: switchroom-hindsight",
+    "    ports:",
+    `      - "127.0.0.1:${HINDSIGHT_DEFAULT_API_PORT}:8888"`,
+    '      - "127.0.0.1:19999:9999"',
+    "    environment:",
+    ...environment,
+    `      - HINDSIGHT_API_MCP_STATELESS=${HINDSIGHT_DEFAULT_MCP_STATELESS}`,
+    `      - HINDSIGHT_API_RERANKER_LOCAL_BUCKET_BATCHING=${HINDSIGHT_DEFAULT_RERANKER_BUCKET_BATCHING}`,
+    `      - HINDSIGHT_API_RERANKER_MAX_CANDIDATES=${HINDSIGHT_DEFAULT_RERANKER_MAX_CANDIDATES}`,
+    `      - HINDSIGHT_API_RERANKER_LOCAL_MAX_CONCURRENT=${HINDSIGHT_DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT}`,
+    `      - HINDSIGHT_API_RECALL_MAX_CONCURRENT=${HINDSIGHT_DEFAULT_RECALL_MAX_CONCURRENT}`,
+    `      - HINDSIGHT_API_REFLECT_WALL_TIMEOUT=${HINDSIGHT_DEFAULT_REFLECT_WALL_TIMEOUT_S}`,
+    `      - HINDSIGHT_API_CONSOLIDATION_LLM_BATCH_SIZE=${HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_BATCH_SIZE}`,
+    `      - HINDSIGHT_API_WORKER_CONSOLIDATION_MAX_SLOTS=${HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_SLOTS}`,
+    `      - HINDSIGHT_API_CONSOLIDATION_LLM_PARALLELISM=${HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_PARALLELISM}`,
+    `      - HINDSIGHT_API_CONSOLIDATION_MAX_MEMORIES_PER_ROUND=${HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND}`,
+    `    mem_limit: ${HINDSIGHT_DEFAULT_MEM_LIMIT}`,
+    `    mem_reservation: ${HINDSIGHT_DEFAULT_MEM_RESERVATION}`,
+    `    pids_limit: ${HINDSIGHT_DEFAULT_PIDS_LIMIT}`,
+    `    shm_size: ${HINDSIGHT_DEFAULT_SHM_SIZE}`,
+    "    healthcheck:",
+    `      test: ${JSON.stringify(["CMD", "python3", "-c", HINDSIGHT_HEALTHCHECK_PY])}`,
+    "      interval: 30s",
+    "      timeout: 5s",
+    "      retries: 3",
+    "      start_period: 60s",
+    "    volumes:",
+    "      - switchroom-hindsight-data:/home/hindsight/.pg0",
+    "      - switchroom-hindsight-backups:/backups",
+    `      - ${HINDSIGHT_BROKER_SOCK_VOLUME}:/run/switchroom/auth-broker`,
+    "    tmpfs:",
+    `      - /run/claude-creds:rw,mode=0700,uid=${HINDSIGHT_DEFAULT_UID},gid=${HINDSIGHT_DEFAULT_UID}`,
+    "    restart: always",
+    "",
+    "volumes:",
+    "  switchroom-hindsight-data:",
+    "  switchroom-hindsight-backups:",
+    `  ${HINDSIGHT_BROKER_SOCK_VOLUME}:`,
+    "    external: true",
+    "    # Bound by the switchroom-auth-broker singleton in the main",
+    "    # switchroom compose project. Declare an `auth.consumers[]`",
+    `    # entry named "${HINDSIGHT_CONSUMER_NAME}" in switchroom.yaml.`
+  ].join(`
+`);
+}
+async function ensureHindsightConsumer(configPath, account, uid = HINDSIGHT_DEFAULT_UID) {
+  const fs = await import("node:fs");
+  const { parseDocument, isMap, isSeq, YAMLMap, YAMLSeq } = await Promise.resolve().then(() => __toESM(require_dist(), 1));
+  const { atomicWriteFileSync: atomicWriteFileSync2 } = await Promise.resolve().then(() => (init_atomic(), exports_atomic));
+  const raw = fs.readFileSync(configPath, "utf-8");
+  const doc = parseDocument(raw);
+  const root = doc.contents;
+  if (!isMap(root)) {
+    return { added: false, reason: "switchroom.yaml root is not a map" };
+  }
+  const authRaw = root.get("auth", true);
+  let authNode;
+  if (isMap(authRaw)) {
+    authNode = authRaw;
+  } else {
+    authNode = new YAMLMap;
+    doc.setIn(["auth"], authNode);
+  }
+  const consumersRaw = authNode.get("consumers", true);
+  let consumersNode;
+  if (isSeq(consumersRaw)) {
+    consumersNode = consumersRaw;
+  } else {
+    consumersNode = new YAMLSeq;
+    doc.setIn(["auth", "consumers"], consumersNode);
+  }
+  for (const item of consumersNode.items) {
+    if (isMap(item)) {
+      const name = item.get("name");
+      if (name === HINDSIGHT_CONSUMER_NAME) {
+        return { added: false, reason: "already present" };
+      }
+    }
+  }
+  const entry = new YAMLMap;
+  entry.set("name", HINDSIGHT_CONSUMER_NAME);
+  if (account !== undefined)
+    entry.set("account", account);
+  entry.set("uid", uid);
+  consumersNode.add(entry);
+  const out = String(doc);
+  const tail = out.endsWith(`
+`) ? out : out + `
+`;
+  let mode = 420;
+  try {
+    mode = fs.statSync(configPath).mode & 511;
+  } catch {}
+  atomicWriteFileSync2(configPath, tail, mode);
+  return { added: true, reason: "added" };
+}
+var HINDSIGHT_DEFAULT_API_PORT = 18888, HINDSIGHT_DEFAULT_UI_PORT = 9999, HINDSIGHT_DEFAULT_MCP_URL, HINDSIGHT_DEFAULT_API_BASE_URL, HINDSIGHT_DEFAULT_MAX_OBSERVATIONS_PER_SCOPE = 1000, HINDSIGHT_CONSUMER_NAME = "hindsight", HINDSIGHT_DEFAULT_UID = 11000, HINDSIGHT_IMAGE_REPO = "ghcr.io/switchroom/switchroom-hindsight", HINDSIGHT_IMAGE, HINDSIGHT_DEFAULT_MODEL = "claude-sonnet-5", HINDSIGHT_DEFAULT_LITELLM_MODEL = "openrouter/google/gemini-3.1-flash-lite", HINDSIGHT_DEFAULT_MCP_STATELESS = true, HINDSIGHT_BROKER_SOCK_VOLUME, HINDSIGHT_DEFAULT_RERANKER_BUCKET_BATCHING = "true", HINDSIGHT_DEFAULT_RERANKER_MAX_CANDIDATES = 150, HINDSIGHT_DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT = 4, HINDSIGHT_DEFAULT_RECALL_MAX_CONCURRENT = 8, HINDSIGHT_DEFAULT_REFLECT_WALL_TIMEOUT_S = 600, HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_BATCH_SIZE = 12, HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_SLOTS = 1, HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_PARALLELISM = 2, HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND = 100, HINDSIGHT_DEFAULT_MEM_LIMIT = "8g", HINDSIGHT_DEFAULT_MEM_RESERVATION = "4g", HINDSIGHT_DEFAULT_PIDS_LIMIT = 1000, HINDSIGHT_DEFAULT_SHM_SIZE = "2g", HINDSIGHT_HEALTHCHECK_PY = 'import urllib.request,sys; sys.exit(0 if urllib.request.urlopen("http://localhost:8888/health",timeout=4).getcode()==200 else 1)', HINDSIGHT_HEALTHCHECK_CMD, HINDSIGHT_LLM_OPS;
+var init_hindsight = __esm(() => {
+  init_model_command();
+  HINDSIGHT_DEFAULT_MCP_URL = `http://127.0.0.1:${HINDSIGHT_DEFAULT_API_PORT}/mcp/`;
+  HINDSIGHT_DEFAULT_API_BASE_URL = HINDSIGHT_DEFAULT_MCP_URL.replace(/\/mcp\/?$/, "");
+  HINDSIGHT_IMAGE = `${HINDSIGHT_IMAGE_REPO}:latest`;
+  HINDSIGHT_BROKER_SOCK_VOLUME = `auth-broker-${HINDSIGHT_CONSUMER_NAME}-sock`;
+  HINDSIGHT_HEALTHCHECK_CMD = `python3 -c '${HINDSIGHT_HEALTHCHECK_PY}'`;
+  HINDSIGHT_LLM_OPS = ["retain", "reflect", "consolidation"];
+});
+
 // src/memory/hindsight.ts
 function generateHindsightMcpConfig(collection, memoryConfig) {
-  const url = memoryConfig.config?.url ?? "http://localhost:8888/mcp/";
+  const url = memoryConfig.config?.url ?? HINDSIGHT_DEFAULT_MCP_URL;
   return {
     type: "http",
     url,
@@ -15167,6 +16056,26 @@ function isHindsightEnabled(config) {
     return false;
   return config?.memory?.backend === "hindsight";
 }
+function mergeDisposition(base, over) {
+  if (!base && !over)
+    return;
+  const merged = { ...base ?? {}, ...over ?? {} };
+  return Object.keys(merged).length > 0 ? merged : undefined;
+}
+function resolveBankMissionExtras(memory, profileName) {
+  const pd = PROFILE_MEMORY_DEFAULTS[profileName] ?? {};
+  const out = {};
+  const reflect = memory?.reflect_mission ?? pd.reflect_mission;
+  if (reflect != null)
+    out.reflect_mission = reflect;
+  const observations = memory?.observations_mission ?? pd.observations_mission;
+  if (observations != null)
+    out.observations_mission = observations;
+  const disposition = mergeDisposition(pd.disposition, memory?.disposition);
+  if (disposition)
+    out.disposition = disposition;
+  return out;
+}
 async function parseSseOrJson(resp) {
   const text = await resp.text();
   const dataLine = text.split(`
@@ -15253,9 +16162,19 @@ async function probeHindsight(apiUrl, opts) {
     clearTimeout(timeout);
   }
 }
-async function ensureUserProfileMentalModel(apiUrl, bankId, opts) {
+async function ensureMentalModel(apiUrl, bankId, spec, opts) {
   const fetchImpl = opts?.fetchImpl ?? fetch;
   const timeoutMs = opts?.timeoutMs ?? 5000;
+  const createArguments = {
+    name: spec.name,
+    source_query: spec.sourceQuery
+  };
+  if (spec.refreshAfterConsolidation !== undefined) {
+    createArguments.trigger_refresh_after_consolidation = spec.refreshAfterConsolidation;
+  }
+  if (spec.maxTokens !== undefined) {
+    createArguments.max_tokens = spec.maxTokens;
+  }
   try {
     const controller = new AbortController;
     const timeout = setTimeout(() => controller.abort(), timeoutMs);
@@ -15312,7 +16231,7 @@ async function ensureUserProfileMentalModel(apiUrl, bankId, opts) {
         if (models && typeof models === "string") {
           const parsed = JSON.parse(models);
           const items = Array.isArray(parsed?.items) ? parsed.items : [];
-          if (items.some((m) => m?.name === "user-profile")) {
+          if (items.some((m) => m?.name === spec.name)) {
             return { ok: true };
           }
         }
@@ -15333,10 +16252,7 @@ async function ensureUserProfileMentalModel(apiUrl, bankId, opts) {
         method: "tools/call",
         params: {
           name: "create_mental_model",
-          arguments: {
-            name: "user-profile",
-            source_query: "What are the key facts, preferences, context, and communication style about the user I talk to? Summarize what matters for making the agent feel like it knows them."
-          }
+          arguments: createArguments
         }
       }),
       signal: controller.signal
@@ -15360,6 +16276,33 @@ async function ensureUserProfileMentalModel(apiUrl, bankId, opts) {
     return { ok: false, reason: String(err) };
   }
 }
+async function ensureUserProfileMentalModel(apiUrl, bankId, opts) {
+  return ensureMentalModel(apiUrl, bankId, { name: "user-profile", sourceQuery: USER_PROFILE_SOURCE_QUERY }, opts);
+}
+async function ensureDeclaredMentalModels(apiUrl, bankId, models, opts) {
+  if (!models || models.length === 0)
+    return [];
+  const outcomes = [];
+  const seen = new Set;
+  for (const m of models) {
+    if (seen.has(m.name))
+      continue;
+    seen.add(m.name);
+    const spec = {
+      name: m.name,
+      sourceQuery: m.source_query,
+      refreshAfterConsolidation: m.refresh_after_consolidation,
+      maxTokens: m.max_tokens
+    };
+    try {
+      const result = await ensureMentalModel(apiUrl, bankId, spec, opts);
+      outcomes.push(result.ok ? { name: m.name, ok: true } : { name: m.name, ok: false, reason: result.reason });
+    } catch (err) {
+      outcomes.push({ name: m.name, ok: false, reason: String(err) });
+    }
+  }
+  return outcomes;
+}
 async function createBank(apiUrl, bankId, opts) {
   const fetchImpl = opts?.fetchImpl ?? fetch;
   const timeoutMs = opts?.timeoutMs ?? 5000;
@@ -15487,8 +16430,24 @@ async function updateBankMissions(apiUrl, bankId, missions, opts) {
           name: "update_bank",
           arguments: {
             bank_id: bankId,
-            ...missions.bank_mission != null ? { mission: missions.bank_mission } : {},
-            ...missions.retain_mission != null ? { config_updates: { retain_mission: missions.retain_mission } } : {}
+            ...missions.reflect_mission == null && missions.bank_mission != null ? { mission: missions.bank_mission } : {},
+            ...(() => {
+              const configUpdates = {};
+              if (missions.retain_mission != null)
+                configUpdates.retain_mission = missions.retain_mission;
+              if (missions.reflect_mission != null)
+                configUpdates.reflect_mission = missions.reflect_mission;
+              if (missions.observations_mission != null)
+                configUpdates.observations_mission = missions.observations_mission;
+              const d = missions.disposition;
+              if (d?.skepticism != null)
+                configUpdates.disposition_skepticism = d.skepticism;
+              if (d?.literalism != null)
+                configUpdates.disposition_literalism = d.literalism;
+              if (d?.empathy != null)
+                configUpdates.disposition_empathy = d.empathy;
+              return Object.keys(configUpdates).length > 0 ? { config_updates: configUpdates } : {};
+            })()
           }
         }
       }),
@@ -15586,10 +16545,23 @@ async function addMemoryTag(apiUrl, bankId, memoryId, tag, opts) {
     return { ok: false, reason: String(err) };
   }
 }
-var DEFAULT_RETAIN_MISSION, DEMOTE_FROM_RECALL_TAG = "[demote-from-recall]";
-var init_hindsight = __esm(() => {
+var DEFAULT_RETAIN_MISSION, PROFILE_MEMORY_DEFAULTS, USER_PROFILE_SOURCE_QUERY = "What are the key facts, preferences, context, and communication style about the user I talk to? Summarize what matters for making the agent feel like it knows them.", DEMOTE_FROM_RECALL_TAG = "[demote-from-recall]";
+var init_hindsight2 = __esm(() => {
   init_users();
+  init_hindsight();
   DEFAULT_RETAIN_MISSION = "Extract user preferences, ongoing projects, recurring commitments, " + "important context, and durable facts that should help across future " + "conversations. Skip one-off chatter and temporary task noise.";
+  PROFILE_MEMORY_DEFAULTS = {
+    "health-coach": {
+      disposition: { skepticism: 2, literalism: 2, empathy: 5 },
+      observations_mission: "Synthesise the person's wellbeing patterns, motivations, and emotional " + "context \u2014 how habits, setbacks, and encouragement connect over time."
+    },
+    "executive-assistant": {
+      disposition: { skepticism: 4, literalism: 4, empathy: 3 }
+    },
+    coding: {
+      disposition: { skepticism: 4, literalism: 5, empathy: 2 }
+    }
+  };
 });
 
 // src/cli/helpers.ts
@@ -22398,7 +23370,8 @@ function getBuiltinDefaultSkillEntries() {
     "switchroom-cli",
     "switchroom-status",
     "switchroom-health",
-    "switchroom-runtime"
+    "switchroom-runtime",
+    "mental-model-curator"
   ];
   return [
     ...anthropic.map((key) => ({ key, optOutKey: key, source: "anthropic" })),
@@ -22407,7 +23380,7 @@ function getBuiltinDefaultSkillEntries() {
 }
 var GOOGLE_WORKSPACE_MCP_PINNED_SHA = "9d69115b63e6bc2ef0d4b5d7a3b962396382b44c", MICROSOFT_WORKSPACE_MCP_PINNED_VERSION = "0.113.0", MICROSOFT_WORKSPACE_MCP_PACKAGE = "@softeria/ms-365-mcp-server", NOTION_MCP_PINNED_VERSION = "1.8.1", NOTION_MCP_PACKAGE = "@notionhq/notion-mcp-server", NOTION_TOKEN_ENV = "NOTION_TOKEN";
 var init_scaffold_integration = __esm(() => {
-  init_hindsight();
+  init_hindsight2();
 });
 
 // src/config/microsoft-workspace-acl.ts
@@ -22425,7 +23398,7 @@ function shouldEmitMs365Mcp(agentName, agentMicrosoftAccount, microsoftAccounts)
 }
 
 // src/agents/reconcile-default-skills.ts
-import { existsSync as existsSync7, lstatSync, mkdirSync as mkdirSync3, readdirSync as readdirSync3, readlinkSync as readlinkSync2, rmSync, symlinkSync } from "node:fs";
+import { existsSync as existsSync7, lstatSync, mkdirSync as mkdirSync3, readdirSync as readdirSync3, readlinkSync as readlinkSync2, rmSync as rmSync2, symlinkSync } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { join as join5, resolve as resolve5 } from "node:path";
 function warnMissingPoolDir(poolDir) {
@@ -22495,7 +23468,7 @@ function reconcileAgentDefaultSkills(agentDir, optOuts = {}, defaults = getBuilt
         }
         if (currentTarget && isOwnedStaleLink(currentTarget, poolDir)) {
           try {
-            rmSync(dest, { force: true });
+            rmSync2(dest, { force: true });
           } catch {}
         } else {
           result.conflicts.push(entry.key);
@@ -22560,7 +23533,7 @@ import {
   writeFileSync as writeFileSync2,
   mkdirSync as mkdirSync4,
   existsSync as existsSync8,
-  renameSync,
+  renameSync as renameSync2,
   copyFileSync as copyFileSync2,
   unlinkSync
 } from "node:fs";
@@ -22600,7 +23573,7 @@ function saveTopicState(state, statePath) {
   try {
     writeFileSync2(tmp, JSON.stringify(state, null, 2) + `
 `, "utf-8");
-    renameSync(tmp, path);
+    renameSync2(tmp, path);
   } catch (err) {
     try {
       if (existsSync8(tmp))
@@ -22616,10 +23589,10 @@ var init_state = __esm(() => {
 // src/vault/flock.ts
 import {
   existsSync as existsSync9,
-  openSync as openSync2,
-  closeSync as closeSync2,
-  writeSync,
-  fsyncSync,
+  openSync as openSync3,
+  closeSync as closeSync3,
+  writeSync as writeSync2,
+  fsyncSync as fsyncSync2,
   unlinkSync as unlinkSync2,
   readFileSync as readFileSync8,
   readdirSync as readdirSync4,
@@ -22741,7 +23714,7 @@ function acquireLock(vaultPath, options = {}) {
   while (true) {
     let fd = null;
     try {
-      fd = openSync2(lockPath, fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL, 384);
+      fd = openSync3(lockPath, fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL, 384);
     } catch (err) {
       const code = err?.code ?? "";
       if (code === "EEXIST") {
@@ -22777,11 +23750,11 @@ function acquireLock(vaultPath, options = {}) {
 ${Date.now()}
 ${process.argv[1] ?? ""}
 `;
-      writeSync(fd, meta);
-      fsyncSync(fd);
+      writeSync2(fd, meta);
+      fsyncSync2(fd);
     } catch {
       try {
-        closeSync2(fd);
+        closeSync3(fd);
       } catch {}
       try {
         unlinkSync2(lockPath);
@@ -22792,7 +23765,7 @@ ${process.argv[1] ?? ""}
     return {
       release: () => {
         try {
-          closeSync2(ownedFd);
+          closeSync3(ownedFd);
         } catch {}
         try {
           unlinkSync2(lockPath);
@@ -22849,22 +23822,22 @@ __export(exports_vault, {
   KNOWN_VAULT_ARTIFACT_PATTERNS: () => KNOWN_VAULT_ARTIFACT_PATTERNS,
   KNOWN_VAULT_ARTIFACT_NAMES: () => KNOWN_VAULT_ARTIFACT_NAMES
 });
-import { randomBytes, scryptSync, createCipheriv, createDecipheriv } from "node:crypto";
+import { randomBytes as randomBytes2, scryptSync, createCipheriv, createDecipheriv } from "node:crypto";
 import {
   readFileSync as readFileSync9,
-  writeSync as writeSync2,
+  writeSync as writeSync3,
   existsSync as existsSync10,
-  renameSync as renameSync2,
+  renameSync as renameSync3,
   mkdirSync as mkdirSync5,
   unlinkSync as unlinkSync3,
-  fsyncSync as fsyncSync2,
-  openSync as openSync3,
-  closeSync as closeSync3,
+  fsyncSync as fsyncSync3,
+  openSync as openSync4,
+  closeSync as closeSync4,
   lstatSync as lstatSync2,
   realpathSync as realpathSync2
 } from "node:fs";
 import { dirname as dirname3, basename as basename3, resolve as resolve7 } from "node:path";
-function atomicWriteFileSync(path, data, mode) {
+function atomicWriteFileSync2(path, data, mode) {
   let effectivePath = path;
   try {
     if (existsSync10(path) && lstatSync2(path).isSymbolicLink()) {
@@ -22874,20 +23847,20 @@ function atomicWriteFileSync(path, data, mode) {
   const dir = dirname3(resolve7(effectivePath));
   const tmp = resolve7(dir, `.${basename3(effectivePath)}.${process.pid}.${Date.now()}.tmp`);
   try {
-    const fd = openSync3(tmp, "wx", mode);
+    const fd = openSync4(tmp, "wx", mode);
     try {
-      writeSync2(fd, data);
-      fsyncSync2(fd);
+      writeSync3(fd, data);
+      fsyncSync3(fd);
     } finally {
-      closeSync3(fd);
+      closeSync4(fd);
     }
-    renameSync2(tmp, effectivePath);
+    renameSync3(tmp, effectivePath);
     try {
-      const dirFd = openSync3(dir, "r");
+      const dirFd = openSync4(dir, "r");
       try {
-        fsyncSync2(dirFd);
+        fsyncSync3(dirFd);
       } finally {
-        closeSync3(dirFd);
+        closeSync4(dirFd);
       }
     } catch {}
   } catch (err) {
@@ -22907,7 +23880,7 @@ function deriveKey(passphrase, salt, params = { N: SCRYPT_N, r: SCRYPT_R, p: SCR
   });
 }
 function encrypt(key, plaintext) {
-  const iv = randomBytes(12);
+  const iv = randomBytes2(12);
   const cipher = createCipheriv("aes-256-gcm", key, iv);
   const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
   const tag = cipher.getAuthTag();
@@ -23012,7 +23985,7 @@ function createVault(passphrase, vaultPath) {
   if (!existsSync10(dir)) {
     mkdirSync5(dir, { recursive: true, mode: 448 });
   }
-  const salt = randomBytes(16);
+  const salt = randomBytes2(16);
   const key = deriveKey(passphrase, salt);
   const vaultData = { secrets: {} };
   const { iv, data, tag } = encrypt(key, JSON.stringify(vaultData));
@@ -23023,7 +23996,7 @@ function createVault(passphrase, vaultPath) {
     tag,
     kdf: { N: SCRYPT_N, r: SCRYPT_R, p: SCRYPT_P }
   };
-  atomicWriteFileSync(vaultPath, JSON.stringify(vaultFile, null, 2), 384);
+  atomicWriteFileSync2(vaultPath, JSON.stringify(vaultFile, null, 2), 384);
 }
 function openVault(passphrase, vaultPath) {
   if (!existsSync10(vaultPath)) {
@@ -23080,7 +24053,7 @@ function saveVault(passphrase, vaultPath, secrets) {
     vaultFile.iv = iv;
     vaultFile.data = data;
     vaultFile.tag = tag;
-    atomicWriteFileSync(vaultPath, JSON.stringify(vaultFile, null, 2), 384);
+    atomicWriteFileSync2(vaultPath, JSON.stringify(vaultFile, null, 2), 384);
   } finally {
     if (releaseLock !== null) {
       try {
@@ -23262,7 +24235,7 @@ function parseSocketIdentity(socketPath, spec) {
 }
 
 // src/vault/broker/peercred.ts
-import { execFileSync } from "node:child_process";
+import { execFileSync as execFileSync3 } from "node:child_process";
 import { readFileSync as readFileSync10, readlinkSync as readlinkSync3, fstatSync } from "node:fs";
 function socketPathToIdentity(socketPath) {
   return parseSocketIdentity(socketPath, {
@@ -23435,7 +24408,7 @@ function identify(socketPath, socket, execFileSyncOverride) {
   if (process.platform !== "linux") {
     return null;
   }
-  const runner = execFileSyncOverride ?? execFileSync;
+  const runner = execFileSyncOverride ?? execFileSync3;
   let pid = null;
   if (socket !== undefined) {
     const fd = fdFromSocket(socket);
@@ -23919,7 +24892,8 @@ function brokerIsComposeManaged() {
   return fs.existsSync(OPERATOR_SOCKET_PATH);
 }
 function vaultTokenFilePath(agentSlug) {
-  return join6(homedir4(), ".switchroom", "agents", agentSlug, ".vault-token");
+  const base = process.env.SWITCHROOM_AGENTS_DIR || join6(homedir4(), ".switchroom", "agents");
+  return join6(base, agentSlug, ".vault-token");
 }
 function readVaultTokenFile(agentSlug) {
   const filePath = vaultTokenFilePath(agentSlug);
@@ -24295,13 +25269,13 @@ __export(exports_resolver, {
 });
 import {
   chmodSync,
-  closeSync as closeSync4,
+  closeSync as closeSync5,
   mkdirSync as mkdirSync6,
   mkdtempSync,
-  openSync as openSync4,
-  rmSync as rmSync2,
+  openSync as openSync5,
+  rmSync as rmSync3,
   statSync as statSync6,
-  writeSync as writeSync3
+  writeSync as writeSync4
 } from "node:fs";
 import { join as join7 } from "node:path";
 import { tmpdir } from "node:os";
@@ -24329,13 +25303,13 @@ function registerCleanupHook() {
   const cleanup = () => {
     for (const dir of materializedDirs) {
       try {
-        rmSync2(dir, { recursive: true, force: true });
+        rmSync3(dir, { recursive: true, force: true });
       } catch {}
     }
     materializedDirs.clear();
     if (cachedRoot) {
       try {
-        rmSync2(cachedRoot, { recursive: true, force: true });
+        rmSync3(cachedRoot, { recursive: true, force: true });
       } catch {}
       cachedRoot = null;
     }
@@ -24366,18 +25340,18 @@ function materializationRoot() {
 }
 function writeFileExclusive(filePath, content) {
   const buf = typeof content === "string" ? Buffer.from(content, "utf8") : content;
-  const fd = openSync4(filePath, fsConstants2.O_WRONLY | fsConstants2.O_CREAT | fsConstants2.O_EXCL, 384);
+  const fd = openSync5(filePath, fsConstants2.O_WRONLY | fsConstants2.O_CREAT | fsConstants2.O_EXCL, 384);
   try {
-    writeSync3(fd, buf);
+    writeSync4(fd, buf);
   } finally {
-    closeSync4(fd);
+    closeSync5(fd);
   }
 }
 function materializeFilesEntry(key, files) {
   const dir = join7(materializationRoot(), key);
   if (materializedDirs.has(dir)) {
     try {
-      rmSync2(dir, { recursive: true, force: true });
+      rmSync3(dir, { recursive: true, force: true });
     } catch {}
   }
   mkdirSync6(dir, { recursive: true, mode: 448 });
@@ -24401,13 +25375,13 @@ function materializeFilesEntry(key, files) {
 function cleanupMaterializedSecrets() {
   for (const dir of materializedDirs) {
     try {
-      rmSync2(dir, { recursive: true, force: true });
+      rmSync3(dir, { recursive: true, force: true });
     } catch {}
   }
   materializedDirs.clear();
   if (cachedRoot) {
     try {
-      rmSync2(cachedRoot, { recursive: true, force: true });
+      rmSync3(cachedRoot, { recursive: true, force: true });
     } catch {}
     cachedRoot = null;
   }
@@ -24728,7 +25702,7 @@ var init_onboarding = __esm(() => {
 });
 
 // src/repos/bare-clone.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
+import { execFileSync as execFileSync4 } from "node:child_process";
 import { existsSync as existsSync13, mkdirSync as mkdirSync8 } from "node:fs";
 import { resolve as resolve9 } from "node:path";
 function bareClonePath(slug) {
@@ -24741,7 +25715,7 @@ function ensureBareClone(slug, url) {
   if (!existsSync13(clonePath)) {
     process.stderr.write(`[switchroom] repo "${slug}": cloning ${url} \u2026
 `);
-    execFileSync2("git", ["clone", "--bare", url, clonePath], {
+    execFileSync4("git", ["clone", "--bare", url, clonePath], {
       stdio: ["ignore", "pipe", "pipe"]
     });
     process.stderr.write(`[switchroom] repo "${slug}": bare clone ready at ${clonePath}
@@ -24750,7 +25724,7 @@ function ensureBareClone(slug, url) {
     process.stderr.write(`[switchroom] repo "${slug}": fetching ${clonePath} \u2026
 `);
     try {
-      execFileSync2("git", ["fetch", "--all"], {
+      execFileSync4("git", ["fetch", "--all"], {
         cwd: clonePath,
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -24767,7 +25741,7 @@ var init_bare_clone = __esm(() => {
 });
 
 // src/repos/agent-worktree.ts
-import { execFileSync as execFileSync3 } from "node:child_process";
+import { execFileSync as execFileSync5 } from "node:child_process";
 import { existsSync as existsSync14, mkdirSync as mkdirSync9, readdirSync as readdirSync5 } from "node:fs";
 import { join as join9, resolve as resolve10 } from "node:path";
 function agentBranchName(agentName) {
@@ -24778,7 +25752,7 @@ function agentWorktreePath(agentDir, slug) {
 }
 function isWorktreeDirty(worktreePath) {
   try {
-    const out = execFileSync3("git", ["status", "--porcelain"], {
+    const out = execFileSync5("git", ["status", "--porcelain"], {
       cwd: worktreePath,
       stdio: ["ignore", "pipe", "pipe"],
       encoding: "utf-8"
@@ -24790,7 +25764,7 @@ function isWorktreeDirty(worktreePath) {
 }
 function headShortSha(worktreePath) {
   try {
-    return execFileSync3("git", ["rev-parse", "--short", "HEAD"], {
+    return execFileSync5("git", ["rev-parse", "--short", "HEAD"], {
       cwd: worktreePath,
       stdio: ["ignore", "pipe", "pipe"],
       encoding: "utf-8"
@@ -24801,7 +25775,7 @@ function headShortSha(worktreePath) {
 }
 function branchExistsInBare(bareClonePath2, branchName) {
   try {
-    execFileSync3("git", ["rev-parse", "--verify", `refs/heads/${branchName}`], {
+    execFileSync5("git", ["rev-parse", "--verify", `refs/heads/${branchName}`], {
       cwd: bareClonePath2,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -24812,7 +25786,7 @@ function branchExistsInBare(bareClonePath2, branchName) {
 }
 function resolveDefaultBranch(bareClonePath2) {
   try {
-    const out = execFileSync3("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
+    const out = execFileSync5("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
       cwd: bareClonePath2,
       stdio: ["ignore", "pipe", "pipe"],
       encoding: "utf-8"
@@ -24830,12 +25804,12 @@ function ensureAgentWorktree(agentName, slug, bareClonePath2, agentDir) {
   if (!existsSync14(worktreePath)) {
     mkdirSync9(join9(agentDir, "work"), { recursive: true });
     if (branchExistsInBare(bareClonePath2, branch)) {
-      execFileSync3("git", ["worktree", "add", worktreePath, branch], {
+      execFileSync5("git", ["worktree", "add", worktreePath, branch], {
         cwd: bareClonePath2,
         stdio: ["ignore", "pipe", "pipe"]
       });
     } else {
-      execFileSync3("git", [
+      execFileSync5("git", [
         "worktree",
         "add",
         worktreePath,
@@ -24863,11 +25837,11 @@ function ensureAgentWorktree(agentName, slug, bareClonePath2, agentDir) {
     };
   }
   try {
-    execFileSync3("git", ["fetch", "origin"], {
+    execFileSync5("git", ["fetch", "origin"], {
       cwd: worktreePath,
       stdio: ["ignore", "pipe", "pipe"]
     });
-    execFileSync3("git", ["merge", "--ff-only", `origin/${defaultBranch}`], {
+    execFileSync5("git", ["merge", "--ff-only", `origin/${defaultBranch}`], {
       cwd: worktreePath,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -24885,7 +25859,7 @@ function removeAgentWorktree(agentName, slug, bareClonePath2, agentDir) {
   const branch = agentBranchName(agentName);
   if (existsSync14(worktreePath)) {
     try {
-      execFileSync3("git", ["worktree", "remove", "--force", worktreePath], {
+      execFileSync5("git", ["worktree", "remove", "--force", worktreePath], {
         cwd: bareClonePath2,
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -24897,7 +25871,7 @@ function removeAgentWorktree(agentName, slug, bareClonePath2, agentDir) {
   }
   if (branchExistsInBare(bareClonePath2, branch)) {
     try {
-      execFileSync3("git", ["branch", "-D", branch], {
+      execFileSync5("git", ["branch", "-D", branch], {
         cwd: bareClonePath2,
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -24908,7 +25882,7 @@ function removeAgentWorktree(agentName, slug, bareClonePath2, agentDir) {
     }
   }
   try {
-    execFileSync3("git", ["worktree", "prune"], {
+    execFileSync5("git", ["worktree", "prune"], {
       cwd: bareClonePath2,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -24925,19 +25899,19 @@ import {
   writeFileSync as writeFileSync4,
   appendFileSync as appendFileSync2,
   readFileSync as readFileSync13,
-  renameSync as renameSync3,
+  renameSync as renameSync4,
   chmodSync as chmodSync2,
   symlinkSync as symlinkSync2,
   copyFileSync as copyFileSync4,
   readdirSync as readdirSync6,
-  rmSync as rmSync3,
+  rmSync as rmSync4,
   statSync as statSync7,
   lstatSync as lstatSync3,
   readlinkSync as readlinkSync4,
   unlinkSync as unlinkSync4
 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { execSync, execFileSync as execFileSync4 } from "node:child_process";
+import { execSync, execFileSync as execFileSync6 } from "node:child_process";
 import { join as join10, resolve as resolve11 } from "node:path";
 import { createHash as createHash2 } from "node:crypto";
 function prependReplyDiscipline(rendered, context) {
@@ -25071,13 +26045,13 @@ function alignAgentUid(name, agentDir, uid, opts = {}) {
 `));
   }
   try {
-    execFileSync4("chown", ["-R", `${uid}:${uid}`, ...paths], {
+    execFileSync6("chown", ["-R", `${uid}:${uid}`, ...paths], {
       stdio: ["ignore", "ignore", "pipe"]
     });
     return { chowned: true, paths };
   } catch {}
   try {
-    execFileSync4("sudo", ["chown", "-R", `${uid}:${uid}`, ...paths], {
+    execFileSync6("sudo", ["chown", "-R", `${uid}:${uid}`, ...paths], {
       stdio: "inherit"
     });
     return { chowned: true, paths };
@@ -25271,7 +26245,7 @@ function migrateLegacySkillsDir(agentDir, skillsPool) {
     }
     if (target && target.startsWith(skillsPool)) {
       try {
-        rmSync3(entryPath, { force: true });
+        rmSync4(entryPath, { force: true });
       } catch {}
     }
   }
@@ -25306,7 +26280,7 @@ function syncGlobalSkills(agentDir, declared, skillsDirOverride) {
         } catch {}
         if (target && target.startsWith(skillsPool)) {
           try {
-            rmSync3(dest, { force: true });
+            rmSync4(dest, { force: true });
           } catch {}
         } else {
           continue;
@@ -25336,7 +26310,7 @@ function syncGlobalSkills(agentDir, declared, skillsDirOverride) {
       continue;
     }
     if (linkTarget && linkTarget.startsWith(skillsPool)) {
-      rmSync3(entryPath, { force: true });
+      rmSync4(entryPath, { force: true });
     }
   }
 }
@@ -25391,7 +26365,7 @@ function installSwitchroomSkills(agentDir, opts = {}) {
       if (currentTarget !== join10(builtinSkillsDir, name))
         continue;
       try {
-        rmSync3(dest, { force: true });
+        rmSync4(dest, { force: true });
       } catch {}
     }
     return;
@@ -25414,7 +26388,7 @@ function installSwitchroomSkills(agentDir, opts = {}) {
         if (currentTarget === src)
           continue;
         try {
-          rmSync3(dest, { force: true });
+          rmSync4(dest, { force: true });
         } catch {}
       } else {
         continue;
@@ -25666,7 +26640,7 @@ function migrateLegacyAgentsMdIfPresent(agentWorkspaceDir, created) {
   }
   const content = readFileSync13(agentsMd, "utf-8");
   writeFileSync4(claudeMd, content, "utf-8");
-  rmSync3(agentsMd);
+  rmSync4(agentsMd);
   created.push(claudeMd);
   console.log(source_default.dim(`  migrated legacy workspace/AGENTS.md \u2192 workspace/CLAUDE.md (content preserved)`));
 }
@@ -25682,9 +26656,9 @@ function ensureClaudeMdSymlinks(agentWorkspaceDir, changes) {
         const target = readlinkSync4(linkPath);
         if (target === "CLAUDE.md")
           continue;
-        rmSync3(linkPath);
+        rmSync4(linkPath);
       } else {
-        rmSync3(linkPath);
+        rmSync4(linkPath);
       }
     }
     symlinkSync2("CLAUDE.md", linkPath);
@@ -25725,7 +26699,7 @@ Thumbs.db
     execSync("git add -A", { cwd: workspaceDir, stdio: "pipe" });
     const userEmail = process.env.GIT_AUTHOR_EMAIL || "switchroom@localhost";
     const userName = process.env.GIT_AUTHOR_NAME || "Switchroom Agent";
-    execFileSync4("git", [
+    execFileSync6("git", [
       "-c",
       `user.email=${userEmail}`,
       "-c",
@@ -25763,27 +26737,36 @@ function installHindsightPlugin(agentName, agentDir, switchroomConfig) {
   }
   const destPath = join10(agentDir, ".claude", "plugins", "hindsight-memory");
   const additionalBanks = resolveUsers(switchroomConfig, agentName).additionalBanks;
+  const retainConfig = resolveHindsightRetainConfig(switchroomConfig, agentName);
   let expectedSettings = null;
   try {
     const vendorSettingsPath = join10(sourcePath, "settings.json");
     if (existsSync15(vendorSettingsPath)) {
-      expectedSettings = renderHindsightSettingsOverrides(readFileSync13(vendorSettingsPath, "utf-8"), additionalBanks);
+      expectedSettings = renderHindsightSettingsOverrides(readFileSync13(vendorSettingsPath, "utf-8"), additionalBanks, retainConfig);
     }
   } catch {}
   const upToDate = dirContentEquals(sourcePath, destPath, expectedSettings != null ? { "settings.json": expectedSettings } : undefined);
   if (!upToDate) {
     if (existsSync15(destPath)) {
-      rmSync3(destPath, { recursive: true, force: true });
+      rmSync4(destPath, { recursive: true, force: true });
     }
     copyDirRecursive2(sourcePath, destPath);
   }
-  applyHindsightSettingsOverrides(destPath, additionalBanks);
+  applyHindsightSettingsOverrides(destPath, additionalBanks, retainConfig);
   const bankId = agentMemory?.collection ?? agentName;
-  const mcpUrl = memory.config?.url ?? "http://127.0.0.1:8888/mcp/";
+  const mcpUrl = memory.config?.url ?? HINDSIGHT_DEFAULT_MCP_URL;
   const apiBaseUrl = mcpUrl.replace(/\/mcp\/?$/, "").replace(/\/$/, "");
   return { pluginDir: destPath, apiBaseUrl, bankId };
 }
-function applyHindsightSettingsOverrides(pluginDestPath, additionalBanks) {
+function resolveHindsightRetainConfig(switchroomConfig, agentName) {
+  const resolved = switchroomConfig ? resolveAgentConfig(switchroomConfig.defaults, switchroomConfig.profiles, switchroomConfig.agents[agentName] ?? {}) : undefined;
+  const retain = resolved?.memory?.retain;
+  return {
+    everyNTurns: retain?.every_n_turns ?? HINDSIGHT_DEFAULT_RETAIN_EVERY_N_TURNS,
+    overlapTurns: retain?.overlap_turns ?? HINDSIGHT_DEFAULT_RETAIN_OVERLAP_TURNS
+  };
+}
+function applyHindsightSettingsOverrides(pluginDestPath, additionalBanks, retainConfig) {
   const settingsPath = join10(pluginDestPath, "settings.json");
   if (!existsSync15(settingsPath))
     return;
@@ -25793,41 +26776,51 @@ function applyHindsightSettingsOverrides(pluginDestPath, additionalBanks) {
   } catch {
     return;
   }
-  const next = renderHindsightSettingsOverrides(raw, additionalBanks);
+  const next = renderHindsightSettingsOverrides(raw, additionalBanks, retainConfig);
   if (next == null)
     return;
   writeFileSyncIfChanged(settingsPath, next);
 }
-function renderHindsightSettingsOverrides(raw, additionalBanks) {
+function renderHindsightSettingsOverrides(raw, additionalBanks, retainConfig) {
   let settings;
   try {
     settings = JSON.parse(raw);
   } catch {
     return null;
   }
-  settings.retainEveryNTurns = 1;
+  settings.retainEveryNTurns = retainConfig.everyNTurns;
   settings.retainMode = "chunked";
+  settings.retainOverlapTurns = retainConfig.overlapTurns;
   settings.recallMaxMemories = 8;
   settings.recallMinOverlap = 0.1;
   settings.recallTypes = ["world", "experience", "observation"];
   settings.recallSkipTrivial = true;
+  settings.directiveCaptureNudge = true;
   if (additionalBanks.length > 0) {
     settings.recallAdditionalBanks = [...additionalBanks];
   }
   return JSON.stringify(settings, null, 2) + `
 `;
 }
+function resolvePermissionDefaultMode(agentConfig, switchroomConfig) {
+  const raw = agentConfig.permission_mode ?? switchroomConfig?.defaults?.permission_mode ?? SWITCHROOM_DEFAULT_PERMISSION_MODE;
+  if (VALID_SETTINGS_DEFAULT_MODES.includes(raw)) {
+    return raw;
+  }
+  console.warn(source_default.yellow(`[switchroom] permission_mode "${raw}" has no settings.json defaultMode ` + `equivalent \u2014 using "${SWITCHROOM_DEFAULT_PERMISSION_MODE}" for ` + `permissions.defaultMode (the --permission-mode CLI flag still carries "${raw}").`));
+  return SWITCHROOM_DEFAULT_PERMISSION_MODE;
+}
 function buildWorkspaceContext(args) {
   const {
     name,
     agentDir,
     agentConfig,
     telegramConfig,
+    switchroomConfig,
     switchroomConfigPath,
     topicId,
     tools,
     permissionAllow,
-    hasAllWildcard,
     resolvedBotToken,
     rawBotToken,
     hindsightAutoRecallEnabled,
@@ -25838,6 +26831,7 @@ function buildWorkspaceContext(args) {
     hindsightRecallMinOverlap,
     hindsightRecallTypes,
     hindsightRecallSkipTrivial,
+    hindsightDirectiveCaptureNudge,
     hindsightTopicAliasesJson,
     hindsightSenderBanksJson,
     hindsightTopicFilterMode
@@ -25859,7 +26853,7 @@ function buildWorkspaceContext(args) {
       ...INTERACTIVE_TUI_FLEET_DENY_TOOLS
     ]),
     permissionAllow,
-    defaultModeAcceptEdits: hasAllWildcard,
+    defaultMode: resolvePermissionDefaultMode(agentConfig, switchroomConfig),
     memory: agentConfig.memory,
     model: agentConfig.model,
     mcpServers: agentConfig.mcp_servers ? filterMcpServers(agentConfig.mcp_servers) : agentConfig.mcp_servers,
@@ -25882,6 +26876,7 @@ function buildWorkspaceContext(args) {
     hindsightRecallMinOverlap,
     hindsightRecallTypes,
     hindsightRecallSkipTrivial,
+    hindsightDirectiveCaptureNudge,
     hindsightTopicAliasesJsonQ: hindsightTopicAliasesJson ? shellSingleQuote(hindsightTopicAliasesJson) : undefined,
     hindsightSenderBanksJsonQ: hindsightSenderBanksJson ? shellSingleQuote(hindsightSenderBanksJson) : undefined,
     hindsightTopicFilterMode,
@@ -26052,12 +27047,13 @@ function scaffoldAgent(name, agentConfigRaw, agentsDir, telegramConfig, switchro
   ]);
   const hindsightAutoRecallEnabled = hindsightEnabled && agentConfig.memory?.auto_recall !== false;
   const hindsightBankId = agentConfig.memory?.collection ?? name;
-  const hindsightApiBaseUrl = switchroomConfig?.memory?.config?.url ? switchroomConfig.memory.config.url.replace(/\/mcp\/?$/, "").replace(/\/$/, "") : "http://127.0.0.1:8888";
+  const hindsightApiBaseUrl = switchroomConfig?.memory?.config?.url ? switchroomConfig.memory.config.url.replace(/\/mcp\/?$/, "").replace(/\/$/, "") : HINDSIGHT_DEFAULT_API_BASE_URL;
   const hindsightRecallMaxMemories = agentConfig.memory?.recall?.max_memories;
   const hindsightRecallCacheTtlSecs = agentConfig.memory?.recall?.cache_ttl_secs;
   const hindsightRecallMinOverlap = agentConfig.memory?.recall?.min_overlap;
   const hindsightRecallTypes = agentConfig.memory?.recall?.types?.length ? agentConfig.memory.recall.types.join(",") : undefined;
   const hindsightRecallSkipTrivial = agentConfig.memory?.recall?.skip_trivial === undefined ? undefined : String(agentConfig.memory.recall.skip_trivial);
+  const hindsightDirectiveCaptureNudge = agentConfig.memory?.directive_capture_nudge === undefined ? undefined : String(agentConfig.memory.directive_capture_nudge);
   const topicAliases = agentConfig.channels?.telegram?.topic_aliases;
   const hindsightTopicAliasesJson = topicAliases && Object.keys(topicAliases).length > 0 ? JSON.stringify(topicAliases) : undefined;
   const senderBanks = switchroomConfig ? resolveUsers(switchroomConfig, name).senderBanks : agentConfig.memory?.recall?.sender_banks ?? {};
@@ -26084,6 +27080,7 @@ function scaffoldAgent(name, agentConfigRaw, agentsDir, telegramConfig, switchro
     hindsightRecallMinOverlap,
     hindsightRecallTypes,
     hindsightRecallSkipTrivial,
+    hindsightDirectiveCaptureNudge,
     hindsightTopicAliasesJson,
     hindsightSenderBanksJson,
     hindsightTopicFilterMode
@@ -26452,12 +27449,12 @@ ${body}
         if (target === "workspace/SOUL.md") {
           skipped.push(agentSoulPath);
         } else {
-          rmSync3(agentSoulPath);
+          rmSync4(agentSoulPath);
           symlinkSync2("workspace/SOUL.md", agentSoulPath);
           created.push(agentSoulPath);
         }
       } else {
-        rmSync3(agentSoulPath);
+        rmSync4(agentSoulPath);
         symlinkSync2("workspace/SOUL.md", agentSoulPath);
         created.push(agentSoulPath);
       }
@@ -26490,8 +27487,10 @@ ${body}
       const userBankMission = agentConfig.memory?.bank_mission;
       const userRetainMission = agentConfig.memory?.retain_mission;
       const seededRetainMission = userRetainMission ?? DEFAULT_RETAIN_MISSION;
+      const extras = resolveBankMissionExtras(agentConfig.memory, agentConfig.extends ?? DEFAULT_PROFILE);
       const missions = {
-        retain_mission: seededRetainMission
+        retain_mission: seededRetainMission,
+        ...extras
       };
       if (userBankMission) {
         missions.bank_mission = userBankMission;
@@ -26506,6 +27505,17 @@ ${body}
       }).catch((err) => {
         console.warn(`  ${source_default.yellow("\u26a0")} Bank mission update error for ${formatAgentBankLabel(name, hindsightBankId)}: ${err}`);
       });
+      ensureDeclaredMentalModels(apiUrl, hindsightBankId, agentConfig.memory?.mental_models, { timeoutMs: 5000 }).then((outcomes) => {
+        for (const o of outcomes) {
+          if (o.ok) {
+            console.log(`  ${source_default.green("\u2713")} Mental model "${o.name}" ready for ${formatAgentBankLabel(name, hindsightBankId)}`);
+          } else {
+            console.warn(`  ${source_default.yellow("\u26a0")} Failed to ensure mental model "${o.name}" for ${formatAgentBankLabel(name, hindsightBankId)}: ${o.reason}`);
+          }
+        }
+      }).catch((err) => {
+        console.warn(`  ${source_default.yellow("\u26a0")} Mental model ensure error for ${formatAgentBankLabel(name, hindsightBankId)}: ${err}`);
+      });
     });
   }
   for (const f of rewrittenWithBackup) {
@@ -26759,7 +27769,7 @@ function buildSettingsHooksBlock(p) {
       hooks: [
         {
           type: "command",
-          command: wrap("hook:workspace-dynamic", `${useInjectOnChange ? `env SWITCHROOM_INJECT_ON_CHANGE=1 ` : ""}bash "${join10(DOCKER_BIN_PATH, "workspace-dynamic-hook.sh")}"`),
+          command: wrap("hook:workspace-dynamic", `${useInjectOnChange ? "" : `env SWITCHROOM_INJECT_ON_CHANGE=0 `}bash "${join10(DOCKER_BIN_PATH, "workspace-dynamic-hook.sh")}"`),
           timeout: 5
         }
       ]
@@ -26884,7 +27894,7 @@ function reconcileAgent(name, agentConfigRaw, agentsDir, telegramConfig, switchr
     mkdirSync10(workspaceDir, { recursive: true });
     const legacyContent = readFileSync13(legacyCustomPath, "utf-8");
     writeFileSync4(newCustomPath, legacyContent, "utf-8");
-    rmSync3(legacyCustomPath);
+    rmSync4(legacyCustomPath);
     console.log(source_default.green(`  moved CLAUDE.custom.md \u2192 workspace/CLAUDE.custom.md`));
   }
   const tools = agentConfig.tools ?? { allow: [], deny: [] };
@@ -26923,12 +27933,13 @@ function reconcileAgent(name, agentConfigRaw, agentsDir, telegramConfig, switchr
   const resolvedBotToken = resolveBotToken(rawBotToken);
   const hindsightAutoRecallEnabled = hindsightEnabled && agentConfig.memory?.auto_recall !== false;
   const hindsightBankId = agentConfig.memory?.collection ?? name;
-  const hindsightApiBaseUrl = switchroomConfig.memory?.config?.url ? switchroomConfig.memory.config.url.replace(/\/mcp\/?$/, "").replace(/\/$/, "") : "http://127.0.0.1:8888";
+  const hindsightApiBaseUrl = switchroomConfig.memory?.config?.url ? switchroomConfig.memory.config.url.replace(/\/mcp\/?$/, "").replace(/\/$/, "") : HINDSIGHT_DEFAULT_API_BASE_URL;
   const hindsightRecallMaxMemories = agentConfig.memory?.recall?.max_memories;
   const hindsightRecallCacheTtlSecs = agentConfig.memory?.recall?.cache_ttl_secs;
   const hindsightRecallMinOverlap = agentConfig.memory?.recall?.min_overlap;
   const hindsightRecallTypes = agentConfig.memory?.recall?.types?.length ? agentConfig.memory.recall.types.join(",") : undefined;
   const hindsightRecallSkipTrivial = agentConfig.memory?.recall?.skip_trivial === undefined ? undefined : String(agentConfig.memory.recall.skip_trivial);
+  const hindsightDirectiveCaptureNudge = agentConfig.memory?.directive_capture_nudge === undefined ? undefined : String(agentConfig.memory.directive_capture_nudge);
   const topicAliases = agentConfig.channels?.telegram?.topic_aliases;
   const hindsightTopicAliasesJson = topicAliases && Object.keys(topicAliases).length > 0 ? JSON.stringify(topicAliases) : undefined;
   const senderBanks = switchroomConfig ? resolveUsers(switchroomConfig, name).senderBanks : agentConfig.memory?.recall?.sender_banks ?? {};
@@ -26968,6 +27979,7 @@ function reconcileAgent(name, agentConfigRaw, agentsDir, telegramConfig, switchr
       hindsightRecallMinOverlap,
       hindsightRecallTypes,
       hindsightRecallSkipTrivial,
+      hindsightDirectiveCaptureNudge,
       hindsightTopicAliasesJsonQ: hindsightTopicAliasesJson ? shellSingleQuote(hindsightTopicAliasesJson) : undefined,
       hindsightSenderBanksJsonQ: hindsightSenderBanksJson ? shellSingleQuote(hindsightSenderBanksJson) : undefined,
       hindsightTopicFilterMode,
@@ -27107,11 +28119,7 @@ ${baseAppend}` : TELEGRAM_FORMATTING_FLOOR_CARD;
     settings.permissions = settings.permissions ?? {};
     settings.permissions.allow = desiredAllow;
     settings.permissions.deny = desiredDeny;
-    if (hasAllWildcard) {
-      settings.permissions.defaultMode = "acceptEdits";
-    } else {
-      delete settings.permissions.defaultMode;
-    }
+    settings.permissions.defaultMode = resolvePermissionDefaultMode(agentConfig, switchroomConfig);
     const mcpServers = {};
     const hindsightEntry = getHindsightSettingsEntry(name, switchroomConfig);
     if (hindsightEntry) {
@@ -27369,6 +28377,7 @@ ${body}
       hindsightRecallMinOverlap,
       hindsightRecallTypes,
       hindsightRecallSkipTrivial,
+      hindsightDirectiveCaptureNudge,
       hindsightTopicAliasesJson,
       hindsightSenderBanksJson,
       hindsightTopicFilterMode
@@ -27397,12 +28406,12 @@ ${body}
       if (stat.isSymbolicLink()) {
         const target = readlinkSync4(agentSoulPath);
         if (target !== "workspace/SOUL.md") {
-          rmSync3(agentSoulPath);
+          rmSync4(agentSoulPath);
           symlinkSync2("workspace/SOUL.md", agentSoulPath);
           changes.push(agentSoulPath);
         }
       } else {
-        rmSync3(agentSoulPath);
+        rmSync4(agentSoulPath);
         symlinkSync2("workspace/SOUL.md", agentSoulPath);
         changes.push(agentSoulPath);
       }
@@ -27446,14 +28455,15 @@ ${body}
     bankOpsChain.then((bankReady) => {
       if (!bankReady)
         return;
-      if (agentConfig.memory?.bank_mission || agentConfig.memory?.retain_mission) {
-        const missions = {};
-        if (agentConfig.memory?.bank_mission) {
-          missions.bank_mission = agentConfig.memory.bank_mission;
-        }
-        if (agentConfig.memory?.retain_mission) {
-          missions.retain_mission = agentConfig.memory.retain_mission;
-        }
+      const extras = resolveBankMissionExtras(agentConfig.memory, agentConfig.extends ?? DEFAULT_PROFILE);
+      const missions = { ...extras };
+      if (agentConfig.memory?.bank_mission) {
+        missions.bank_mission = agentConfig.memory.bank_mission;
+      }
+      if (agentConfig.memory?.retain_mission) {
+        missions.retain_mission = agentConfig.memory.retain_mission;
+      }
+      if (Object.keys(missions).length > 0) {
         updateBankMissions(apiUrl, hindsightBankId, missions, { timeoutMs: 5000 }).then((result) => {
           if (result.ok) {
             console.log(`  ${source_default.green("\u2713")} Bank missions updated for ${formatAgentBankLabel(name, hindsightBankId)}`);
@@ -27464,6 +28474,17 @@ ${body}
           console.warn(`  ${source_default.yellow("\u26a0")} Bank mission update error for ${formatAgentBankLabel(name, hindsightBankId)}: ${err}`);
         });
       }
+      ensureDeclaredMentalModels(apiUrl, hindsightBankId, agentConfig.memory?.mental_models, { timeoutMs: 5000 }).then((outcomes) => {
+        for (const o of outcomes) {
+          if (o.ok) {
+            console.log(`  ${source_default.green("\u2713")} Mental model "${o.name}" ready for ${formatAgentBankLabel(name, hindsightBankId)}`);
+          } else {
+            console.warn(`  ${source_default.yellow("\u26a0")} Failed to ensure mental model "${o.name}" for ${formatAgentBankLabel(name, hindsightBankId)}: ${o.reason}`);
+          }
+        }
+      }).catch((err) => {
+        console.warn(`  ${source_default.yellow("\u26a0")} Mental model ensure error for ${formatAgentBankLabel(name, hindsightBankId)}: ${err}`);
+      });
     });
   }
   return {
@@ -27558,7 +28579,7 @@ function reconcileConfiguredGroup(accessPath, agentConfig, telegramConfig) {
   const tmp = accessPath + ".tmp";
   writeFileSync4(tmp, JSON.stringify(access, null, 2) + `
 `, { mode: 384 });
-  renameSync3(tmp, accessPath);
+  renameSync4(tmp, accessPath);
   console.log(source_default.green(`  registered supergroup ${forumChatId} in access.json ` + `(responds to all topics; requireMention=false)`));
 }
 function buildAccessJson2(agentConfig, telegramConfig, resolvedTopicId, userId) {
@@ -27902,7 +28923,7 @@ in doubt, shorter and plainer wins.
 
 Every turn that answers a user message ends with a user-visible \`reply\`
 \u2014 Telegram is all the user sees; your terminal output
-never reaches them.`, SWITCHROOM_TELEGRAM_MCP_TOOLS, HINDSIGHT_MCP_TOOLS, AGENT_CONFIG_MCP_TOOLS, HOSTD_MCP_TOOLS, WEBKITE_MCP_TOOLS, LEGACY_SWITCHROOM_MCP_TOKENS, LEGACY_HOSTD_BLANKET_TOKENS, DEFAULT_READ_ONLY_PREAPPROVED_TOOLS, WEBKITE_FLEET_DENY_TOOLS, INTERACTIVE_TUI_FLEET_DENY_TOOLS, WEBKITE_BINARY_CONTAINER_PATH = "/usr/local/bin/webkite", SWITCHROOM_DEFAULT_MAIN_MODEL = "claude-sonnet-5", SWITCHROOM_DEFAULT_THINKING_EFFORT = "low", SWITCHROOM_OWNED_SETTINGS_KEYS, ALL_BUILTIN_TOOLS, DOCKER_TELEGRAM_PLUGIN_PATH = "/opt/switchroom/telegram-plugin", DOCKER_HOOKS_PATH, DOCKER_BUNDLED_HOOKS_PATH = "/opt/switchroom/hooks", DOCKER_BIN_PATH = "/opt/switchroom/bin", DOCKER_SECURITY_PLUGIN_PATH = "/opt/switchroom/security-plugin", DOCKER_CONFIG_PATH = "/state/config/switchroom.yaml", DOCKER_SWITCHROOM_CLI_PATH = "/usr/local/bin/switchroom", DOCKER_AUTH_BROKER_SOCKET = "/run/switchroom/auth-broker/sock", DOCKER_VAULT_BROKER_SOCKET = "/run/switchroom/broker/sock", DOCKER_AGENT_HOME = "/state/agent/home", INTEGRATION_MCP_RESOLVERS;
+never reaches them.`, SWITCHROOM_TELEGRAM_MCP_TOOLS, HINDSIGHT_MCP_TOOLS, AGENT_CONFIG_MCP_TOOLS, HOSTD_MCP_TOOLS, WEBKITE_MCP_TOOLS, LEGACY_SWITCHROOM_MCP_TOKENS, LEGACY_HOSTD_BLANKET_TOKENS, DEFAULT_READ_ONLY_PREAPPROVED_TOOLS, WEBKITE_FLEET_DENY_TOOLS, INTERACTIVE_TUI_FLEET_DENY_TOOLS, WEBKITE_BINARY_CONTAINER_PATH = "/usr/local/bin/webkite", SWITCHROOM_DEFAULT_MAIN_MODEL = "claude-sonnet-5", SWITCHROOM_DEFAULT_THINKING_EFFORT = "low", SWITCHROOM_OWNED_SETTINGS_KEYS, ALL_BUILTIN_TOOLS, HINDSIGHT_DEFAULT_RETAIN_EVERY_N_TURNS = 3, HINDSIGHT_DEFAULT_RETAIN_OVERLAP_TURNS = 1, VALID_SETTINGS_DEFAULT_MODES, SWITCHROOM_DEFAULT_PERMISSION_MODE = "acceptEdits", DOCKER_TELEGRAM_PLUGIN_PATH = "/opt/switchroom/telegram-plugin", DOCKER_HOOKS_PATH, DOCKER_BUNDLED_HOOKS_PATH = "/opt/switchroom/hooks", DOCKER_BIN_PATH = "/opt/switchroom/bin", DOCKER_SECURITY_PLUGIN_PATH = "/opt/switchroom/security-plugin", DOCKER_CONFIG_PATH = "/state/config/switchroom.yaml", DOCKER_SWITCHROOM_CLI_PATH = "/usr/local/bin/switchroom", DOCKER_AUTH_BROKER_SOCKET = "/run/switchroom/auth-broker/sock", DOCKER_VAULT_BROKER_SOCKET = "/run/switchroom/broker/sock", DOCKER_AGENT_HOME = "/state/agent/home", INTEGRATION_MCP_RESOLVERS;
 var init_scaffold = __esm(() => {
   init_source();
   init_cron_unit_name();
@@ -27916,13 +28937,14 @@ var init_scaffold = __esm(() => {
   init_profiles();
   init_scaffold_integration();
   init_reconcile_default_skills();
-  init_hindsight();
+  init_hindsight2();
   init_state();
   init_paths();
   init_loader();
   init_resolver();
   init_vault();
   init_onboarding();
+  init_hindsight();
   init_bare_clone();
   init_agent_worktree();
   REPO_ROOT = resolve11(import.meta.dirname, "../..");
@@ -27940,8 +28962,31 @@ var init_scaffold = __esm(() => {
     "mcp__switchroom-telegram__progress_update"
   ];
   HINDSIGHT_MCP_TOOLS = [
-    "mcp__hindsight",
-    "mcp__hindsight__*"
+    "mcp__hindsight__recall",
+    "mcp__hindsight__retain",
+    "mcp__hindsight__sync_retain",
+    "mcp__hindsight__reflect",
+    "mcp__hindsight__create_directive",
+    "mcp__hindsight__update_bank",
+    "mcp__hindsight__delete_directive",
+    "mcp__hindsight__list_directives",
+    "mcp__hindsight__create_bank",
+    "mcp__hindsight__get_bank",
+    "mcp__hindsight__get_bank_stats",
+    "mcp__hindsight__list_banks",
+    "mcp__hindsight__delete_bank",
+    "mcp__hindsight__get_memory",
+    "mcp__hindsight__list_memories",
+    "mcp__hindsight__clear_memories",
+    "mcp__hindsight__get_document",
+    "mcp__hindsight__list_documents",
+    "mcp__hindsight__delete_document",
+    "mcp__hindsight__get_mental_model",
+    "mcp__hindsight__list_mental_models",
+    "mcp__hindsight__list_tags",
+    "mcp__hindsight__get_operation",
+    "mcp__hindsight__list_operations",
+    "mcp__hindsight__cancel_operation"
   ];
   AGENT_CONFIG_MCP_TOOLS = [
     "mcp__agent-config",
@@ -27993,6 +29038,12 @@ var init_scaffold = __esm(() => {
     "Agent",
     "ExitPlanMode"
   ];
+  VALID_SETTINGS_DEFAULT_MODES = [
+    "default",
+    "acceptEdits",
+    "plan",
+    "bypassPermissions"
+  ];
   DOCKER_HOOKS_PATH = `${DOCKER_TELEGRAM_PLUGIN_PATH}/hooks`;
   INTEGRATION_MCP_RESOLVERS = [
     {
@@ -28237,6 +29288,7 @@ function describeAgents(config, litellmConfirmedAgents) {
         baseUrl: resolved.litellm?.base_url ?? config.litellm?.base_url,
         smallFastModel: resolved.litellm?.small_fast_model ?? config.litellm?.small_fast_model ?? "claude-haiku-4-5-20251001"
       },
+      model: resolveMainModel(resolved.model),
       timezone: resolveTimezone(config, resolved, {
         onUtcFallback: () => {
           console.warn(`  \u26a0 timezone: no explicit timezone set and server detection resolved to UTC ` + `for agent "${name}" \u2014 cron schedules and the per-turn time hint will ` + `run in UTC. Add \`switchroom.timezone: "Region/City"\` (e.g. ` + `"Australia/Melbourne") to switchroom.yaml to silence this warning.`);
@@ -28669,7 +29721,7 @@ function emitAgentService(lines, a, imageTag, buildMode, buildContext, homePrefi
     const root = a.litellm.baseUrl.replace(/\/+$/, "");
     env2.SWITCHROOM_LITELLM = "1";
     env2.SWITCHROOM_LITELLM_BASE = root;
-    env2.ANTHROPIC_BASE_URL = `${root}/anthropic`;
+    env2.ANTHROPIC_BASE_URL = isClaudeModel(a.model) ? `${root}/anthropic` : root;
     env2.ANTHROPIC_SMALL_FAST_MODEL = a.litellm.smallFastModel;
   }
   env2.SWITCHROOM_VOICE_ENGINE = voiceEngine;
@@ -28767,6 +29819,8 @@ var init_compose = __esm(() => {
   init_schema();
   init_cron_routing();
   init_tier_selector();
+  init_scaffold();
+  init_model_command();
   init_merge();
   init_timezone();
   init_peercred();
@@ -29033,7 +30087,7 @@ function resolveHostHomeForCompose() {
   }
   return homedir6();
 }
-async function writeComposeFile(opts) {
+async function computeComposeContent(opts) {
   const release = resolveRelease({ override: opts.releaseOverride, root: opts.config.release });
   const imageTag = resolveImageTag(release);
   const operatorUid = resolveOperatorUid();
@@ -29057,6 +30111,11 @@ async function writeComposeFile(opts) {
     previous = null;
   }
   const previousImageTag = previous ? AGENT_IMAGE_TAG_RE.exec(previous)?.[1] ?? null : null;
+  return { content, imageTag, previous, previousImageTag };
+}
+async function writeComposeFile(opts) {
+  const { content, imageTag, previous, previousImageTag } = await computeComposeContent(opts);
+  const operatorUid = resolveOperatorUid();
   await mkdir(dirname6(opts.composePath), { recursive: true });
   if (previous !== null) {
     try {
@@ -29089,7 +30148,7 @@ var init_write_compose = __esm(() => {
 });
 
 // src/agents/tmux.ts
-import { execFileSync as execFileSync5 } from "node:child_process";
+import { execFileSync as execFileSync7 } from "node:child_process";
 function sendAgentInterrupt(opts) {
   const { agentName } = opts;
   const attempts = typeof opts.attempts === "number" && opts.attempts > 0 ? opts.attempts : 1;
@@ -29099,7 +30158,7 @@ function sendAgentInterrupt(opts) {
   let lastError = null;
   for (let i = 0;i < attempts; i++) {
     try {
-      execFileSync5("tmux", args, {
+      execFileSync7("tmux", args, {
         timeout: 3000,
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -29140,7 +30199,7 @@ var init_compose_env = () => {};
 import { resolve as resolve13 } from "node:path";
 import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync6 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { execFileSync as execFileSync6 } from "node:child_process";
+import { execFileSync as execFileSync8 } from "node:child_process";
 function resolveSwitchroomHome(explicit) {
   if (explicit && explicit.length > 0)
     return explicit;
@@ -29171,7 +30230,7 @@ function bringUpAgentService(opts) {
   const dockerBin = opts.dockerBin ?? "docker";
   const stdio = opts.stdio ?? "inherit";
   for (const svc of ["vault-broker", "approval-kernel", "switchroom-auth-broker"]) {
-    execFileSync6(dockerBin, [
+    execFileSync8(dockerBin, [
       "compose",
       "-f",
       composePath,
@@ -29183,7 +30242,7 @@ function bringUpAgentService(opts) {
       svc
     ], { stdio });
   }
-  execFileSync6(dockerBin, [
+  execFileSync8(dockerBin, [
     "compose",
     "-f",
     composePath,
@@ -29202,7 +30261,7 @@ var init_docker_fleet = __esm(() => {
 });
 
 // src/agents/singleton-reconcile.ts
-import { execFileSync as execFileSync7 } from "node:child_process";
+import { execFileSync as execFileSync9 } from "node:child_process";
 import { readFileSync as readFileSync16 } from "node:fs";
 function resolveSingletonServices(voiceEngine) {
   const engine = voiceEngine ?? loadHostCapabilities()?.voice.engine ?? "cloud";
@@ -29228,7 +30287,7 @@ function readPinnedSingletonImages(composeText, services = SINGLETON_SERVICES) {
 }
 function defaultInspectImage(dockerBin, container) {
   try {
-    const out = execFileSync7(dockerBin, ["inspect", "-f", "{{.Config.Image}}", container], { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], timeout: 5000 }).trim();
+    const out = execFileSync9(dockerBin, ["inspect", "-f", "{{.Config.Image}}", container], { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], timeout: 5000 }).trim();
     return out.length > 0 ? out : null;
   } catch {
     return null;
@@ -29254,7 +30313,7 @@ function detectSingletonDrift(deps) {
   });
 }
 function defaultRecreate(dockerBin, project, composeFile, service) {
-  execFileSync7(dockerBin, ["compose", "-p", project, "-f", composeFile, ...composeEnvFileArgs(composeFile), "up", "-d", "--no-deps", service], { stdio: ["ignore", "pipe", "pipe"], timeout: 120000 });
+  execFileSync9(dockerBin, ["compose", "-p", project, "-f", composeFile, ...composeEnvFileArgs(composeFile), "up", "-d", "--no-deps", service], { stdio: ["ignore", "pipe", "pipe"], timeout: 120000 });
 }
 function reconcileSingletons(deps) {
   const dockerBin = deps.dockerBin ?? "docker";
@@ -29297,8 +30356,8 @@ var init_singleton_reconcile = __esm(() => {
 });
 
 // src/agents/lifecycle.ts
-import { execFileSync as execFileSync8, spawn, spawnSync } from "node:child_process";
-import { existsSync as existsSync20, mkdirSync as mkdirSync14, writeFileSync as writeFileSync7, renameSync as renameSync4, readFileSync as readFileSync17 } from "node:fs";
+import { execFileSync as execFileSync10, spawn, spawnSync } from "node:child_process";
+import { existsSync as existsSync20, mkdirSync as mkdirSync14, writeFileSync as writeFileSync7, renameSync as renameSync5, readFileSync as readFileSync17 } from "node:fs";
 import { resolve as resolve14, join as join14 } from "node:path";
 import { connect } from "node:net";
 function cleanShutdownMarkerPathForAgent(name) {
@@ -29320,7 +30379,7 @@ function writeRestartReasonMarker(name, reason, opts = {}) {
     const marker = { ts: Date.now(), signal: "SIGTERM", reason };
     const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
     writeFileSync7(tmp, JSON.stringify(marker), "utf-8");
-    renameSync4(tmp, path);
+    renameSync5(tmp, path);
   } catch {}
 }
 function buildCliRestartReason(opts) {
@@ -29328,7 +30387,7 @@ function buildCliRestartReason(opts) {
   if (!buildCommit)
     return "cli: restart";
   try {
-    const head = execFileSync8("git", ["rev-parse", "HEAD"], {
+    const head = execFileSync10("git", ["rev-parse", "HEAD"], {
       cwd: cwd ?? process.cwd(),
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -29339,7 +30398,7 @@ function buildCliRestartReason(opts) {
       return "cli: restart";
     let subject = "";
     try {
-      subject = execFileSync8("git", ["log", "-1", "--pretty=%s", head], {
+      subject = execFileSync10("git", ["log", "-1", "--pretty=%s", head], {
         cwd: cwd ?? process.cwd(),
         encoding: "utf-8",
         stdio: ["ignore", "pipe", "ignore"]
@@ -29369,7 +30428,7 @@ function reconcileSingletonImages(log) {
 }
 function dockerSync(args) {
   try {
-    return execFileSync8("docker", args, {
+    return execFileSync10("docker", args, {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
     }).trim();
@@ -29758,12 +30817,12 @@ var init_lifecycle = __esm(() => {
 });
 
 // src/auth/pane-ready-probe.ts
-import { execFileSync as execFileSync10 } from "node:child_process";
+import { execFileSync as execFileSync12 } from "node:child_process";
 function defaultPaneReadyDeps() {
   return {
     capturePane(sessionName) {
       try {
-        return execFileSync10("tmux", ["capture-pane", "-p", "-t", sessionName, "-S", "-200"], {
+        return execFileSync12("tmux", ["capture-pane", "-p", "-t", sessionName, "-S", "-200"], {
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
         }).trim();
@@ -29805,12 +30864,12 @@ import {
   mkdirSync as mkdirSync16,
   readFileSync as readFileSync21,
   readdirSync as readdirSync10,
-  renameSync as renameSync6,
-  rmSync as rmSync4,
+  renameSync as renameSync7,
+  rmSync as rmSync5,
   statSync as statSync12,
   writeFileSync as writeFileSync9
 } from "node:fs";
-import { randomBytes as randomBytes2 } from "node:crypto";
+import { randomBytes as randomBytes3 } from "node:crypto";
 import { join as join17 } from "node:path";
 function claudeDir(agentDir) {
   return join17(agentDir, ".claude");
@@ -29944,13 +31003,13 @@ function syncLegacyFromActive(agentDir) {
 }
 function atomicCopy(src, dest, mode) {
   const contents = readFileSync21(src);
-  const tmp = `${dest}.tmp-${process.pid}-${randomBytes2(4).toString("hex")}`;
+  const tmp = `${dest}.tmp-${process.pid}-${randomBytes3(4).toString("hex")}`;
   try {
     writeFileSync9(tmp, contents, { mode });
-    renameSync6(tmp, dest);
+    renameSync7(tmp, dest);
   } catch (err) {
     try {
-      rmSync4(tmp);
+      rmSync5(tmp);
     } catch {}
     throw err;
   }
@@ -30044,7 +31103,7 @@ var init_accounts = __esm(() => {
 });
 
 // src/auth/manager.ts
-import { execFileSync as execFileSync11 } from "node:child_process";
+import { execFileSync as execFileSync13 } from "node:child_process";
 import {
   readFileSync as readFileSync22,
   readdirSync as readdirSync11,
@@ -30052,7 +31111,7 @@ import {
   writeFileSync as writeFileSync10,
   mkdirSync as mkdirSync17,
   mkdtempSync as mkdtempSync2,
-  rmSync as rmSync5,
+  rmSync as rmSync6,
   chmodSync as chmodSync3,
   statSync as statSync13
 } from "node:fs";
@@ -30095,14 +31154,14 @@ function authSessionName(name, slot) {
   return `${base}-${slot.replace(/[^a-zA-Z0-9_.-]/g, "-")}`;
 }
 function tmux(args) {
-  return execFileSync11("tmux", args, {
+  return execFileSync13("tmux", args, {
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
   }).trim();
 }
 function tmuxSessionExists(sessionName) {
   try {
-    execFileSync11("tmux", ["has-session", "-t", sessionName], {
+    execFileSync13("tmux", ["has-session", "-t", sessionName], {
       stdio: ["pipe", "pipe", "pipe"]
     });
     return true;
@@ -30180,7 +31239,7 @@ function writeAuthSessionMeta(agentDir, meta) {
   });
 }
 function clearAuthSessionMeta(agentDir) {
-  rmSync5(authSessionMetaPath(agentDir), { force: true });
+  rmSync6(authSessionMetaPath(agentDir), { force: true });
 }
 function isSessionStale(agentDir, sessionName) {
   const meta = readJsonFile(authSessionMetaPath(agentDir));
@@ -30206,7 +31265,7 @@ function cleanupAuthTempDirs(agentDir) {
   try {
     for (const entry of readdirSync11(dir)) {
       if (entry.startsWith(".setup-token-tmp-")) {
-        rmSync5(join18(dir, entry), { recursive: true, force: true });
+        rmSync6(join18(dir, entry), { recursive: true, force: true });
       }
     }
   } catch {}
@@ -30364,7 +31423,7 @@ function startAuthSession(name, agentDir, opts = {}) {
   mkdirSync17(claudeDir2(agentDir), { recursive: true });
   cleanupAuthTempDirs(agentDir);
   const logPath = authLogPath(agentDir);
-  rmSync5(logPath, { force: true });
+  rmSync6(logPath, { force: true });
   let configDir;
   if (opts.force) {
     configDir = mkdtempSync2(join18(claudeDir2(agentDir), ".setup-token-tmp-"));
@@ -30384,589 +31443,240 @@ function startAuthSession(name, agentDir, opts = {}) {
   }
   commandParts.push(`export CLAUDE_CONFIG_DIR BROWSER`);
   commandParts.push(`claude setup-token | tee -- "$LOG_PATH"`);
-  const command = commandParts.join(" && ");
-  tmux(["new-session", "-d", "-s", sessionName, "-c", agentDir, `bash -lc ${shellQuote(command)}`]);
-  sleepMs(8000);
-  const output = captureTmuxPane(sessionName);
-  const loginUrl = parseSetupTokenUrl(output) ?? undefined;
-  const initialCodeChallenge = loginUrl ? extractCodeChallenge(loginUrl) ?? undefined : undefined;
-  writeAuthSessionMeta(agentDir, {
-    sessionName,
-    logPath,
-    startedAt: Date.now(),
-    slot: slotArg,
-    initialCodeChallenge,
-    configDir,
-    credentialsMtimeAtStart
-  });
-  return {
-    sessionName,
-    loginUrl,
-    instructions: [
-      `Started Claude auth for agent "${name}" in tmux session ${sessionName}.`,
-      ...loginUrl ? [`Open this URL in your browser:`, loginUrl, ""] : [
-        `Use 'tmux attach -t ${sessionName}' if you need to inspect the auth prompt.`,
-        ""
-      ],
-      `After Claude shows you a browser code, finish with:`,
-      `  switchroom auth code ${name} <browser-code>`,
-      `Cancel with: switchroom auth cancel ${name}`
-    ]
-  };
-}
-function readTokenFromLogFile(logPath) {
-  if (!existsSync25(logPath))
-    return null;
-  try {
-    const content = readFileSync22(logPath, "utf-8");
-    return parseSetupTokenValue(content);
-  } catch {
-    return null;
-  }
-}
-function submitAuthCode(name, agentDir, code, slot, _opts = {}) {
-  const pollIntervalMs = _opts.pollIntervalMs ?? 500;
-  const envTimeout = process.env.SWITCHROOM_AUTH_CODE_TIMEOUT_MS ? parseInt(process.env.SWITCHROOM_AUTH_CODE_TIMEOUT_MS, 10) : NaN;
-  const pollTimeoutMs = _opts.pollTimeoutMs ?? (Number.isFinite(envTimeout) && envTimeout > 0 ? envTimeout : 120000);
-  let targetSlot = slot;
-  if (!targetSlot) {
-    const pending = readJsonFile(authSessionMetaPath(agentDir));
-    if (pending?.slot)
-      targetSlot = pending.slot;
-  }
-  const sessionName = authSessionName(name, targetSlot);
-  if (!tmuxSessionExists(sessionName)) {
-    return {
-      completed: false,
-      tokenSaved: false,
-      instructions: [
-        `No pending auth session for agent "${name}".`,
-        `Start one with: switchroom auth add ${name}`
-      ]
-    };
-  }
-  const paneReadyResult = probeForCodePrompt(sessionName);
-  if (!paneReadyResult.ready) {
-    clearAuthSessionMeta(agentDir);
-    const outcome2 = { kind: "pane-not-ready" };
-    return {
-      completed: false,
-      tokenSaved: false,
-      outcome: outcome2,
-      instructions: [
-        `Auth pane for agent "${name}" is not ready (prompt not visible yet).`,
-        paneReadyResult.reason === "session-gone" ? `The tmux session disappeared \u2014 start a new auth with: switchroom auth reauth ${name}` : `Retry in a moment with: switchroom auth code ${name} <browser-code>`
-      ]
-    };
-  }
-  tmux(["send-keys", "-l", "-t", sessionName, code.trim()]);
-  tmux(["send-keys", "-t", sessionName, "Enter"]);
-  const meta = readJsonFile(authSessionMetaPath(agentDir));
-  const credFileToWatch = meta?.configDir ? join18(meta.configDir, ".credentials.json") : credentialsPath(agentDir);
-  const credsMtimeSnapshot = meta?.credentialsMtimeAtStart ?? 0;
-  const logPath = authLogPath(agentDir);
-  let token = null;
-  const deadline = Date.now() + pollTimeoutMs;
-  while (Date.now() < deadline) {
-    sleepMs(pollIntervalMs);
-    const credsMtime = fileMtimeMs(credFileToWatch);
-    if (credsMtime > credsMtimeSnapshot) {
-      token = readTokenFromCredentialsFile(credFileToWatch);
-      if (token)
-        break;
-    }
-    token = readTokenFromLogFile(logPath);
-    if (token)
-      break;
-  }
-  if (!token) {
-    const paneOutput = captureTmuxPane(sessionName);
-    token = parseSetupTokenValue(paneOutput);
-  }
-  if (!token) {
-    let paneTailText;
-    try {
-      const paneText = captureTmuxPane(sessionName);
-      const lastNonEmpty = paneText.split(`
-`).map((l) => l.trim()).filter(Boolean).at(-1);
-      if (lastNonEmpty)
-        paneTailText = lastNonEmpty;
-    } catch {}
-    const tailLower = paneTailText?.toLowerCase() ?? "";
-    let outcomeKind = "timeout";
-    if (/invalid.*code|code.*invalid/i.test(tailLower)) {
-      outcomeKind = "invalid-code";
-    } else if (/expired.*code|code.*expired/i.test(tailLower)) {
-      outcomeKind = "expired-code";
-    }
-    clearAuthSessionMeta(agentDir);
-    const outcome2 = { kind: outcomeKind, paneTailText };
-    return {
-      completed: false,
-      tokenSaved: false,
-      outcome: outcome2,
-      instructions: [
-        `Submitted code to Claude for agent "${name}", but no token was found after ${Math.round(pollTimeoutMs / 1000)}s.`,
-        ...paneTailText ? [`Pane output: ${paneTailText}`] : [],
-        `If the code was invalid, Claude will say so in the auth session.`,
-        `Inspect with: tmux attach -t ${sessionName}`,
-        `Retry with:   switchroom auth code ${name} <browser-code>`
-      ]
-    };
-  }
-  const tokenPath = writeOAuthToken(agentDir, token, targetSlot);
-  try {
-    tmux(["kill-session", "-t", sessionName]);
-  } catch {}
-  clearAuthSessionMeta(agentDir);
-  cleanupAuthTempDirs(agentDir);
-  rmSync5(authLogPath(agentDir), { force: true });
-  rmSync5(credentialsPath(agentDir), { force: true });
-  const outcome = { kind: "success" };
-  return {
-    completed: true,
-    tokenSaved: true,
-    tokenPath,
-    outcome,
-    instructions: [
-      `Saved Claude OAuth token for agent "${name}".`,
-      `  Token file: ${tokenPath}`,
-      `Restart the agent to pick up the new account, or let switchroom do it now.`
-    ]
-  };
-}
-function cancelAuthSession(name, agentDir, slot) {
-  let targetSlot = slot;
-  if (!targetSlot) {
-    const pending = readJsonFile(authSessionMetaPath(agentDir));
-    if (pending?.slot)
-      targetSlot = pending.slot;
-  }
-  const sessionName = authSessionName(name, targetSlot);
-  if (tmuxSessionExists(sessionName)) {
-    tmux(["kill-session", "-t", sessionName]);
-  }
-  clearAuthSessionMeta(agentDir);
-  cleanupAuthTempDirs(agentDir);
-  return {
-    instructions: [`Cancelled pending auth session for agent "${name}".`]
-  };
-}
-var TOKEN_VALIDITY_MS;
-var init_manager = __esm(() => {
-  init_loader();
-  init_pane_ready_probe();
-  init_accounts();
-  TOKEN_VALIDITY_MS = 365 * 24 * 60 * 60000;
-});
-
-// src/agents/quarantine.ts
-import {
-  existsSync as existsSync30,
-  mkdirSync as mkdirSync18,
-  readFileSync as readFileSync24,
-  unlinkSync as unlinkSync6,
-  writeFileSync as writeFileSync12
-} from "node:fs";
-import { join as join20 } from "node:path";
-function quarantineMarkerPath(telegramStateDir) {
-  return join20(telegramStateDir, QUARANTINE_FILENAME);
-}
-function readQuarantineMarker(telegramStateDir) {
-  const path = quarantineMarkerPath(telegramStateDir);
-  if (!existsSync30(path))
-    return null;
-  try {
-    const raw = readFileSync24(path, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object")
-      return null;
-    const m = parsed;
-    if (m.v !== 1)
-      return null;
-    if (typeof m.reason !== "string")
-      return null;
-    if (typeof m.ts !== "number")
-      return null;
-    return {
-      v: 1,
-      reason: m.reason,
-      ts: m.ts,
-      detail: typeof m.detail === "string" ? m.detail : undefined
-    };
-  } catch {
-    return null;
-  }
-}
-function clearQuarantineMarker(telegramStateDir) {
-  const path = quarantineMarkerPath(telegramStateDir);
-  if (!existsSync30(path))
-    return false;
-  try {
-    unlinkSync6(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function hostTelegramStateDir(agentsDir, name) {
-  return join20(agentsDir, name, "telegram");
-}
-function readQuarantineMarkerForAgent(agentsDir, name) {
-  return readQuarantineMarker(hostTelegramStateDir(agentsDir, name));
-}
-var QUARANTINE_FILENAME = "quarantine.json";
-var init_quarantine = () => {};
-
-// src/agents/pane-lock.ts
-function withPaneLock(key, fn) {
-  const tail = tails.get(key) ?? Promise.resolve();
-  const run = tail.then(() => fn());
-  const next = run.then(() => {}, () => {});
-  tails.set(key, next);
-  next.then(() => {
-    if (tails.get(key) === next)
-      tails.delete(key);
-  });
-  return run;
-}
-var tails;
-var init_pane_lock = __esm(() => {
-  tails = new Map;
-});
-
-// src/agents/inject.ts
-var exports_inject = {};
-__export(exports_inject, {
-  validateInjectCommand: () => validateInjectCommand,
-  normalizeInjectCommand: () => normalizeInjectCommand,
-  makeTmuxRunner: () => makeTmuxRunner,
-  isTuiChromeLine: () => isTuiChromeLine,
-  injectSlashCommandWith: () => injectSlashCommandWith,
-  injectSlashCommand: () => injectSlashCommand,
-  diffPane: () => diffPane,
-  dedupeInjectQueue: () => dedupeInjectQueue,
-  InjectError: () => InjectError,
-  INJECT_COMMANDS: () => INJECT_COMMANDS,
-  INJECT_BLOCKLIST: () => INJECT_BLOCKLIST,
-  INJECT_BLOCKED: () => INJECT_BLOCKED,
-  INJECT_ALLOWLIST: () => INJECT_ALLOWLIST
-});
-import { execFileSync as execFileSync13 } from "node:child_process";
-function validateInjectCommand(command) {
-  if (typeof command !== "string" || command.trim().length === 0) {
-    throw new InjectError("invalid", "command is empty");
-  }
-  const trimmed = command.trim();
-  if (!trimmed.startsWith("/")) {
-    throw new InjectError("invalid", `command must start with "/": got ${trimmed}`);
-  }
-  const bare = trimmed.split(/\s+/, 1)[0].toLowerCase();
-  const blockedMeta = INJECT_BLOCKED.get(bare);
-  if (blockedMeta) {
-    throw new InjectError("blocked", `${bare} is explicitly blocked from inject (${blockedMeta.reason}).`);
-  }
-  if (!INJECT_COMMANDS.has(bare)) {
-    const allowed = [...INJECT_COMMANDS.keys()].sort().join(", ");
-    throw new InjectError("not_allowed", `${bare} is not in the inject allowlist. Allowed: ${allowed}`);
-  }
-  return bare;
-}
-function normalizeInjectCommand(command) {
-  return command.trim().replace(/\s+/g, " ").toLowerCase();
-}
-function dedupeInjectQueue(commands) {
-  const seen = new Set;
-  const out = [];
-  for (const raw of commands) {
-    if (typeof raw !== "string")
-      continue;
-    const key = normalizeInjectCommand(raw);
-    if (key.length === 0)
-      continue;
-    if (seen.has(key))
-      continue;
-    seen.add(key);
-    out.push(raw.trim());
-  }
-  return out;
-}
-function defaultSocketName(agentName) {
-  return `switchroom-${agentName}`;
-}
-function makeTmuxRunner(tmuxBin) {
-  return {
-    capture(socket, session) {
-      try {
-        return execFileSync13(tmuxBin, ["-L", socket, "capture-pane", "-p", "-t", session, "-S", "-200"], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
-      } catch {
-        return null;
-      }
-    },
-    send(socket, session, args) {
-      const [subcmd, ...rest] = args;
-      const flagEnd = rest.findIndex((a) => !a.startsWith("-"));
-      const flagsBeforeKeys = flagEnd === -1 ? rest : rest.slice(0, flagEnd);
-      const keys = flagEnd === -1 ? [] : rest.slice(flagEnd);
-      execFileSync13(tmuxBin, ["-L", socket, subcmd, ...flagsBeforeKeys, "-t", session, ...keys], { stdio: ["pipe", "pipe", "pipe"] });
-    },
-    hasSession(socket, session) {
-      try {
-        execFileSync13(tmuxBin, ["-L", socket, "has-session", "-t", session], {
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-        return true;
-      } catch {
-        return false;
-      }
-    }
-  };
-}
-function sleep2(ms) {
-  return new Promise((res) => setTimeout(res, ms));
-}
-function isTuiChromeLine(line) {
-  const t = line.trim();
-  if (t.length === 0)
-    return false;
-  if (/^[\s\-_\u2502\u2500\u256d\u256e\u2570\u256f\u250c\u2510\u2514\u2518|]+$/.test(t))
-    return true;
-  if (/^[\u256d\u256e\u2570\u256f\u2502\s]*[>)\u276f][\u256d\u256e\u2570\u256f\u2502\s]*$/.test(t))
-    return true;
-  if (/accept edits on/i.test(t))
-    return true;
-  if (/shift\+tab to cycle/i.test(t))
-    return true;
-  if (/for agents/i.test(t))
-    return true;
-  if (/\? for shortcuts/i.test(t))
-    return true;
-  if (/bypassing permissions/i.test(t))
-    return true;
-  if (t === "copy")
-    return true;
-  return false;
-}
-function diffPane(before, after, command) {
-  if (command) {
-    const escaped = command.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const lines = after.split(`
-`);
-    let anchorIdx = -1;
-    for (let i = lines.length - 1;i >= 0; i--) {
-      if (/[\u276f>]\s+/.test(lines[i]) && lines[i].includes(escaped)) {
-        anchorIdx = i;
-        break;
-      }
-    }
-    if (anchorIdx >= 0) {
-      const tail = lines.slice(anchorIdx + 1);
-      const trimmed = [];
-      for (const raw of tail) {
-        const line = raw.trimEnd();
-        if (line.length === 0 && trimmed.length === 0)
-          continue;
-        if (isTuiChromeLine(line))
-          continue;
-        trimmed.push(line);
-      }
-      while (trimmed.length > 0 && trimmed[trimmed.length - 1].length === 0) {
-        trimmed.pop();
-      }
-      const affordances = /^(esc to cancel|press any key|\u21b5 select)/i;
-      while (trimmed.length > 0 && affordances.test(trimmed[trimmed.length - 1].trim())) {
-        trimmed.pop();
-      }
-      if (trimmed.length > 0) {
-        return { output: trimmed.join(`
-`), anchored: true };
-      }
-    }
-  }
-  const beforeSet = new Set(before.split(`
-`).map((l) => l.trimEnd()));
-  const newLines = [];
-  for (const raw of after.split(`
-`)) {
-    const line = raw.trimEnd();
-    if (line.length === 0)
-      continue;
-    if (beforeSet.has(line))
-      continue;
-    if (isTuiChromeLine(line))
-      continue;
-    newLines.push(line);
-  }
-  return { output: newLines.join(`
-`), anchored: false };
-}
-async function injectSlashCommand(agentName, command, opts = {}) {
-  validateInjectCommand(command);
-  const tmuxBin = opts.tmuxBin ?? "tmux";
-  const socket = opts.socketName ?? defaultSocketName(agentName);
-  const session = opts.sessionName ?? agentName;
-  const settleMs = opts.settleMs ?? 2000;
-  const timeoutMs = opts.timeoutMs ?? 5000;
-  return withPaneLock(`${socket}:${session}`, () => injectSlashCommandWith(makeTmuxRunner(tmuxBin), {
-    socket,
-    session,
-    command: command.trim(),
-    settleMs,
-    timeoutMs
-  }));
+  const command = commandParts.join(" && ");
+  tmux(["new-session", "-d", "-s", sessionName, "-c", agentDir, `bash -lc ${shellQuote(command)}`]);
+  sleepMs(8000);
+  const output = captureTmuxPane(sessionName);
+  const loginUrl = parseSetupTokenUrl(output) ?? undefined;
+  const initialCodeChallenge = loginUrl ? extractCodeChallenge(loginUrl) ?? undefined : undefined;
+  writeAuthSessionMeta(agentDir, {
+    sessionName,
+    logPath,
+    startedAt: Date.now(),
+    slot: slotArg,
+    initialCodeChallenge,
+    configDir,
+    credentialsMtimeAtStart
+  });
+  return {
+    sessionName,
+    loginUrl,
+    instructions: [
+      `Started Claude auth for agent "${name}" in tmux session ${sessionName}.`,
+      ...loginUrl ? [`Open this URL in your browser:`, loginUrl, ""] : [
+        `Use 'tmux attach -t ${sessionName}' if you need to inspect the auth prompt.`,
+        ""
+      ],
+      `After Claude shows you a browser code, finish with:`,
+      `  switchroom auth code ${name} <browser-code>`,
+      `Cancel with: switchroom auth cancel ${name}`
+    ]
+  };
 }
-async function injectSlashCommandWith(runner, args) {
-  const { socket, session, command, settleMs, timeoutMs } = args;
-  let bareVerb;
+function readTokenFromLogFile(logPath) {
+  if (!existsSync25(logPath))
+    return null;
   try {
-    bareVerb = validateInjectCommand(command);
-  } catch (err) {
-    if (err instanceof InjectError) {
-      return {
-        outcome: "failed",
-        output: "",
-        truncated: false,
-        command: command.trim().split(/\s+/, 1)[0]?.toLowerCase() ?? "",
-        meta: null,
-        errorCode: err.code,
-        errorMessage: err.message
-      };
-    }
-    throw err;
+    const content = readFileSync22(logPath, "utf-8");
+    return parseSetupTokenValue(content);
+  } catch {
+    return null;
   }
-  const meta = INJECT_COMMANDS.get(bareVerb) ?? null;
-  if (!runner.hasSession(socket, session)) {
+}
+function submitAuthCode(name, agentDir, code, slot, _opts = {}) {
+  const pollIntervalMs = _opts.pollIntervalMs ?? 500;
+  const envTimeout = process.env.SWITCHROOM_AUTH_CODE_TIMEOUT_MS ? parseInt(process.env.SWITCHROOM_AUTH_CODE_TIMEOUT_MS, 10) : NaN;
+  const pollTimeoutMs = _opts.pollTimeoutMs ?? (Number.isFinite(envTimeout) && envTimeout > 0 ? envTimeout : 120000);
+  let targetSlot = slot;
+  if (!targetSlot) {
+    const pending = readJsonFile(authSessionMetaPath(agentDir));
+    if (pending?.slot)
+      targetSlot = pending.slot;
+  }
+  const sessionName = authSessionName(name, targetSlot);
+  if (!tmuxSessionExists(sessionName)) {
     return {
-      outcome: "failed",
-      output: "",
-      truncated: false,
-      command: bareVerb,
-      meta,
-      errorCode: "session_missing",
-      errorMessage: `tmux session "${session}" on socket "${socket}" not found. ` + `Is the agent running under the tmux supervisor (the default)? ` + `If experimental.legacy_pty=true is set, inject is unsupported.`
+      completed: false,
+      tokenSaved: false,
+      instructions: [
+        `No pending auth session for agent "${name}".`,
+        `Start one with: switchroom auth add ${name}`
+      ]
     };
   }
-  const before = runner.capture(socket, session) ?? "";
-  try {
-    runner.send(socket, session, ["send-keys", "-l", command]);
-    runner.send(socket, session, ["send-keys", "Enter"]);
-  } catch (err) {
+  const paneReadyResult = probeForCodePrompt(sessionName);
+  if (!paneReadyResult.ready) {
+    clearAuthSessionMeta(agentDir);
+    const outcome2 = { kind: "pane-not-ready" };
     return {
-      outcome: "failed",
-      output: "",
-      truncated: false,
-      command: bareVerb,
-      meta,
-      errorCode: "tmux_failed",
-      errorMessage: `tmux send-keys failed: ${err instanceof Error ? err.message : String(err)}`
+      completed: false,
+      tokenSaved: false,
+      outcome: outcome2,
+      instructions: [
+        `Auth pane for agent "${name}" is not ready (prompt not visible yet).`,
+        paneReadyResult.reason === "session-gone" ? `The tmux session disappeared \u2014 start a new auth with: switchroom auth reauth ${name}` : `Retry in a moment with: switchroom auth code ${name} <browser-code>`
+      ]
     };
   }
-  const start = Date.now();
-  let last = before;
-  let stableSince = null;
-  while (Date.now() - start < timeoutMs) {
-    await sleep2(POLL_INTERVAL_MS);
-    const cur = runner.capture(socket, session) ?? "";
-    if (cur === last && cur !== before) {
-      if (stableSince === null) {
-        stableSince = Date.now();
-      } else if (Date.now() - stableSince >= POLL_INTERVAL_MS) {
-        last = cur;
+  tmux(["send-keys", "-l", "-t", sessionName, code.trim()]);
+  tmux(["send-keys", "-t", sessionName, "Enter"]);
+  const meta = readJsonFile(authSessionMetaPath(agentDir));
+  const credFileToWatch = meta?.configDir ? join18(meta.configDir, ".credentials.json") : credentialsPath(agentDir);
+  const credsMtimeSnapshot = meta?.credentialsMtimeAtStart ?? 0;
+  const logPath = authLogPath(agentDir);
+  let token = null;
+  const deadline = Date.now() + pollTimeoutMs;
+  while (Date.now() < deadline) {
+    sleepMs(pollIntervalMs);
+    const credsMtime = fileMtimeMs(credFileToWatch);
+    if (credsMtime > credsMtimeSnapshot) {
+      token = readTokenFromCredentialsFile(credFileToWatch);
+      if (token)
         break;
-      }
-    } else {
-      stableSince = null;
     }
-    last = cur;
-    if (Date.now() - start >= settleMs && cur !== before) {
+    token = readTokenFromLogFile(logPath);
+    if (token)
       break;
-    }
   }
-  const { output: rawOutput, anchored } = diffPane(before, last, command);
-  let output = rawOutput;
-  let truncated = false;
-  const bytes = Buffer.byteLength(output, "utf-8");
-  if (bytes > OUTPUT_BYTE_CAP) {
-    while (Buffer.byteLength(output, "utf-8") > OUTPUT_BYTE_CAP) {
-      output = output.slice(Math.floor(output.length * 0.1) + 1);
-    }
-    truncated = true;
+  if (!token) {
+    const paneOutput = captureTmuxPane(sessionName);
+    token = parseSetupTokenValue(paneOutput);
   }
-  if (meta?.dialog) {
+  if (!token) {
+    let paneTailText;
     try {
-      runner.send(socket, session, ["send-keys", "Escape"]);
+      const paneText = captureTmuxPane(sessionName);
+      const lastNonEmpty = paneText.split(`
+`).map((l) => l.trim()).filter(Boolean).at(-1);
+      if (lastNonEmpty)
+        paneTailText = lastNonEmpty;
     } catch {}
-  }
-  if (output.trim().length === 0) {
+    const tailLower = paneTailText?.toLowerCase() ?? "";
+    let outcomeKind = "timeout";
+    if (/invalid.*code|code.*invalid/i.test(tailLower)) {
+      outcomeKind = "invalid-code";
+    } else if (/expired.*code|code.*expired/i.test(tailLower)) {
+      outcomeKind = "expired-code";
+    }
+    clearAuthSessionMeta(agentDir);
+    const outcome2 = { kind: outcomeKind, paneTailText };
     return {
-      outcome: "ok_no_output",
-      output: "",
-      truncated: false,
-      command: bareVerb,
-      meta,
-      ...anchored ? {} : { diagnostic: "anchor_missing" }
+      completed: false,
+      tokenSaved: false,
+      outcome: outcome2,
+      instructions: [
+        `Submitted code to Claude for agent "${name}", but no token was found after ${Math.round(pollTimeoutMs / 1000)}s.`,
+        ...paneTailText ? [`Pane output: ${paneTailText}`] : [],
+        `If the code was invalid, Claude will say so in the auth session.`,
+        `Inspect with: tmux attach -t ${sessionName}`,
+        `Retry with:   switchroom auth code ${name} <browser-code>`
+      ]
     };
   }
+  const tokenPath = writeOAuthToken(agentDir, token, targetSlot);
+  try {
+    tmux(["kill-session", "-t", sessionName]);
+  } catch {}
+  clearAuthSessionMeta(agentDir);
+  cleanupAuthTempDirs(agentDir);
+  rmSync6(authLogPath(agentDir), { force: true });
+  rmSync6(credentialsPath(agentDir), { force: true });
+  const outcome = { kind: "success" };
   return {
-    outcome: "ok",
-    output,
-    truncated,
-    command: bareVerb,
-    meta,
-    ...truncated ? { diagnostic: "truncated_output" } : {}
+    completed: true,
+    tokenSaved: true,
+    tokenPath,
+    outcome,
+    instructions: [
+      `Saved Claude OAuth token for agent "${name}".`,
+      `  Token file: ${tokenPath}`,
+      `Restart the agent to pick up the new account, or let switchroom do it now.`
+    ]
   };
 }
-var INJECT_COMMANDS, INJECT_ALLOWLIST, INJECT_BLOCKED, INJECT_BLOCKLIST, InjectError, POLL_INTERVAL_MS = 150, OUTPUT_BYTE_CAP = 3000;
-var init_inject = __esm(() => {
-  init_pane_lock();
-  INJECT_COMMANDS = new Map([
-    ["/cost", { description: "Show session cost", expectsOutput: true, dialog: true }],
-    ["/status", { description: "Show session status", expectsOutput: true, dialog: true }],
-    ["/usage", { description: "Show plan quota", expectsOutput: true, dialog: true }],
-    ["/hooks", { description: "List configured hooks", expectsOutput: true, dialog: true }],
-    ["/memory", { description: "Open memory picker", expectsOutput: true, dialog: true }],
-    ["/model", { description: "Open model picker", expectsOutput: true }],
-    [
-      "/clear",
-      {
-        description: "Clear session screen",
-        expectsOutput: false,
-        silentNote: "context cleared \u2014 fresh slate"
-      }
-    ],
-    [
-      "/compact",
-      {
-        description: "Compact conversation history",
-        expectsOutput: false,
-        silentNote: "compaction runs silently"
-      }
-    ]
-  ]);
-  INJECT_ALLOWLIST = new Set(INJECT_COMMANDS.keys());
-  INJECT_BLOCKED = new Map([
-    ["/login", { reason: "would mutate auth state" }],
-    ["/logout", { reason: "would terminate the agent's auth session" }],
-    ["/exit", { reason: "would kill the agent process" }],
-    ["/quit", { reason: "would kill the agent process" }],
-    [
-      "/effort",
-      {
-        reason: "leaves a blocking confirmation modal open and wedges the pane; use the /effort command (it drives the modal), not raw inject"
-      }
-    ]
-  ]);
-  INJECT_BLOCKLIST = new Set(INJECT_BLOCKED.keys());
-  InjectError = class InjectError extends Error {
-    code;
-    constructor(code, message) {
-      super(message);
-      this.name = "InjectError";
-      this.code = code;
-    }
+function cancelAuthSession(name, agentDir, slot) {
+  let targetSlot = slot;
+  if (!targetSlot) {
+    const pending = readJsonFile(authSessionMetaPath(agentDir));
+    if (pending?.slot)
+      targetSlot = pending.slot;
+  }
+  const sessionName = authSessionName(name, targetSlot);
+  if (tmuxSessionExists(sessionName)) {
+    tmux(["kill-session", "-t", sessionName]);
+  }
+  clearAuthSessionMeta(agentDir);
+  cleanupAuthTempDirs(agentDir);
+  return {
+    instructions: [`Cancelled pending auth session for agent "${name}".`]
   };
+}
+var TOKEN_VALIDITY_MS;
+var init_manager = __esm(() => {
+  init_loader();
+  init_pane_ready_probe();
+  init_accounts();
+  TOKEN_VALIDITY_MS = 365 * 24 * 60 * 60000;
 });
 
+// src/agents/quarantine.ts
+import {
+  existsSync as existsSync30,
+  mkdirSync as mkdirSync18,
+  readFileSync as readFileSync24,
+  unlinkSync as unlinkSync6,
+  writeFileSync as writeFileSync12
+} from "node:fs";
+import { join as join20 } from "node:path";
+function quarantineMarkerPath(telegramStateDir) {
+  return join20(telegramStateDir, QUARANTINE_FILENAME);
+}
+function readQuarantineMarker(telegramStateDir) {
+  const path = quarantineMarkerPath(telegramStateDir);
+  if (!existsSync30(path))
+    return null;
+  try {
+    const raw = readFileSync24(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object")
+      return null;
+    const m = parsed;
+    if (m.v !== 1)
+      return null;
+    if (typeof m.reason !== "string")
+      return null;
+    if (typeof m.ts !== "number")
+      return null;
+    return {
+      v: 1,
+      reason: m.reason,
+      ts: m.ts,
+      detail: typeof m.detail === "string" ? m.detail : undefined
+    };
+  } catch {
+    return null;
+  }
+}
+function clearQuarantineMarker(telegramStateDir) {
+  const path = quarantineMarkerPath(telegramStateDir);
+  if (!existsSync30(path))
+    return false;
+  try {
+    unlinkSync6(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hostTelegramStateDir(agentsDir, name) {
+  return join20(agentsDir, name, "telegram");
+}
+function readQuarantineMarkerForAgent(agentsDir, name) {
+  return readQuarantineMarker(hostTelegramStateDir(agentsDir, name));
+}
+var QUARANTINE_FILENAME = "quarantine.json";
+var init_quarantine = () => {};
+
 // src/auth/broker/protocol.ts
 function encodeRequest2(req) {
   const line = JSON.stringify(RequestSchema2.parse(req)) + `
@@ -31607,8 +32317,8 @@ import {
   mkdirSync as mkdirSync19,
   readFileSync as readFileSync26,
   readdirSync as readdirSync15,
-  renameSync as renameSync7,
-  rmSync as rmSync10,
+  renameSync as renameSync8,
+  rmSync as rmSync11,
   statSync as statSync16,
   writeFileSync as writeFileSync14
 } from "node:fs";
@@ -31737,73 +32447,6 @@ var init_google_workspace_yaml = __esm(() => {
   import_yaml7 = __toESM(require_dist(), 1);
 });
 
-// src/util/atomic.ts
-var exports_atomic = {};
-__export(exports_atomic, {
-  writeConfigFileSync: () => writeConfigFileSync,
-  atomicWriteJsonSync: () => atomicWriteJsonSync,
-  atomicWriteFileSync: () => atomicWriteFileSync2
-});
-import { randomBytes as randomBytes3 } from "node:crypto";
-import { closeSync as closeSync5, constants, fsyncSync as fsyncSync3, openSync as openSync5, renameSync as renameSync8, rmSync as rmSync11, writeSync as writeSync4 } from "node:fs";
-function atomicWriteFileSync2(destPath, contents, mode = 384) {
-  const tmp = `${destPath}.tmp-${process.pid}-${randomBytes3(4).toString("hex")}`;
-  const buf = typeof contents === "string" ? Buffer.from(contents, "utf-8") : contents;
-  let fd = null;
-  try {
-    fd = openSync5(tmp, TMP_OPEN_FLAGS, mode);
-    writeSync4(fd, buf, 0, buf.length, 0);
-    fsyncSync3(fd);
-    closeSync5(fd);
-    fd = null;
-    renameSync8(tmp, destPath);
-  } catch (err) {
-    if (fd !== null) {
-      try {
-        closeSync5(fd);
-      } catch {}
-    }
-    try {
-      rmSync11(tmp, { force: true });
-    } catch {}
-    throw err;
-  }
-}
-function atomicWriteJsonSync(destPath, value, mode = 384) {
-  atomicWriteFileSync2(destPath, JSON.stringify(value, null, 2) + `
-`, mode);
-}
-function writeConfigFileSync(destPath, contents, mode = 420) {
-  try {
-    atomicWriteFileSync2(destPath, contents, mode);
-  } catch (err) {
-    const code = err.code;
-    if (code !== "EBUSY" && code !== "EXDEV" && code !== "EINVAL") {
-      throw err;
-    }
-    const buf = typeof contents === "string" ? Buffer.from(contents, "utf-8") : contents;
-    let fd = null;
-    try {
-      fd = openSync5(destPath, constants.O_WRONLY | constants.O_TRUNC, mode);
-      writeSync4(fd, buf, 0, buf.length, 0);
-      fsyncSync3(fd);
-      closeSync5(fd);
-      fd = null;
-    } catch (fallbackErr) {
-      if (fd !== null) {
-        try {
-          closeSync5(fd);
-        } catch {}
-      }
-      throw fallbackErr;
-    }
-  }
-}
-var TMP_OPEN_FLAGS;
-var init_atomic = __esm(() => {
-  TMP_OPEN_FLAGS = constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW ?? 0);
-});
-
 // src/drive/oauth.ts
 var exports_oauth = {};
 __export(exports_oauth, {
@@ -33536,7 +34179,7 @@ __export(exports_via_claude, {
   PRE_PASTE_RULES: () => PRE_PASTE_RULES,
   POST_PASTE_RULES: () => POST_PASTE_RULES
 });
-import { execFileSync as execFileSync14, spawnSync as spawnSync3 } from "node:child_process";
+import { execFileSync as execFileSync15, spawnSync as spawnSync3 } from "node:child_process";
 import { existsSync as existsSync34, mkdirSync as mkdirSync20, readFileSync as readFileSync29 } from "node:fs";
 import { join as join26, resolve as resolve24 } from "node:path";
 function tmuxHasSession(session) {
@@ -33547,7 +34190,7 @@ function tmuxHasSession(session) {
 }
 function tmuxKillSession(session) {
   try {
-    execFileSync14("tmux", ["kill-session", "-t", session], {
+    execFileSync15("tmux", ["kill-session", "-t", session], {
       stdio: "ignore",
       timeout: 3000
     });
@@ -33555,7 +34198,7 @@ function tmuxKillSession(session) {
 }
 function tmuxCapturePane(session) {
   try {
-    const out = execFileSync14("tmux", ["capture-pane", "-p", "-t", session, "-S", "-200"], { timeout: 3000, stdio: ["ignore", "pipe", "pipe"], maxBuffer: 4 * 1024 * 1024 });
+    const out = execFileSync15("tmux", ["capture-pane", "-p", "-t", session, "-S", "-200"], { timeout: 3000, stdio: ["ignore", "pipe", "pipe"], maxBuffer: 4 * 1024 * 1024 });
     return out.toString("utf8");
   } catch {
     return "";
@@ -33563,7 +34206,7 @@ function tmuxCapturePane(session) {
 }
 function tmuxSendKeys(session, keys, literal = false) {
   try {
-    execFileSync14("tmux", ["send-keys", "-t", session, ...literal ? ["-l"] : [], ...keys], { timeout: 3000, stdio: ["ignore", "pipe", "pipe"] });
+    execFileSync15("tmux", ["send-keys", "-t", session, ...literal ? ["-l"] : [], ...keys], { timeout: 3000, stdio: ["ignore", "pipe", "pipe"] });
   } catch {}
 }
 function extractAuthorizeUrl(pane) {
@@ -33592,7 +34235,7 @@ async function runViaClaude(opts) {
       tmuxKillSession(SESSION);
   }
   const spawn4 = opts.spawnClaude ?? (() => {
-    execFileSync14("tmux", [
+    execFileSync15("tmux", [
       "new-session",
       "-d",
       "-s",
@@ -39970,6 +40613,30 @@ function classifyShmSize(bytes) {
   const gib = (bytes / 1024 / 1024 / 1024).toFixed(bytes % 1024 ** 3 === 0 ? 0 : 1);
   return { name: "hindsight shm-size", status: "ok", detail: `${gib}g` };
 }
+function classifyConsolidationBacklog(queueDepth, oldestAgeSecs = null) {
+  const ageStr = oldestAgeSecs !== null && oldestAgeSecs > 0 ? `, oldest ${Math.round(oldestAgeSecs / 60)}m old` : "";
+  const base = `${queueDepth} pending consolidation op(s)${ageStr}`;
+  if (queueDepth >= CONSOLIDATION_BACKLOG_FAIL) {
+    return {
+      name: "hindsight consolidation backlog",
+      status: "fail",
+      detail: `${base} \u2014 queue is deep enough to be wedged; retains are landing but ` + `not consolidating into recall (drains ~7 ops/hr under the #2894 throttle)`,
+      fix: "Check `docker logs switchroom-hindsight` for the queue-lag WARNING and " + "consolidation errors (quota/429/shm); restart with `switchroom memory " + "--restart` if the worker is stuck."
+    };
+  }
+  if (queueDepth >= CONSOLIDATION_BACKLOG_WARN) {
+    return {
+      name: "hindsight consolidation backlog",
+      status: "warn",
+      detail: `${base} \u2014 building faster than it drains (~7 ops/hr under the #2894 ` + `throttle); recall may lag recent turns until it catches up`
+    };
+  }
+  return {
+    name: "hindsight consolidation backlog",
+    status: "ok",
+    detail: queueDepth > 0 ? base : "queue drained (0 pending)"
+  };
+}
 function classifyExtractionLogs(logs) {
   const noSpace = /No space left on device|could not resize shared memory/i.test(logs);
   const llmError = /Claude Code returned an error result|claude_code_llm[\s\S]{0,80}error|Fact extraction failed|Content extraction failed/i.test(logs);
@@ -40026,6 +40693,49 @@ function checkHindsightContainerHealth(opts) {
   } catch {}
   return results;
 }
+function classifyHindsightHealthProbe(status, port) {
+  if (status === 200) {
+    return {
+      name: "hindsight /health",
+      status: "ok",
+      detail: `200 at :${port} \u2014 memory backend live`
+    };
+  }
+  if (status === null) {
+    return {
+      name: "hindsight /health",
+      status: "fail",
+      detail: `no response on :${port} \u2014 the container is down or crash-looping ` + `(fleet memory is silently OFF: auto-recall/retain fail with no user error)`,
+      fix: "Check `docker logs switchroom-hindsight` for `[Errno 98] address " + "already in use` (a foreign process on the port) and run " + "`switchroom memory --start` \u2014 the launcher now preflights the port " + "and reassigns instead of crash-looping."
+    };
+  }
+  return {
+    name: "hindsight /health",
+    status: "fail",
+    detail: `HTTP ${status} at :${port} \u2014 memory backend unhealthy`,
+    fix: "Inspect `docker logs switchroom-hindsight`; restart with `switchroom memory --restart`."
+  };
+}
+async function checkHindsightHealthEndpoint(mcpUrl, opts = {}) {
+  const doFetch = opts.fetchImpl ?? fetch;
+  const timeoutMs = opts.timeoutMs ?? 4000;
+  const origin = mcpUrl.replace(/\/mcp\/?$/, "").replace(/\/$/, "");
+  const healthUrl = `${origin}/health`;
+  const port = (() => {
+    const m = origin.match(/:(\d+)(?:$|\/)/);
+    return m ? parseInt(m[1], 10) : 80;
+  })();
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await doFetch(healthUrl, { signal: controller.signal });
+    return classifyHindsightHealthProbe(res.status, port);
+  } catch {
+    return classifyHindsightHealthProbe(null, port);
+  } finally {
+    clearTimeout(timer);
+  }
+}
 function classifyToolContract(advertised) {
   const byName = new Map(advertised.map((t) => [t.name, t]));
   const results = [];
@@ -40068,7 +40778,7 @@ function classifyToolContract(advertised) {
   }
   return results;
 }
-var MIN_HINDSIGHT_SHM_BYTES;
+var MIN_HINDSIGHT_SHM_BYTES, CONSOLIDATION_BACKLOG_WARN = 25, CONSOLIDATION_BACKLOG_FAIL = 200;
 var init_doctor_memory = __esm(() => {
   init_hindsight_tools();
   MIN_HINDSIGHT_SHM_BYTES = 1024 * 1024 * 1024;
@@ -43474,6 +44184,19 @@ async function checkBankIngestHealth(config, url, opts) {
       banks.set(bank, []);
   }
   const inspected = await Promise.all([...banks].map(async ([bankId, agents]) => [bankId, agents, await inspectBankHealth(url, bankId, { fetchImpl: opts?.fetchImpl })]));
+  let backlogRow;
+  if (opts?.includeConsolidationBacklog) {
+    let totalPending = 0;
+    let anyBankReachable = false;
+    for (const [, , h] of inspected) {
+      if (h.ok) {
+        anyBankReachable = true;
+        totalPending += h.pendingOperations;
+      }
+    }
+    if (anyBankReachable)
+      backlogRow = classifyConsolidationBacklog(totalPending);
+  }
   for (const [bankId, agents, h] of inspected) {
     const label = `bank ${bankId}` + (profileBanks.has(bankId) ? " (profile)" : agents[0] !== bankId ? ` (${agents.join(", ")})` : "");
     if (!h.ok) {
@@ -43535,6 +44258,8 @@ async function checkBankIngestHealth(config, url, opts) {
     }
     results.push({ name: label, status: "ok", detail: summary });
   }
+  if (backlogRow)
+    results.push(backlogRow);
   return results;
 }
 function hindsightDocReprocessUrl(mcpUrl, bankId, docId) {
@@ -43545,7 +44270,7 @@ async function checkHindsight(config) {
   if (!isHindsightEnabled(config)) {
     return [];
   }
-  const url = config.memory?.config?.url ?? "http://localhost:8888/mcp/";
+  const url = config.memory?.config?.url ?? HINDSIGHT_DEFAULT_MCP_URL;
   const results = [];
   const match = url.match(/^https?:\/\/([^:/]+):?(\d+)?/);
   if (!match) {
@@ -43591,7 +44316,8 @@ async function checkHindsight(config) {
   }
   results.push(checkHindsightConsumer(config));
   results.push(...checkHindsightContainerHealth());
-  results.push(...await checkBankIngestHealth(config, url));
+  results.push(await checkHindsightHealthEndpoint(url));
+  results.push(...await checkBankIngestHealth(config, url, { includeConsolidationBacklog: true }));
   for (const [agentName, agentConfig] of Object.entries(config.agents)) {
     const bankId = agentConfig.memory?.collection ?? agentName;
     const hasBankMission = !!agentConfig.memory?.bank_mission;
@@ -44745,6 +45471,7 @@ var init_doctor = __esm(() => {
   init_manager();
   init_accounts();
   init_manifest();
+  init_hindsight2();
   init_hindsight();
   init_doctor_memory();
   init_doctor_docker();
@@ -48352,12 +49079,15 @@ var exports_apply = {};
 __export(exports_apply, {
   writeInstallTypeCache: () => writeInstallTypeCache,
   runApplyPreflight: () => runApplyPreflight,
+  runApplyDryRun: () => runApplyDryRun,
   runApply: () => runApply,
   resolveVaultBindMountDir: () => resolveVaultBindMountDir,
   resolveOperatorVaultPassphrase: () => resolveOperatorVaultPassphrase,
   registerApplyCommand: () => registerApplyCommand,
   reexecUnderSudo: () => reexecUnderSudo,
   provisionLiteLLMKeys: () => provisionLiteLLMKeys,
+  probeVaultProvisioning: () => probeVaultProvisioning,
+  parseComposeServiceNames: () => parseComposeServiceNames,
   isInAgentContainer: () => isInAgentContainer,
   inspectVaultBindMountDir: () => inspectVaultBindMountDir,
   formatScaffoldFailureResolution: () => formatScaffoldFailureResolution,
@@ -49040,6 +49770,186 @@ Done. Scaffolded ${scaffolded}/${allAgentNames.length} agents.
     failures
   };
 }
+async function probeVaultProvisioning(config, agentNames, home2) {
+  const optedIn = [];
+  for (const name of agentNames) {
+    const agentConfig = config.agents[name];
+    if (!agentConfig)
+      continue;
+    const resolved = resolveAgentConfig(config.defaults, config.profiles, agentConfig);
+    if (effectiveLiteLLMEnabled(config, resolved.litellm))
+      optedIn.push(name);
+  }
+  const needsHindsight = config.litellm?.enabled === true && config.memory?.backend === "hindsight";
+  const passphraseAvailable = await resolveOperatorVaultPassphrase(home2) !== null;
+  const alreadyProvisioned = [];
+  const unprovisionedNew = [];
+  const brokerUnreachable = [];
+  if (optedIn.length > 0) {
+    const { getViaBrokerStructured: getViaBrokerStructured2 } = await Promise.resolve().then(() => (init_client(), exports_client));
+    for (const name of optedIn) {
+      const existing = await getViaBrokerStructured2(`litellm/${name}/api-key`);
+      if (existing.kind === "ok")
+        alreadyProvisioned.push(name);
+      else if (existing.kind === "unreachable")
+        brokerUnreachable.push(name);
+      else
+        unprovisionedNew.push(name);
+    }
+  }
+  return {
+    optedInCount: optedIn.length,
+    passphraseAvailable,
+    alreadyProvisioned,
+    unprovisionedNew,
+    brokerUnreachable,
+    needsHindsight
+  };
+}
+function parseComposeServiceNames(compose) {
+  const lines = compose.split(`
+`);
+  const names = [];
+  let inServices = false;
+  for (const line of lines) {
+    if (/^services:\s*$/.test(line)) {
+      inServices = true;
+      continue;
+    }
+    if (inServices && /^\S/.test(line))
+      break;
+    if (!inServices)
+      continue;
+    const m = /^ {2}([A-Za-z0-9_.-]+):\s*$/.exec(line);
+    if (m)
+      names.push(m[1]);
+  }
+  return names;
+}
+async function runApplyDryRun(config, options, deps = {}, switchroomConfigPath) {
+  const writeOut = deps.writeOut ?? ((s) => process.stdout.write(s));
+  const writeErr = deps.writeErr ?? ((s) => process.stderr.write(s));
+  const blocking = [];
+  const warnings = [];
+  const info = [];
+  writeOut(source_default.bold(`
+Dry-run: validating switchroom config (no changes will be written)...
+`));
+  try {
+    runApplyPreflight(config, { detectComposeV2: deps.detectComposeV2 });
+  } catch (err) {
+    blocking.push(`preflight: ${err.message}`);
+  }
+  const allAgentNames = Object.keys(config.agents ?? {});
+  const agentNames = options.only !== undefined ? [options.only] : allAgentNames;
+  if (options.only !== undefined && !allAgentNames.includes(options.only)) {
+    blocking.push(`apply --only=${options.only}: no such agent in switchroom.yaml (defined: ${allAgentNames.join(", ") || "none"}).`);
+  }
+  for (const name of agentNames) {
+    const agentConfig = config.agents[name];
+    if (!agentConfig)
+      continue;
+    const profileName = agentConfig.extends ?? "default";
+    try {
+      getProfilePath(profileName);
+      resolveAgentConfig(config.defaults, config.profiles, agentConfig);
+    } catch (err) {
+      blocking.push(`profile '${profileName}' for agent '${name}': ${err.message}`);
+    }
+  }
+  try {
+    const probe2 = await probeVaultProvisioning(config, agentNames, homedir47());
+    if (probe2.alreadyProvisioned.length > 0) {
+      info.push(`litellm: ${probe2.alreadyProvisioned.length} agent(s) already provisioned (${probe2.alreadyProvisioned.join(", ")}).`);
+    }
+    if (probe2.brokerUnreachable.length > 0) {
+      warnings.push(`litellm: vault-broker unreachable \u2014 could not verify/provision ` + `${probe2.brokerUnreachable.length} agent(s) (${probe2.brokerUnreachable.join(", ")}); they keep their previous routing env.`);
+    }
+    const pending = [
+      ...probe2.unprovisionedNew,
+      ...probe2.needsHindsight ? ["hindsight (service)"] : []
+    ];
+    if (pending.length > 0) {
+      if (probe2.passphraseAvailable) {
+        info.push(`litellm: would provision ${pending.length} new virtual key(s) (${pending.join(", ")}) \u2014 vault passphrase is available.`);
+      } else {
+        blocking.push(`litellm: ${pending.length} agent(s)/service(s) need a NEW vault key (${pending.join(", ")}) but the vault passphrase is unavailable (no SWITCHROOM_VAULT_PASSPHRASE env and machine-id auto-unlock blob ` + `missing/undecryptable) \u2014 a real apply could not provision them.`);
+      }
+    }
+  } catch (err) {
+    warnings.push(`litellm: provisioning probe failed \u2014 ${err.message}`);
+  }
+  let imageTag = null;
+  let previousImageTag = null;
+  let composeChanged = false;
+  let addedServices = [];
+  let removedServices = [];
+  try {
+    const computed = await computeComposeContent({
+      config,
+      composePath: options.outPath ?? DEFAULT_COMPOSE_PATH2,
+      switchroomConfigPath,
+      releaseOverride: options.releaseOverride,
+      buildMode: options.buildLocal ? "local" : "pull",
+      buildContext: options.buildContext
+    });
+    imageTag = computed.imageTag;
+    previousImageTag = computed.previousImageTag;
+    composeChanged = computed.previous !== computed.content;
+    const newServices = parseComposeServiceNames(computed.content);
+    const oldServices = computed.previous ? parseComposeServiceNames(computed.previous) : [];
+    addedServices = newServices.filter((s) => !oldServices.includes(s));
+    removedServices = oldServices.filter((s) => !newServices.includes(s));
+    if (previousImageTag === null) {
+      info.push(`compose: no existing compose on disk \u2014 a real apply would create it.`);
+    } else if (previousImageTag !== imageTag) {
+      info.push(`compose: agent image would change ${previousImageTag} \u2192 ${imageTag}.`);
+    } else {
+      info.push(`compose: agent image unchanged (${imageTag}).`);
+    }
+    if (addedServices.length > 0) {
+      info.push(`compose: services added: ${addedServices.join(", ")}.`);
+    }
+    if (removedServices.length > 0) {
+      info.push(`compose: services removed: ${removedServices.join(", ")}.`);
+    }
+    if (previousImageTag !== null && !composeChanged) {
+      info.push(`compose: no change (would be byte-identical to the current file).`);
+    }
+  } catch (err) {
+    blocking.push(`compose generation: ${err.message}`);
+  }
+  for (const line of info)
+    writeOut(source_default.gray(`  ~ ${line}
+`));
+  for (const line of warnings)
+    writeErr(source_default.yellow(`  ! ${line}
+`));
+  for (const line of blocking)
+    writeErr(source_default.red(`  x ${line}
+`));
+  const wouldSucceed = blocking.length === 0;
+  writeOut(`
+`);
+  if (wouldSucceed) {
+    writeOut(source_default.green.bold(`Dry-run: a real apply would SUCCEED. ${allAgentNames.length} agent(s) validated; nothing was written.
+`));
+  } else {
+    writeErr(source_default.red.bold(`Dry-run: a real apply would FAIL \u2014 ${blocking.length} blocking condition(s) above. Nothing was written.
+`));
+  }
+  return {
+    blocking,
+    warnings,
+    info,
+    imageTag,
+    previousImageTag,
+    composeChanged,
+    addedServices,
+    removedServices,
+    wouldSucceed
+  };
+}
 function formatScaffoldFailureResolution(failures, scaffolded, agentsTotal) {
   const fail3 = failures.length;
   const lines = [];
@@ -49157,7 +50067,7 @@ ERROR: failed to spawn sudo: ${result.error.message}
   process.exit(result.status ?? 1);
 }
 function registerApplyCommand(program3) {
-  program3.command("apply").description("Apply switchroom.yaml: scaffold every agent and (re)generate the compose file. Run `docker compose -f <path> up -d` afterwards to bring the fleet up.").option("--build-local [context]", "Dev-only: emit `build:` blocks instead of GHCR `image:` refs so `docker compose up --build` rebuilds from in-tree Dockerfiles. Optional context path (defaults to cwd).").option("-o, --out <path>", `Override compose output path (default: ${DEFAULT_COMPOSE_PATH2}).`).option("--example <name>", "Copy an example config into cwd before applying (e.g., 'switchroom' or 'minimal').").option("--non-interactive", "Skip prompts (e.g. sudo-chown explainer for UID alignment). Use in CI / scripts.").option("--allow-unaligned", "Treat UID-alignment chown failures as warnings instead of hard errors. Unsafe: an unaligned state dir will break the agent on first write. Use only if you know you'll fix ownership out-of-band.").option("--only <agent>", "Restrict scaffold + UID-alignment to a single agent (compose still covers the full fleet). Use during a v0.6 \u2192 v0.7 cutover to migrate agents one at a time without breaking the systemd-managed siblings.").option("--compose-only", "Skip the per-agent scaffold loop entirely; only (re)generate the compose file. Use in CI / scripts that can't chown into per-agent state dirs (mode 0700, owned by per-agent UIDs in v0.7+ docker mode). The full apply still runs preflight + emits compose; only the start.sh / .mcp.json / settings.json refresh is skipped.").option("--no-doctor", "Skip the post-apply doctor sweep that surfaces stale start.sh / unhealthy agents (#929). Default: doctor runs after a successful scaffold so the operator sees whether the v0.7+ post-Phase-4 supervisor block is now in place. `switchroom update` passes this internally to avoid running doctor twice (it has its own doctor step).").addOption(new Option("--channel <c>", "Override the resolved `release` block for this apply run: follow the named channel pointer (dev|rc|latest). Mutually exclusive with --pin.").choices(["dev", "rc", "latest"]).conflicts("pin")).addOption(new Option("--pin <p>", "Override the resolved `release` block for this apply run: pin to a specific build (sha-<7-40 hex> or v<semver>). Mutually exclusive with --channel.").conflicts("channel")).option("--print-sudo-cmd", "Print the sudo invocation that `apply` would re-exec itself with when escalation is needed, then exit. Operators who want to script the escalation themselves (CI, custom orchestration) can capture this. Note: tokens are space-separated and not shell-quoted; re-quote arguments if pasting into a shell.").addOption(new Option("--skip-self-elevate").default(false).hideHelp()).action(async (opts) => {
+  program3.command("apply").description("Apply switchroom.yaml: scaffold every agent and (re)generate the compose file. Run `docker compose -f <path> up -d` afterwards to bring the fleet up.").option("--build-local [context]", "Dev-only: emit `build:` blocks instead of GHCR `image:` refs so `docker compose up --build` rebuilds from in-tree Dockerfiles. Optional context path (defaults to cwd).").option("-o, --out <path>", `Override compose output path (default: ${DEFAULT_COMPOSE_PATH2}).`).option("--example <name>", "Copy an example config into cwd before applying (e.g., 'switchroom' or 'minimal').").option("--non-interactive", "Skip prompts (e.g. sudo-chown explainer for UID alignment). Use in CI / scripts.").option("--allow-unaligned", "Treat UID-alignment chown failures as warnings instead of hard errors. Unsafe: an unaligned state dir will break the agent on first write. Use only if you know you'll fix ownership out-of-band.").option("--only <agent>", "Restrict scaffold + UID-alignment to a single agent (compose still covers the full fleet). Use during a v0.6 \u2192 v0.7 cutover to migrate agents one at a time without breaking the systemd-managed siblings.").option("--compose-only", "Skip the per-agent scaffold loop entirely; only (re)generate the compose file. Use in CI / scripts that can't chown into per-agent state dirs (mode 0700, owned by per-agent UIDs in v0.7+ docker mode). The full apply still runs preflight + emits compose; only the start.sh / .mcp.json / settings.json refresh is skipped.").option("--dry-run", "Validate only: run the full compose-regeneration + validation pipeline IN MEMORY (resolve every agent's profile, probe the vault-broker for key-provisioning gaps, compute the would-be compose) and print a report \u2014 without writing the compose file, persisting anything, or touching a container. Exits non-zero if a real apply would fail (e.g. a profile can't resolve). Use as a pre-flight before a `rollout`/`update` (which only print the step plan, not the config-regeneration that actually fails).").option("--no-doctor", "Skip the post-apply doctor sweep that surfaces stale start.sh / unhealthy agents (#929). Default: doctor runs after a successful scaffold so the operator sees whether the v0.7+ post-Phase-4 supervisor block is now in place. `switchroom update` passes this internally to avoid running doctor twice (it has its own doctor step).").addOption(new Option("--channel <c>", "Override the resolved `release` block for this apply run: follow the named channel pointer (dev|rc|latest). Mutually exclusive with --pin.").choices(["dev", "rc", "latest"]).conflicts("pin")).addOption(new Option("--pin <p>", "Override the resolved `release` block for this apply run: pin to a specific build (sha-<7-40 hex> or v<semver>). Mutually exclusive with --channel.").conflicts("channel")).option("--print-sudo-cmd", "Print the sudo invocation that `apply` would re-exec itself with when escalation is needed, then exit. Operators who want to script the escalation themselves (CI, custom orchestration) can capture this. Note: tokens are space-separated and not shell-quoted; re-quote arguments if pasting into a shell.").addOption(new Option("--skip-self-elevate").default(false).hideHelp()).action(async (opts) => {
     try {
       if (opts.example) {
         copyExampleConfig2(opts.example);
@@ -49171,6 +50081,23 @@ function registerApplyCommand(program3) {
 `);
         process.exit(0);
       }
+      if (opts.dryRun) {
+        const dry = await runApplyDryRun(config, {
+          buildLocal: !!opts.buildLocal,
+          buildContext: typeof opts.buildLocal === "string" ? opts.buildLocal : process.cwd(),
+          outPath: opts.out,
+          only: opts.only,
+          releaseOverride: opts.channel ? { channel: opts.channel } : opts.pin ? { pin: opts.pin } : undefined,
+          dryRun: true
+        }, {}, switchroomConfigPath);
+        await captureEvent("apply_dry_run", {
+          agents_total: Object.keys(config.agents ?? {}).length,
+          would_succeed: dry.wouldSucceed,
+          blocking: dry.blocking.length,
+          warnings: dry.warnings.length
+        });
+        process.exit(dry.wouldSucceed ? 0 : 1);
+      }
       if (!opts.skipSelfElevate && !opts.composeOnly && process.geteuid?.() !== 0) {
         const unwritable = findUnwritableAgentDirs(config, {
           only: opts.only
@@ -49278,6 +50205,7 @@ var init_apply = __esm(() => {
   init_update_prompt_hook();
   init_compose();
   init_write_compose();
+  init_profiles();
   init_install_detect();
   init_operator_uid();
   init_posthog();
@@ -63737,8 +64665,8 @@ import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 
 // src/build-info.ts
-var VERSION = "0.17.6";
-var COMMIT_SHA = "0cc74c23";
+var VERSION = "0.18.3";
+var COMMIT_SHA = "dbd8b112";
 
 // src/cli/resolve-version.ts
 function readPackageVersion() {
@@ -63769,7 +64697,7 @@ var SWITCHROOM_VERSION = (() => {
 init_esm();
 init_source();
 import { join as join21, resolve as resolve22 } from "node:path";
-import { rmSync as rmSync9, existsSync as existsSync31, readFileSync as readFileSync25, writeFileSync as writeFileSync13 } from "node:fs";
+import { rmSync as rmSync10, existsSync as existsSync31, readFileSync as readFileSync25, writeFileSync as writeFileSync13 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
 
 // src/agents/scheduler-state.ts
@@ -63833,6 +64761,7 @@ function formatSchedulerState(state) {
 
 // src/cli/agent.ts
 init_loader();
+init_hindsight2();
 init_hindsight();
 init_helpers();
 init_scaffold();
@@ -63951,11 +64880,11 @@ function detectInFlight(opts) {
 async function waitUntilIdle(opts) {
   const pollMs = opts.pollMs ?? 2000;
   const clock = opts.now ?? Date.now;
-  const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const sleep2 = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   const deadline = clock() + opts.timeoutMs;
   let last = detectInFlight(opts);
   while (last.busy && clock() < deadline) {
-    await sleep(pollMs);
+    await sleep2(pollMs);
     last = detectInFlight(opts);
   }
   return last;
@@ -64067,10 +64996,10 @@ function spinner(message) {
 // src/agents/status.ts
 import { existsSync as existsSync23, readFileSync as readFileSync20, statSync as statSync11 } from "node:fs";
 import { join as join16 } from "node:path";
-import { execFileSync as execFileSync9 } from "node:child_process";
+import { execFileSync as execFileSync11 } from "node:child_process";
 
 // src/agents/handoff-summarizer.ts
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync8, renameSync as renameSync5, mkdirSync as mkdirSync15, existsSync as existsSync21, statSync as statSync10, readdirSync as readdirSync9 } from "node:fs";
+import { readFileSync as readFileSync18, writeFileSync as writeFileSync8, renameSync as renameSync6, mkdirSync as mkdirSync15, existsSync as existsSync21, statSync as statSync10, readdirSync as readdirSync9 } from "node:fs";
 import { join as join15 } from "node:path";
 var DEFAULT_MAX_TURNS = 50;
 var TOPIC_MAX_CHARS = 117;
@@ -64212,8 +65141,8 @@ function writeSidecarsAtomic(agentDir, briefing, topic) {
   const topicTmp = topicPath + ".tmp";
   writeFileSync8(handoffTmp, briefing, "utf-8");
   writeFileSync8(topicTmp, topic, "utf-8");
-  renameSync5(handoffTmp, handoffPath);
-  renameSync5(topicTmp, topicPath);
+  renameSync6(handoffTmp, handoffPath);
+  renameSync6(topicTmp, topicPath);
 }
 async function buildHandoff(opts) {
   const maxTurns = opts.maxTurns ?? DEFAULT_MAX_TURNS;
@@ -64652,7 +65581,7 @@ async function buildAgentStatusReport(inputs) {
 async function waitForAgentReady(inputs, options = {}) {
   const timeoutMs = options.timeoutMs ?? 30000;
   const pollIntervalMs = options.pollIntervalMs ?? 750;
-  const sleep = options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const sleep2 = options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   const now = options.now ?? Date.now;
   const startedAt = now();
   const deadline = startedAt + timeoutMs;
@@ -64667,7 +65596,7 @@ async function waitForAgentReady(inputs, options = {}) {
         notReady
       };
     }
-    await sleep(pollIntervalMs);
+    await sleep2(pollIntervalMs);
     report = await buildAgentStatusReport(inputs);
     notReady = readinessGaps(report);
   }
@@ -64744,14 +65673,14 @@ function readLastMessages(historyDbPath) {
     };
   }
   try {
-    const out = execFileSync9("bun", [
+    const out = execFileSync11("bun", [
       "-e",
       `const { Database } = require("bun:sqlite"); ` + `const db = new Database(${JSON.stringify(historyDbPath)}, { readonly: true }); ` + `const rows = db.prepare("SELECT role, MAX(ts) as ts FROM messages GROUP BY role").all(); ` + `for (const r of rows) console.log(r.role + "|" + r.ts); ` + `db.close();`
     ], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
     return parseSqliteRoleTsOutput(out);
   } catch {}
   try {
-    const out = execFileSync9("sqlite3", [
+    const out = execFileSync11("sqlite3", [
       historyDbPath,
       "SELECT role, MAX(ts) FROM messages GROUP BY role;"
     ], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
@@ -64863,7 +65792,7 @@ function escapeRegex(s) {
 }
 function readDockerContainer(containerName2) {
   try {
-    const out = execFileSync9("docker", ["inspect", "--format", "{{json .State}}", containerName2], { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
+    const out = execFileSync11("docker", ["inspect", "--format", "{{json .State}}", containerName2], { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
     const state = JSON.parse(out.trim());
     const active = state.Status === "running" ? "active" : state.Status === "restarting" ? "restarting" : "inactive";
     const pid = typeof state.Pid === "number" && state.Pid > 0 ? state.Pid : null;
@@ -64925,7 +65854,7 @@ init_profiles();
 init_lifecycle();
 init_manager();
 import { resolve as resolve17 } from "node:path";
-import { existsSync as existsSync26, rmSync as rmSync6 } from "node:fs";
+import { existsSync as existsSync26, rmSync as rmSync7 } from "node:fs";
 
 // src/telegram/redact-token.ts
 var REDACTED_PLACEHOLDER = "<redacted-bot-token>";
@@ -64978,7 +65907,7 @@ async function pollForDmStart(token, timeoutMs = 120000) {
       const response = await fetch(url);
       data = await response.json();
     } catch {
-      await sleep(2000);
+      await sleep2(2000);
       continue;
     }
     if (data.ok && Array.isArray(data.result)) {
@@ -64994,11 +65923,11 @@ async function pollForDmStart(token, timeoutMs = 120000) {
         }
       }
     }
-    await sleep(2000);
+    await sleep2(2000);
   }
   throw new Error("Timed out waiting for /start DM");
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve17) => setTimeout(resolve17, ms));
 }
 
@@ -65074,7 +66003,7 @@ async function createAgent(opts) {
   const agentDir = resolve17(agentsDir, name);
   await withRollback(() => {
     scaffoldAgent(name, agentConfig, agentsDir, config.telegram, config, undefined, configPath);
-    rollbackStack.push(() => rmSync6(agentDir, { recursive: true, force: true }));
+    rollbackStack.push(() => rmSync7(agentDir, { recursive: true, force: true }));
   });
   await withRollback(() => {
     writeAgentEnv(agentDir, telegramBotToken);
@@ -65141,8 +66070,8 @@ async function completeCreation(name, code, opts = {}) {
 
 // src/agents/add-orchestrator.ts
 import { resolve as resolve19, join as join19 } from "node:path";
-import { existsSync as existsSync28, rmSync as rmSync7, statSync as statSync15 } from "node:fs";
-import { execFileSync as execFileSync12 } from "node:child_process";
+import { existsSync as existsSync28, rmSync as rmSync8, statSync as statSync15 } from "node:fs";
+import { execFileSync as execFileSync14 } from "node:child_process";
 init_onboarding();
 
 // src/setup/botfather-walkthrough.ts
@@ -65708,7 +66637,7 @@ function pruneBundledSkills(agentDir, keep, scope) {
     if (!isDir)
       continue;
     try {
-      rmSync7(entryPath, { recursive: true, force: true });
+      rmSync8(entryPath, { recursive: true, force: true });
       removed.push(entry);
     } catch {}
   }
@@ -65716,7 +66645,7 @@ function pruneBundledSkills(agentDir, keep, scope) {
 }
 function defaultIsUnitActive(unitName) {
   try {
-    const out = execFileSync12("systemctl", ["--user", "is-active", unitName], {
+    const out = execFileSync14("systemctl", ["--user", "is-active", unitName], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
     }).trim();
@@ -65743,7 +66672,7 @@ import { resolve as resolve20 } from "node:path";
 import {
   existsSync as existsSync29,
   mkdtempSync as mkdtempSync3,
-  rmSync as rmSync8,
+  rmSync as rmSync9,
   cpSync
 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
@@ -65768,7 +66697,7 @@ function defaultDeps() {
       return tmp;
     },
     copyDir: (src, dst) => cpSync(src, dst, { recursive: true }),
-    removeDir: (p) => rmSync8(p, { recursive: true, force: true }),
+    removeDir: (p) => rmSync9(p, { recursive: true, force: true }),
     existsSync: existsSync29,
     readFileSync: (p, enc) => readFileSync23(p, enc)
   };
@@ -66137,16 +67066,16 @@ function parsePorcelainDirty(porcelain) {
 }
 function checkSwitchroomBranch() {
   try {
-    const { execFileSync: execFileSync14 } = __require("node:child_process");
+    const { execFileSync: execFileSync15 } = __require("node:child_process");
     const cwd = process.cwd();
-    const branch = execFileSync14("git", ["-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"], {
+    const branch = execFileSync15("git", ["-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
     if (branch === "" || branch === "HEAD")
       return null;
     if (branch === "main" || branch === "master") {
-      const porcelain = execFileSync14("git", ["-C", cwd, "status", "--porcelain"], {
+      const porcelain = execFileSync15("git", ["-C", cwd, "status", "--porcelain"], {
         encoding: "utf-8",
         stdio: ["ignore", "pipe", "ignore"]
       });
@@ -66209,7 +67138,7 @@ function buildStatusInputs(name, config, agentsDir) {
   let hindsightApiUrl = null;
   let hindsightBankId = name;
   if (isHindsightEnabled(config)) {
-    const baseUrl = config.memory?.config?.url ?? "http://localhost:8888/mcp/";
+    const baseUrl = config.memory?.config?.url ?? HINDSIGHT_DEFAULT_MCP_URL;
     hindsightApiUrl = baseUrl.endsWith("/mcp/") ? baseUrl : baseUrl.replace(/\/$/, "") + "/mcp/";
     hindsightBankId = agentConfig?.memory?.collection ?? name;
   }
@@ -66477,7 +67406,7 @@ function registerAgentCommand(program3) {
     let hindsightApiUrl = null;
     let hindsightBankId = name;
     if (isHindsightEnabled(config)) {
-      const baseUrl = config.memory?.config?.url ?? "http://localhost:8888/mcp/";
+      const baseUrl = config.memory?.config?.url ?? HINDSIGHT_DEFAULT_MCP_URL;
       hindsightApiUrl = baseUrl.endsWith("/mcp/") ? baseUrl : baseUrl.replace(/\/$/, "") + "/mcp/";
       hindsightBankId = agentConfig.memory?.collection ?? name;
     }
@@ -67161,7 +68090,7 @@ Permissions for ${name}
       }
     }
     if (existsSync31(agentDir)) {
-      rmSync9(agentDir, { recursive: true, force: true });
+      rmSync10(agentDir, { recursive: true, force: true });
       console.log(source_default.green(`  Removed directory: ${agentDir}`));
     } else {
       console.log(source_default.gray(`  Directory not found: ${agentDir}`));
@@ -67365,7 +68294,7 @@ switchroom agent add: ${name}
           const agentsDirRollback = resolveAgentsDir(cfg);
           const agentDirRollback = resolve22(agentsDirRollback, name);
           if (existsSync31(agentDirRollback)) {
-            rmSync9(agentDirRollback, { recursive: true, force: true });
+            rmSync10(agentDirRollback, { recursive: true, force: true });
             console.log(source_default.gray(`  Rolled back: removed ${agentDirRollback}`));
           }
           process.exit(1);
@@ -69996,7 +70925,7 @@ function registerAuthCommand(program3) {
         try {
           mode = statSync17(yamlPath).mode & 511;
         } catch {}
-        atomicWriteFileSync2(yamlPath, after, mode);
+        atomicWriteFileSync(yamlPath, after, mode);
         if (!quiet) {
           console.log(source_default.gray(`  Pinned auth.active: ${label} in ${yamlPath}`));
         }
@@ -70143,9 +71072,9 @@ import { readFileSync as readFileSync39 } from "node:fs";
 init_source();
 init_loader();
 init_vault();
-init_hindsight();
+init_hindsight2();
 import { readFileSync as readFileSync31, writeFileSync as writeFileSync17, copyFileSync as copyFileSync6, existsSync as existsSync36, readdirSync as readdirSync16, statSync as statSync18 } from "node:fs";
-import { execFileSync as execFileSync15 } from "node:child_process";
+import { execFileSync as execFileSync16 } from "node:child_process";
 import { join as join28 } from "node:path";
 import { homedir as homedir13 } from "node:os";
 function getVaultPath2(configPath) {
@@ -70492,7 +71421,7 @@ function registerVaultSweep(vault, program3) {
 function scrubSqlite(path, values, dryRun) {
   let hasSqlite = true;
   try {
-    execFileSync15("sqlite3", ["-version"], { timeout: 2000, stdio: "ignore" });
+    execFileSync16("sqlite3", ["-version"], { timeout: 2000, stdio: "ignore" });
   } catch {
     hasSqlite = false;
   }
@@ -70504,7 +71433,7 @@ function scrubSqlite(path, values, dryRun) {
   for (const { value } of values) {
     const esc = value.replace(/'/g, "''");
     try {
-      const out = execFileSync15("sqlite3", [path, `SELECT COUNT(*) FROM messages WHERE text LIKE '%${esc}%'`], { encoding: "utf8", timeout: 1e4 });
+      const out = execFileSync16("sqlite3", [path, `SELECT COUNT(*) FROM messages WHERE text LIKE '%${esc}%'`], { encoding: "utf8", timeout: 1e4 });
       const n = parseInt(out.trim(), 10);
       if (!Number.isNaN(n))
         matches += n;
@@ -70518,7 +71447,7 @@ function scrubSqlite(path, values, dryRun) {
       for (const { key, value } of values) {
         const esc = value.replace(/'/g, "''");
         const replacement = `vault:${key}`.replace(/'/g, "''");
-        execFileSync15("sqlite3", [path, `UPDATE messages SET text = replace(text, '${esc}', '${replacement}')`], { timeout: 15000 });
+        execFileSync16("sqlite3", [path, `UPDATE messages SET text = replace(text, '${esc}', '${replacement}')`], { timeout: 15000 });
       }
       return { target: path, matches, modified: true };
     } catch (err) {
@@ -74170,7 +75099,8 @@ class VaultBroker {
         return;
       }
       try {
-        const tokenDir = path3.join(os4.homedir(), ".switchroom", "agents", agent);
+        const agentsDir = this.config ? resolveAgentsDir(this.config) : path3.join(os4.homedir(), ".switchroom", "agents");
+        const tokenDir = path3.join(agentsDir, agent);
         mkdirSync24(tokenDir, { recursive: true });
         const tokenPath = path3.join(tokenDir, ".vault-token");
         const tmpPath = `${tokenPath}.tmp.${process.pid}`;
@@ -74234,7 +75164,8 @@ class VaultBroker {
       try {
         const row = this.grantsDb.query("SELECT agent_slug FROM vault_grants WHERE id = ?").get(id);
         if (row && AgentNameSchema.safeParse(row.agent_slug).success) {
-          const tokenPath = path3.join(os4.homedir(), ".switchroom", "agents", row.agent_slug, ".vault-token");
+          const agentsDir = this.config ? resolveAgentsDir(this.config) : path3.join(os4.homedir(), ".switchroom", "agents");
+          const tokenPath = path3.join(agentsDir, row.agent_slug, ".vault-token");
           if (existsSync41(tokenPath)) {
             try {
               unlinkSync10(tokenPath);
@@ -77429,10 +78360,10 @@ function fail2(msg) {
 
 // src/cli/memory.ts
 init_source();
-init_hindsight();
+init_hindsight2();
 
 // src/memory/search.ts
-init_hindsight();
+init_hindsight2();
 function shellQuote2(s) {
   return "'" + s.replace(/'/g, `'"'"'`) + "'";
 }
@@ -77459,312 +78390,7 @@ function reflectAcrossAgents(config) {
 
 // src/cli/memory.ts
 init_helpers();
-
-// src/setup/hindsight.ts
-import { execFileSync as execFileSync16 } from "node:child_process";
-import { createServer as createServer4 } from "node:net";
-var HINDSIGHT_DEFAULT_API_PORT = 8888;
-var HINDSIGHT_DEFAULT_UI_PORT = 9999;
-var HINDSIGHT_DEFAULT_MAX_OBSERVATIONS_PER_SCOPE = 1000;
-var HINDSIGHT_CONSUMER_NAME = "hindsight";
-var HINDSIGHT_DEFAULT_UID = 11000;
-var HINDSIGHT_IMAGE_REPO = "ghcr.io/switchroom/switchroom-hindsight";
-var HINDSIGHT_IMAGE = `${HINDSIGHT_IMAGE_REPO}:latest`;
-function hindsightImageRef(tag) {
-  const t = tag?.trim();
-  if (!t)
-    return HINDSIGHT_IMAGE;
-  const v = t.replace(/^v/, "");
-  return `${HINDSIGHT_IMAGE_REPO}:v${v}`;
-}
-var HINDSIGHT_DEFAULT_MODEL = "claude-sonnet-5";
-var HINDSIGHT_DEFAULT_MCP_STATELESS = true;
-var HINDSIGHT_BROKER_SOCK_VOLUME = `auth-broker-${HINDSIGHT_CONSUMER_NAME}-sock`;
-var HINDSIGHT_DEFAULT_RERANKER_BUCKET_BATCHING = "true";
-var HINDSIGHT_DEFAULT_RERANKER_MAX_CANDIDATES = 150;
-var HINDSIGHT_DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT = 4;
-var HINDSIGHT_DEFAULT_RECALL_MAX_CONCURRENT = 8;
-var HINDSIGHT_DEFAULT_REFLECT_WALL_TIMEOUT_S = 600;
-var HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_BATCH_SIZE = 12;
-var HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_SLOTS = 3;
-var HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_PARALLELISM = 6;
-var HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND = 300;
-var HINDSIGHT_DEFAULT_MEM_LIMIT = "8g";
-var HINDSIGHT_DEFAULT_MEM_RESERVATION = "4g";
-var HINDSIGHT_DEFAULT_PIDS_LIMIT = 1000;
-var HINDSIGHT_DEFAULT_SHM_SIZE = "2g";
-var HINDSIGHT_HEALTHCHECK_PY = 'import urllib.request,sys; sys.exit(0 if urllib.request.urlopen("http://localhost:8888/health",timeout=4).getcode()==200 else 1)';
-var HINDSIGHT_HEALTHCHECK_CMD = `python3 -c '${HINDSIGHT_HEALTHCHECK_PY}'`;
-function isPortFree(port) {
-  return new Promise((resolve29) => {
-    const server = createServer4();
-    server.once("error", () => resolve29(false));
-    server.once("listening", () => {
-      server.close(() => resolve29(true));
-    });
-    server.listen(port, "127.0.0.1");
-  });
-}
-async function findFreePort(start, maxAttempts = 50) {
-  for (let i = 0;i < maxAttempts; i++) {
-    const port = start + i;
-    if (port < 1024)
-      continue;
-    if (await isPortFree(port)) {
-      return port;
-    }
-  }
-  return null;
-}
-async function pickHindsightPorts() {
-  if (await isPortFree(HINDSIGHT_DEFAULT_API_PORT) && await isPortFree(HINDSIGHT_DEFAULT_UI_PORT)) {
-    return {
-      apiPort: HINDSIGHT_DEFAULT_API_PORT,
-      uiPort: HINDSIGHT_DEFAULT_UI_PORT
-    };
-  }
-  const apiPort = await findFreePort(18888);
-  const uiPort = await findFreePort(19999);
-  if (apiPort === null || uiPort === null) {
-    throw new Error("Could not find a free port for Hindsight. " + "Stop whatever is using 8888 / 9999 / 18888 / 19999 and retry.");
-  }
-  return { apiPort, uiPort };
-}
-function isDockerAvailable() {
-  try {
-    execFileSync16("docker", ["--version"], { stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isHindsightRunning() {
-  try {
-    const output = execFileSync16("docker", ["ps", "--filter", "name=switchroom-hindsight", "--format", "{{.Status}}"], { stdio: "pipe", encoding: "utf-8" });
-    return output.trim().length > 0;
-  } catch {
-    return false;
-  }
-}
-function isHindsightContainerExists() {
-  try {
-    const output = execFileSync16("docker", ["ps", "-a", "--filter", "name=switchroom-hindsight", "--format", "{{.Names}}"], { stdio: "pipe", encoding: "utf-8" });
-    return output.trim().length > 0;
-  } catch {
-    return false;
-  }
-}
-function startHindsight(ports, litellm, imageTag) {
-  const apiPort = ports?.apiPort ?? HINDSIGHT_DEFAULT_API_PORT;
-  const uiPort = ports?.uiPort ?? HINDSIGHT_DEFAULT_UI_PORT;
-  const envArgs = [
-    "-e",
-    `HINDSIGHT_API_MAX_OBSERVATIONS_PER_SCOPE=${HINDSIGHT_DEFAULT_MAX_OBSERVATIONS_PER_SCOPE}`,
-    "-e",
-    "HINDSIGHT_API_LLM_PROVIDER=claude-code",
-    "-e",
-    `HINDSIGHT_API_LLM_MODEL=${HINDSIGHT_DEFAULT_MODEL}`,
-    "-e",
-    `HINDSIGHT_API_MCP_STATELESS=${HINDSIGHT_DEFAULT_MCP_STATELESS}`,
-    "-e",
-    `HINDSIGHT_API_RERANKER_LOCAL_BUCKET_BATCHING=${HINDSIGHT_DEFAULT_RERANKER_BUCKET_BATCHING}`,
-    "-e",
-    `HINDSIGHT_API_RERANKER_MAX_CANDIDATES=${HINDSIGHT_DEFAULT_RERANKER_MAX_CANDIDATES}`,
-    "-e",
-    `HINDSIGHT_API_RERANKER_LOCAL_MAX_CONCURRENT=${HINDSIGHT_DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT}`,
-    "-e",
-    `HINDSIGHT_API_RECALL_MAX_CONCURRENT=${HINDSIGHT_DEFAULT_RECALL_MAX_CONCURRENT}`,
-    "-e",
-    `HINDSIGHT_API_REFLECT_WALL_TIMEOUT=${HINDSIGHT_DEFAULT_REFLECT_WALL_TIMEOUT_S}`,
-    "-e",
-    `HINDSIGHT_API_CONSOLIDATION_LLM_BATCH_SIZE=${HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_BATCH_SIZE}`,
-    "-e",
-    `HINDSIGHT_API_WORKER_CONSOLIDATION_MAX_SLOTS=${HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_SLOTS}`,
-    "-e",
-    `HINDSIGHT_API_CONSOLIDATION_LLM_PARALLELISM=${HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_PARALLELISM}`,
-    "-e",
-    `HINDSIGHT_API_CONSOLIDATION_MAX_MEMORIES_PER_ROUND=${HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND}`
-  ];
-  if (litellm) {
-    envArgs.push("-e", `HINDSIGHT_API_PORT=${apiPort}`, "-e", `ANTHROPIC_BASE_URL=${litellm.baseUrl.replace(/\/+$/, "")}/anthropic`, "-e", `ANTHROPIC_CUSTOM_HEADERS=x-litellm-api-key: Bearer ${litellm.apiKey}
-x-litellm-customer-id: hindsight
-x-litellm-tags: service:hindsight`);
-  }
-  const args = [
-    "run",
-    "-d",
-    "--name",
-    "switchroom-hindsight",
-    "--restart",
-    "always",
-    `--memory=${HINDSIGHT_DEFAULT_MEM_LIMIT}`,
-    `--memory-reservation=${HINDSIGHT_DEFAULT_MEM_RESERVATION}`,
-    `--pids-limit=${HINDSIGHT_DEFAULT_PIDS_LIMIT}`,
-    `--shm-size=${HINDSIGHT_DEFAULT_SHM_SIZE}`,
-    "--health-cmd",
-    litellm ? `python3 -c 'import urllib.request,sys; sys.exit(0 if urllib.request.urlopen("http://localhost:${apiPort}/health",timeout=4).getcode()==200 else 1)'` : HINDSIGHT_HEALTHCHECK_CMD,
-    "--health-interval",
-    "30s",
-    "--health-timeout",
-    "5s",
-    "--health-retries",
-    "3",
-    "--health-start-period",
-    "60s"
-  ];
-  if (litellm) {
-    args.push("--network", "host");
-  } else {
-    args.push("-p", `127.0.0.1:${apiPort}:8888`, "-p", `127.0.0.1:${uiPort}:9999`);
-  }
-  args.push("-v", "switchroom-hindsight-data:/home/hindsight/.pg0", "-v", "switchroom-hindsight-backups:/backups", "-v", `${HINDSIGHT_BROKER_SOCK_VOLUME}:/run/switchroom/auth-broker`, "--tmpfs", `/run/claude-creds:rw,mode=0700,uid=${HINDSIGHT_DEFAULT_UID},gid=${HINDSIGHT_DEFAULT_UID}`, ...envArgs, hindsightImageRef(imageTag));
-  execFileSync16("docker", args, { stdio: "pipe" });
-}
-function stopHindsight() {
-  try {
-    execFileSync16("docker", ["stop", "switchroom-hindsight"], { stdio: "pipe" });
-  } catch {}
-  try {
-    execFileSync16("docker", ["rm", "switchroom-hindsight"], { stdio: "pipe" });
-  } catch {}
-}
-function pullHindsightImage(imageTag) {
-  execFileSync16("docker", ["pull", hindsightImageRef(imageTag)], { stdio: "inherit" });
-}
-function getRunningHindsightPorts() {
-  const readPort = (containerPort) => {
-    try {
-      const out = execFileSync16("docker", ["port", "switchroom-hindsight", `${containerPort}/tcp`], { stdio: "pipe", encoding: "utf-8" });
-      const m = out.split(`
-`).map((l) => l.trim()).find((l) => l.length > 0);
-      if (!m)
-        return null;
-      const port = Number(m.slice(m.lastIndexOf(":") + 1));
-      return Number.isInteger(port) && port > 0 ? port : null;
-    } catch {
-      return null;
-    }
-  };
-  const apiPort = readPort(HINDSIGHT_DEFAULT_API_PORT);
-  if (apiPort === null)
-    return null;
-  const uiPort = readPort(HINDSIGHT_DEFAULT_UI_PORT) ?? (apiPort === HINDSIGHT_DEFAULT_API_PORT ? HINDSIGHT_DEFAULT_UI_PORT : 19999);
-  return { apiPort, uiPort };
-}
-function getHindsightStatus() {
-  try {
-    const output = execFileSync16("docker", ["ps", "-a", "--filter", "name=switchroom-hindsight", "--format", "{{.Status}}"], { stdio: "pipe", encoding: "utf-8" });
-    const status = output.trim();
-    return status.length > 0 ? status : null;
-  } catch {
-    return null;
-  }
-}
-function generateHindsightComposeSnippet() {
-  return [
-    "services:",
-    "  switchroom-hindsight:",
-    `    image: ${HINDSIGHT_IMAGE}`,
-    "    container_name: switchroom-hindsight",
-    "    ports:",
-    '      - "8888:8888"',
-    '      - "9999:9999"',
-    "    environment:",
-    `      - HINDSIGHT_API_MAX_OBSERVATIONS_PER_SCOPE=${HINDSIGHT_DEFAULT_MAX_OBSERVATIONS_PER_SCOPE}`,
-    "      - HINDSIGHT_API_LLM_PROVIDER=claude-code",
-    `      - HINDSIGHT_API_LLM_MODEL=${HINDSIGHT_DEFAULT_MODEL}`,
-    `      - HINDSIGHT_API_MCP_STATELESS=${HINDSIGHT_DEFAULT_MCP_STATELESS}`,
-    `      - HINDSIGHT_API_RERANKER_LOCAL_BUCKET_BATCHING=${HINDSIGHT_DEFAULT_RERANKER_BUCKET_BATCHING}`,
-    `      - HINDSIGHT_API_RERANKER_MAX_CANDIDATES=${HINDSIGHT_DEFAULT_RERANKER_MAX_CANDIDATES}`,
-    `      - HINDSIGHT_API_RERANKER_LOCAL_MAX_CONCURRENT=${HINDSIGHT_DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT}`,
-    `      - HINDSIGHT_API_RECALL_MAX_CONCURRENT=${HINDSIGHT_DEFAULT_RECALL_MAX_CONCURRENT}`,
-    `      - HINDSIGHT_API_REFLECT_WALL_TIMEOUT=${HINDSIGHT_DEFAULT_REFLECT_WALL_TIMEOUT_S}`,
-    `      - HINDSIGHT_API_CONSOLIDATION_LLM_BATCH_SIZE=${HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_BATCH_SIZE}`,
-    `      - HINDSIGHT_API_WORKER_CONSOLIDATION_MAX_SLOTS=${HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_SLOTS}`,
-    `      - HINDSIGHT_API_CONSOLIDATION_LLM_PARALLELISM=${HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_PARALLELISM}`,
-    `      - HINDSIGHT_API_CONSOLIDATION_MAX_MEMORIES_PER_ROUND=${HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND}`,
-    `    mem_limit: ${HINDSIGHT_DEFAULT_MEM_LIMIT}`,
-    `    mem_reservation: ${HINDSIGHT_DEFAULT_MEM_RESERVATION}`,
-    `    pids_limit: ${HINDSIGHT_DEFAULT_PIDS_LIMIT}`,
-    `    shm_size: ${HINDSIGHT_DEFAULT_SHM_SIZE}`,
-    "    healthcheck:",
-    `      test: ${JSON.stringify(["CMD", "python3", "-c", HINDSIGHT_HEALTHCHECK_PY])}`,
-    "      interval: 30s",
-    "      timeout: 5s",
-    "      retries: 3",
-    "      start_period: 60s",
-    "    volumes:",
-    "      - switchroom-hindsight-data:/home/hindsight/.pg0",
-    "      - switchroom-hindsight-backups:/backups",
-    `      - ${HINDSIGHT_BROKER_SOCK_VOLUME}:/run/switchroom/auth-broker`,
-    "    tmpfs:",
-    `      - /run/claude-creds:rw,mode=0700,uid=${HINDSIGHT_DEFAULT_UID},gid=${HINDSIGHT_DEFAULT_UID}`,
-    "    restart: always",
-    "",
-    "volumes:",
-    "  switchroom-hindsight-data:",
-    "  switchroom-hindsight-backups:",
-    `  ${HINDSIGHT_BROKER_SOCK_VOLUME}:`,
-    "    external: true",
-    "    # Bound by the switchroom-auth-broker singleton in the main",
-    "    # switchroom compose project. Declare an `auth.consumers[]`",
-    `    # entry named "${HINDSIGHT_CONSUMER_NAME}" in switchroom.yaml.`
-  ].join(`
-`);
-}
-async function ensureHindsightConsumer(configPath, account, uid = HINDSIGHT_DEFAULT_UID) {
-  const fs4 = await import("node:fs");
-  const { parseDocument: parseDocument7, isMap: isMap7, isSeq: isSeq4, YAMLMap, YAMLSeq } = await Promise.resolve().then(() => __toESM(require_dist(), 1));
-  const { atomicWriteFileSync: atomicWriteFileSync3 } = await Promise.resolve().then(() => (init_atomic(), exports_atomic));
-  const raw = fs4.readFileSync(configPath, "utf-8");
-  const doc = parseDocument7(raw);
-  const root = doc.contents;
-  if (!isMap7(root)) {
-    return { added: false, reason: "switchroom.yaml root is not a map" };
-  }
-  const authRaw = root.get("auth", true);
-  let authNode;
-  if (isMap7(authRaw)) {
-    authNode = authRaw;
-  } else {
-    authNode = new YAMLMap;
-    doc.setIn(["auth"], authNode);
-  }
-  const consumersRaw = authNode.get("consumers", true);
-  let consumersNode;
-  if (isSeq4(consumersRaw)) {
-    consumersNode = consumersRaw;
-  } else {
-    consumersNode = new YAMLSeq;
-    doc.setIn(["auth", "consumers"], consumersNode);
-  }
-  for (const item of consumersNode.items) {
-    if (isMap7(item)) {
-      const name = item.get("name");
-      if (name === HINDSIGHT_CONSUMER_NAME) {
-        return { added: false, reason: "already present" };
-      }
-    }
-  }
-  const entry = new YAMLMap;
-  entry.set("name", HINDSIGHT_CONSUMER_NAME);
-  if (account !== undefined)
-    entry.set("account", account);
-  entry.set("uid", uid);
-  consumersNode.add(entry);
-  const out = String(doc);
-  const tail = out.endsWith(`
-`) ? out : out + `
-`;
-  let mode = 420;
-  try {
-    mode = fs4.statSync(configPath).mode & 511;
-  } catch {}
-  atomicWriteFileSync3(configPath, tail, mode);
-  return { added: true, reason: "added" };
-}
-
-// src/cli/memory.ts
+init_hindsight();
 init_client();
 init_loader();
 var import_yaml13 = __toESM(require_dist(), 1);
@@ -77777,7 +78403,11 @@ async function resolveLiteLLMForHindsight(config) {
   const result = await getViaBrokerStructured("litellm/hindsight/api-key").catch(() => null);
   if (!result || result.kind !== "ok" || result.entry.kind !== "string")
     return;
-  return { baseUrl: topLiteLLM.base_url, apiKey: result.entry.value };
+  return {
+    baseUrl: topLiteLLM.base_url,
+    apiKey: result.entry.value,
+    model: config.memory?.config?.llm_model
+  };
 }
 function readRecallLog(agentDir, limit) {
   const path4 = join40(agentDir, ".claude", "plugins", "data", "hindsight-memory-inline", "state", "recall_log.jsonl");
@@ -77984,6 +78614,21 @@ Cross-agent reflection plan
     let ports;
     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}.
+`));
+        }
+      }
     } else {
       try {
         ports = await pickHindsightPorts();
@@ -77997,14 +78642,38 @@ Cross-agent reflection plan
     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.error(source_default.red(`
+  ${err.message}
+`));
+        process.exit(1);
+      }
+      conflict = await preflightHindsightPorts(ports);
+      if (conflict) {
+        const stillHeldBy = 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\`.
+`));
+        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."));
     }
     const provider = "claude-code";
     console.log(source_default.gray("  Starting Hindsight Docker container..."));
     try {
-      const litellmCfg = await resolveLiteLLMForHindsight(getConfig(program3));
-      startHindsight(ports, litellmCfg, opts.tag);
+      const hindsightConfig = getConfig(program3);
+      const litellmCfg = await resolveLiteLLMForHindsight(hindsightConfig);
+      startHindsight(ports, litellmCfg, opts.tag, hindsightConfig.hindsight?.llm);
       if (litellmCfg) {
         console.log(source_default.gray("  LiteLLM routing enabled for hindsight (--network host)."));
       }
@@ -78050,7 +78719,7 @@ Cross-agent reflection plan
     console.log(source_default.bold(`
 # Add this to your docker-compose.yml:
 `));
-    console.log(generateHindsightComposeSnippet());
+    console.log(generateHindsightComposeSnippet(getConfig(program3).hindsight?.llm));
     console.log();
   });
   memory.command("recall-log [agent]").description("Show recent auto-recall events (per-turn JSONL log) \u2014 see what was injected, when the cap fired, hit rate hints").option("-n, --limit <n>", "Tail the last N events per agent (default 20)", "20").option("--json", "Emit raw JSONL (one entry per line)").action(withConfigError(async (agent, opts) => {
@@ -78103,7 +78772,7 @@ ${name}:`));
       process.exit(1);
     }
     const collection = getCollectionForAgent(agent, config);
-    const apiUrl = config.memory?.config?.url ?? "http://localhost:8888/mcp/";
+    const apiUrl = config.memory?.config?.url ?? HINDSIGHT_DEFAULT_MCP_URL;
     const timeoutMs = Math.max(500, parseInt(opts.timeout, 10) || 5000);
     console.log(source_default.bold(`
 Demoting memory ${source_default.cyan(memoryId)}`));
@@ -78119,7 +78788,7 @@ Demoting memory ${source_default.cyan(memoryId)}`));
     console.error(source_default.gray("  The Hindsight MCP `update_memory` tool may not be exposed by your deployment, or the memory ID may be wrong. Try `switchroom memory recall-log " + agent + " --json` to confirm the ID surfaced recently."));
     process.exit(1);
   }));
-  const restBase = (url) => (url ?? "http://127.0.0.1:8888/mcp/").replace(/\/mcp\/?$/, "").replace(/\/$/, "");
+  const restBase = (url) => (url ?? HINDSIGHT_DEFAULT_MCP_URL).replace(/\/mcp\/?$/, "").replace(/\/$/, "");
   const VALID_BANK = /^[a-zA-Z0-9_.-]+$/;
   const profile = memory.command("profile").description("Author + inspect operator profile banks (shared/per-user memory; wire via memory.recall.additional_banks)");
   profile.command("add <bank> <fact...>").description("Add an operator-authored fact to a profile bank (creates the bank on first write)").option("--timeout <ms>", "HTTP timeout in milliseconds (retain runs synchronously; default: 60000)", "60000").action(withConfigError(async (bank, factWords, opts) => {
@@ -78227,13 +78896,13 @@ import { timingSafeEqual as timingSafeEqual3, randomBytes as randomBytes11 } fro
 // src/web/api.ts
 init_lifecycle();
 init_manager();
-init_hindsight();
+init_hindsight2();
 import { spawnSync as spawnSync6 } from "node:child_process";
 import { existsSync as existsSync51, readFileSync as readFileSync45, statSync as statSync23 } from "node:fs";
 import { resolve as resolve29, join as join45 } from "node:path";
 
 // src/web/memory-remediation.ts
-init_hindsight();
+init_hindsight2();
 function restBaseFromMcpUrl(mcpUrl) {
   return hindsightRestBase(mcpUrl);
 }
@@ -78295,6 +78964,7 @@ async function buildUserProfile(mcpUrl, bank, opts) {
 }
 
 // src/web/api.ts
+init_hindsight();
 init_audit_reader();
 
 // src/scheduler/dispatch.ts
@@ -82307,6 +82977,7 @@ var NVIDIA_TOOLKIT_INSTALL_HINT = "https://docs.nvidia.com/datacenter/cloud-nati
 
 // src/cli/setup.ts
 init_host_capabilities();
+init_hindsight();
 init_client();
 init_posthog();
 
@@ -82852,7 +83523,11 @@ async function resolveLiteLLMForHindsight2(config) {
   const result = await getViaBrokerStructured("litellm/hindsight/api-key").catch(() => null);
   if (!result || result.kind !== "ok" || result.entry.kind !== "string")
     return;
-  return { baseUrl: topLiteLLM.base_url, apiKey: result.entry.value };
+  return {
+    baseUrl: topLiteLLM.base_url,
+    apiKey: result.entry.value,
+    model: config.memory?.config?.llm_model
+  };
 }
 async function stepMemoryBackend(config, nonInteractive, switchroomConfigPath) {
   stepHeader(6, "Memory backend", STEP_ACTIVE);
@@ -82913,17 +83588,45 @@ async function stepMemoryBackend(config, nonInteractive, switchroomConfigPath) {
     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}`));
+    return;
+  }
+  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}`));
+      return;
+    }
+    conflict = await preflightHindsightPorts(ports);
+    if (conflict) {
+      const stillHeldBy = conflict.holder ? ` (held by ${conflict.holder})` : "";
+      console.log(source_default.red(`  Refusing to start Hindsight: port ${conflict.port} is still occupied${stillHeldBy} after reassignment. Free it and re-run \`switchroom setup\`.`));
+      return;
+    }
+    console.log(source_default.green(`  Reassigned Hindsight to port ${ports.apiPort}/${ports.uiPort}.`));
+  }
   const spin = spinner("Starting Hindsight Docker container...");
   try {
     const litellmCfg = await resolveLiteLLMForHindsight2(config);
-    startHindsight(undefined, litellmCfg);
+    startHindsight(ports, litellmCfg, undefined, config.hindsight?.llm);
     if (litellmCfg) {
       console.log(source_default.gray("  LiteLLM routing enabled (--network host, ANTHROPIC_BASE_URL set)."));
     }
     if (isHindsightRunning()) {
       spin.stop(source_default.green(`${STEP_DONE} Hindsight container started (switchroom-hindsight)`));
-      console.log(source_default.gray("  API: http://localhost:8888/mcp"));
-      console.log(source_default.gray("  UI:  http://localhost:9999"));
+      console.log(source_default.gray(`  API: http://localhost:${ports.apiPort}/mcp`));
+      console.log(source_default.gray(`  UI:  http://localhost:${ports.uiPort}`));
     } else {
       spin.stop(source_default.yellow("Container started but may still be initializing"));
     }
@@ -83450,6 +84153,22 @@ var UPDATE_RESULT_SENTINEL = "SWITCHROOM_UPDATE_RESULT:";
 function encodeUpdateResultLine(payload) {
   return `${UPDATE_RESULT_SENTINEL}${JSON.stringify(payload)}`;
 }
+function resolveHindsightPinTag(opts) {
+  if (typeof opts.hindsightPinTag === "string") {
+    return opts.hindsightPinTag || undefined;
+  }
+  if (opts.channel)
+    return;
+  let candidate = opts.pin;
+  if (!candidate) {
+    try {
+      candidate = loadConfig().release?.pin ?? undefined;
+    } catch {
+      candidate = undefined;
+    }
+  }
+  return candidate && /^v\d+\.\d+\.\d+$/.test(candidate) ? candidate : undefined;
+}
 function planUpdate(opts) {
   const composePath = opts.composePath ?? DEFAULT_COMPOSE_PATH;
   const runner = opts.runner ?? defaultRunner2;
@@ -83596,10 +84315,14 @@ function planUpdate(opts) {
   }
   steps.push({
     name: "refresh-hindsight",
-    description: "switchroom memory setup --recreate \u2014 pull latest hindsight image + recreate the memory singleton (standalone container, reusing its current port)",
+    description: "switchroom memory setup --recreate \u2014 pull the hindsight image (pinned to the release target when set, else :latest) + recreate the memory singleton (reusing its current port)",
     skipReason: !memoryBackendHindsight ? "memory.backend is not hindsight \u2014 no hindsight singleton to refresh" : opts.skipImages ? "--skip-images flag set" : undefined,
     run: () => {
-      const r = runner(process.execPath, [scriptPath, "memory", "setup", "--recreate"]);
+      const pinTag = resolveHindsightPinTag(opts);
+      const setupArgs = ["memory", "setup", "--recreate"];
+      if (pinTag)
+        setupArgs.push("--tag", pinTag);
+      const r = runner(process.execPath, [scriptPath, ...setupArgs]);
       if (r.status !== 0)
         throw new Error("switchroom memory setup --recreate failed");
     }
@@ -83963,6 +84686,7 @@ import { homedir as homedir39 } from "node:os";
 init_operator_uid();
 init_atomic();
 init_audit_reader();
+init_hindsight();
 function normalizeVersion(v) {
   return v.trim().replace(/^v/, "");
 }
@@ -86902,7 +87626,7 @@ import { existsSync as existsSync72, readFileSync as readFileSync63, readdirSync
 import { resolve as resolve45, join as join71 } from "node:path";
 import { createHash as createHash14 } from "node:crypto";
 init_merge();
-init_hindsight();
+init_hindsight2();
 function formatBytes(bytes) {
   return `${bytes.toLocaleString()} bytes`;
 }
@@ -87323,6 +88047,8 @@ async function claimWorktree(input, codeRepos) {
     const baseDir = worktreesBaseDir();
     mkdirSync38(baseDir, { recursive: true });
     worktreePath = join73(baseDir, `${id}-${taskSuffix}`);
+    const ambientOwner = process.env.SWITCHROOM_AGENT_NAME;
+    const ownerAgent = input.ownerAgent ?? (ambientOwner != null && ambientOwner !== "" ? ambientOwner : undefined);
     const now = new Date().toISOString();
     const record2 = {
       id,
@@ -87332,7 +88058,7 @@ async function claimWorktree(input, codeRepos) {
       path: worktreePath,
       createdAt: now,
       heartbeatAt: now,
-      ownerAgent: input.ownerAgent
+      ownerAgent
     };
     writeRecord(record2);
   } finally {