@wrongstack/core 0.309.0 → 0.310.0

package/dist/storage/index.js

@@ -1,867 +1,31 @@
-// src/agent-status-helpers.ts
-var TOOL_TEXT_CAP = 360;
-var TOUCHED_FILE_LIMIT = 200;
-var TODO_TEXT_CAP = 360;
-var TODO_LIMIT = 32;
-function lineCount(value) {
-  return value.length === 0 ? 0 : value.split(/\r?\n/).length;
-}
-function patchDelta(value) {
-  let addedLines = 0;
-  let removedLines = 0;
-  const hunkStart = value.indexOf("@@");
-  if (hunkStart === -1) return { addedLines, removedLines };
-  for (const line of value.slice(hunkStart).split(/\r?\n/)) {
-    if (line.startsWith("+++") || line.startsWith("---")) continue;
-    if (line.startsWith("+")) addedLines += 1;
-    else if (line.startsWith("-")) removedLines += 1;
-  }
-  return { addedLines, removedLines };
-}
-function compactText(value) {
-  return value.length <= TOOL_TEXT_CAP ? value : `${value.slice(0, TOOL_TEXT_CAP - 1)}\u2026`;
-}
-function boundedText(value, cap) {
-  const trimmed = value.trim();
-  return trimmed.length <= cap ? trimmed : `${trimmed.slice(0, cap - 1)}\u2026`;
-}
-function compactTodos(value) {
-  if (!Array.isArray(value)) return void 0;
-  const todos = [];
-  for (const candidate of value) {
-    if (typeof candidate !== "object" || candidate === null) continue;
-    const todo = candidate;
-    const id = typeof todo["id"] === "string" ? todo["id"].trim() : "";
-    const content = typeof todo["content"] === "string" ? boundedText(todo["content"], TODO_TEXT_CAP) : "";
-    const status = todo["status"];
-    if (!id || !content || status !== "pending" && status !== "in_progress" && status !== "completed") {
-      continue;
-    }
-    const activeForm = typeof todo["activeForm"] === "string" ? boundedText(todo["activeForm"], TODO_TEXT_CAP) : void 0;
-    todos.push({ id, content, status, ...activeForm ? { activeForm } : {} });
-    if (todos.length >= TODO_LIMIT) break;
-  }
-  return todos;
-}
-function compactToolInput(input) {
-  if (!input || typeof input !== "object" || Array.isArray(input)) {
-    return typeof input === "string" ? { input: compactText(input) } : {};
-  }
-  const source = input;
-  const safe = {};
-  const safeKeys = [
-    "file_path",
-    "filePath",
-    "path",
-    "filename",
-    "target_file",
-    "targetFile",
-    "line",
-    "start_line",
-    "startLine",
-    "end_line",
-    "endLine",
-    "offset",
-    "limit",
-    "command",
-    "cmd",
-    "url",
-    "href",
-    "uri",
-    "query",
-    "pattern"
-  ];
-  for (const key of safeKeys) {
-    const value = source[key];
-    if (typeof value === "string") safe[key] = compactText(value);
-    else if (typeof value === "number" || typeof value === "boolean") safe[key] = value;
-  }
-  const content = [source["content"], source["text"], source["data"]].find(
-    (value) => typeof value === "string"
-  );
-  const oldText = [source["old_string"], source["oldString"], source["search"]].find(
-    (value) => typeof value === "string"
+// src/storage/board-store-port.ts
+var notWired = () => {
+  throw new Error(
+    "Kanban BoardStorePort is not wired \u2014 register the implementation at the CLI composition root (see setBoardStorePort)."
   );
-  const newText = [source["new_string"], source["newString"], source["replacement"]].find(
-    (value) => typeof value === "string"
-  );
-  const patch = [source["patch"], source["diff"]].find(
-    (value) => typeof value === "string"
-  );
-  const delta = patch ? patchDelta(patch) : void 0;
-  return {
-    ...Object.keys(safe).length > 0 ? { input: safe } : {},
-    ...content !== void 0 ? { inputLines: lineCount(content) } : {},
-    ...oldText !== void 0 ? { oldLines: lineCount(oldText) } : {},
-    ...newText !== void 0 ? { newLines: lineCount(newText) } : {},
-    ...delta && delta.addedLines > 0 ? { addedLines: delta.addedLines } : {},
-    ...delta && delta.removedLines > 0 ? { removedLines: delta.removedLines } : {}
-  };
-}
-function completedToolReceipt(payload, pending) {
-  const completedAt = Date.now();
-  const durationMs = Math.max(
-    0,
-    payload.durationMs ?? completedAt - (pending?.startedAt ?? completedAt)
-  );
-  const compact = compactToolInput(payload.input ?? pending?.input);
-  return {
-    id: payload.id ?? `${payload.name}:${completedAt}`,
-    name: payload.name,
-    startedAt: pending?.startedAt ?? Math.max(0, completedAt - durationMs),
-    completedAt,
-    durationMs,
-    ok: payload.ok !== false,
-    ...compact,
-    ...payload.output !== void 0 ? { output: compactText(payload.output) } : {},
-    ...payload.outputLines !== void 0 ? { outputLines: payload.outputLines } : {},
-    ...payload.outputBytes !== void 0 ? { outputBytes: payload.outputBytes } : {},
-    ...payload.outputTokens !== void 0 ? { outputTokens: payload.outputTokens } : {}
-  };
-}
-function emptyActivityTotals() {
-  return {
-    filesTouched: [],
-    reads: 0,
-    writes: 0,
-    edits: 0,
-    terminalCalls: 0,
-    webCalls: 0,
-    searches: 0,
-    otherCalls: 0,
-    mailReceived: 0,
-    mailSent: 0,
-    linesRead: 0,
-    linesWritten: 0,
-    linesAdded: 0,
-    linesRemoved: 0
-  };
-}
-function addMailTotal(current, direction) {
-  const next = { ...current ?? emptyActivityTotals() };
-  if (direction === "incoming") next.mailReceived += 1;
-  else next.mailSent += 1;
-  return next;
-}
-function toolActivityKind(name) {
-  const normalized = name.toLowerCase().replace(/[.:/-]+/g, "_");
-  if (/^(read|view|open_file|read_file)|file_read/.test(normalized)) return "read";
-  if (/^(write|create|save)|file_write/.test(normalized)) return "write";
-  if (/edit|update|patch|replace|apply_patch/.test(normalized)) return "edit";
-  if (/bash|shell|terminal|exec|command|powershell|cmd/.test(normalized)) return "terminal";
-  if (/fetch|browser|browse|http|url|web/.test(normalized)) return "web";
-  if (/search|grep|find|glob|query/.test(normalized)) return "search";
-  return "other";
-}
-function receiptFilePath(receipt) {
-  if (!receipt.input || typeof receipt.input !== "object" || Array.isArray(receipt.input)) {
-    return void 0;
-  }
-  const input = receipt.input;
-  for (const key of ["file_path", "filePath", "path", "filename", "target_file", "targetFile"]) {
-    const value = input[key];
-    if (typeof value === "string" && value.trim()) return value.trim();
-  }
-  return void 0;
-}
-function addToolActivity(current, receipt) {
-  const next = {
-    ...current ?? emptyActivityTotals(),
-    filesTouched: [...current?.filesTouched ?? []]
-  };
-  const kind = toolActivityKind(receipt.name);
-  if (kind === "read") {
-    next.reads += 1;
-    next.linesRead += receipt.outputLines ?? 0;
-  } else if (kind === "write") {
-    next.writes += 1;
-    next.linesWritten += receipt.inputLines ?? 0;
-  } else if (kind === "edit") {
-    next.edits += 1;
-    next.linesAdded += receipt.addedLines ?? receipt.newLines ?? 0;
-    next.linesRemoved += receipt.removedLines ?? receipt.oldLines ?? 0;
-  } else if (kind === "terminal") next.terminalCalls += 1;
-  else if (kind === "web") next.webCalls += 1;
-  else if (kind === "search") next.searches += 1;
-  else next.otherCalls += 1;
-  const filePath = receiptFilePath(receipt);
-  if (filePath && !next.filesTouched.includes(filePath) && next.filesTouched.length < TOUCHED_FILE_LIMIT) {
-    next.filesTouched.push(filePath);
-  }
-  return next;
-}
-function clampPct(pct) {
-  if (!Number.isFinite(pct)) return 0;
-  return Math.max(0, Math.min(100, pct));
-}
-
-// src/agent-status-tracker.ts
-var AGENT_REAP_MS = 3e4;
-var AGENT_SWEEP_INTERVAL_MS = 1e4;
-var PENDING_TOOL_TTL_MS = 3e5;
-var PARTIAL_TEXT_CAP = 1200;
-var PARTIAL_FLUSH_THROTTLE_MS = 300;
-var RECENT_TOOL_LIMIT = 12;
-var RECENT_MAIL_LIMIT = 12;
-var TASK_TEXT_CAP = 1200;
-var PROMPT_TEXT_CAP = 6e3;
-var AgentStatusTracker = class _AgentStatusTracker {
-  events;
-  registry;
-  sessionId;
-  leaderName;
-  // Live agent map: agentId → AgentEntry
-  agents = /* @__PURE__ */ new Map();
-  // Last full agent list flushed (leader + subagents). Lets external consumers
-  // read the current state synchronously without re-deriving it.
-  lastAgents = [];
-  // Leader tracking
-  leaderStatus = "idle";
-  leaderCurrentTool;
-  leaderCurrentTask;
-  leaderIterations = 0;
-  leaderToolCalls = 0;
-  leaderCostUsd = 0;
-  leaderTokensIn = 0;
-  leaderTokensOut = 0;
-  leaderCtxPct;
-  leaderModel;
-  leaderPartialText = "";
-  leaderStartedAt;
-  leaderRecentTools = [];
-  leaderRecentMail = [];
-  leaderTodos = [];
-  leaderLatestPrompt;
-  leaderLatestPromptAt;
-  leaderActivity = emptyActivityTotals();
-  leaderPendingTools = /* @__PURE__ */ new Map();
-  subagentPendingTools = /* @__PURE__ */ new Map();
-  seenIncomingMail = /* @__PURE__ */ new Set();
-  seenOutgoingMail = /* @__PURE__ */ new Set();
-  static SEEN_MAIL_LIMIT = 1e4;
-  rememberMailId(seen, messageId) {
-    if (seen.has(messageId)) return false;
-    seen.add(messageId);
-    if (seen.size > _AgentStatusTracker.SEEN_MAIL_LIMIT) {
-      const oldest = seen.values().next().value;
-      if (oldest !== void 0) seen.delete(oldest);
-    }
-    return true;
-  }
-  unsubscribers = [];
-  onUpdate;
-  sweepTimer = null;
-  partialTimer = null;
-  /** Serialize registry writes so concurrent flush() calls don't race. */
-  flushPromise = null;
-  constructor(opts) {
-    this.events = opts.events;
-    this.registry = opts.registry;
-    this.sessionId = opts.sessionId;
-    this.leaderName = opts.leaderName ?? "leader";
-    this.onUpdate = opts.onUpdate;
-  }
-  /** Current full agent list (leader + subagents) as of the last flush. */
-  getAgents() {
-    return this.lastAgents.length > 0 ? [...this.lastAgents] : [];
-  }
-  start() {
-    this.stop();
-    const on = (pattern, fn) => this.events.onPattern(pattern, (event, payload) => {
-      if (!this.acceptsSession(payload)) return;
-      fn(event, payload);
-    });
-    this.unsubscribers.push(
-      on("agent.run.started", (_event, payload) => {
-        const p = payload;
-        this.markLeaderStarted(p?.at);
-        this.captureLeaderContext(p?.ctx);
-        if (p?.model) this.leaderModel = p.model;
-        if (p?.inputText?.trim()) {
-          const prompt = boundedText(p.inputText, PROMPT_TEXT_CAP);
-          this.leaderLatestPrompt = prompt;
-          this.leaderLatestPromptAt = p.at ? Date.parse(p.at) : Date.now();
-          if (!Number.isFinite(this.leaderLatestPromptAt)) this.leaderLatestPromptAt = Date.now();
-          this.leaderCurrentTask = boundedText(p.inputText, TASK_TEXT_CAP);
-        }
-        this.leaderStatus = "running";
-        this.leaderIterations++;
-        this.flush();
-      })
-    );
-    this.unsubscribers.push(
-      on("iteration.started", (_e, payload) => {
-        const p = payload;
-        const ctx = p?.ctx;
-        this.markLeaderStarted();
-        this.leaderStatus = "running";
-        if (typeof p?.index === "number") {
-          this.leaderIterations = Math.max(this.leaderIterations, p.index + 1);
-        }
-        if (!ctx) {
-          this.flush();
-          return;
-        }
-        this.captureLeaderContext(ctx);
-        this.flush();
-      })
-    );
-    this.unsubscribers.push(
-      on("agent.run.completed", (_event, payload) => {
-        const p = payload;
-        this.captureLeaderContext(p?.ctx);
-        this.leaderStatus = p?.status === "failed" ? "error" : "idle";
-        this.leaderCurrentTool = void 0;
-        this.leaderCurrentTask = void 0;
-        this.leaderPartialText = "";
-        if (this.leaderStatus === "idle") this.leaderStartedAt = void 0;
-        this.flush();
-      })
-    );
-    this.unsubscribers.push(
-      on("agent.run.error", (_event, payload) => {
-        const p = payload;
-        this.captureLeaderContext(p?.ctx);
-        this.leaderStatus = "error";
-        this.leaderCurrentTool = void 0;
-        this.leaderCurrentTask = void 0;
-        this.leaderPartialText = "";
-        this.flush();
-      })
-    );
-    this.unsubscribers.push(
-      on("iteration.completed", (_event, payload) => {
-        const p = payload;
-        this.captureLeaderContext(p?.ctx);
-        this.flush();
-      })
-    );
-    this.unsubscribers.push(
-      on("tool.started", (_event, payload) => {
-        const p = payload;
-        if (p?.name) {
-          this.markLeaderStarted();
-          this.leaderCurrentTool = p.name;
-          this.leaderToolCalls++;
-          this.leaderPendingTools.set(p.id ?? p.name, {
-            name: p.name,
-            input: p.input,
-            startedAt: Date.now()
-          });
-        }
-        this.leaderStatus = "running";
-        this.flush();
-      })
-    );
-    this.unsubscribers.push(
-      on("tool.executed", (_event, payload) => {
-        const p = payload;
-        if (p?.name) {
-          const key = p.id ?? p.name;
-          const receipt = completedToolReceipt(p, this.leaderPendingTools.get(key));
-          this.leaderRecentTools = [receipt, ...this.leaderRecentTools].slice(0, RECENT_TOOL_LIMIT);
-          this.leaderActivity = addToolActivity(this.leaderActivity, receipt);
-          this.leaderPendingTools.delete(key);
-        }
-        this.leaderCurrentTool = void 0;
-        this.flush();
-      })
-    );
-    this.unsubscribers.push(
-      on("brain.ask_human", () => {
-        this.markLeaderStarted();
-        this.leaderStatus = "waiting_user";
-        this.flush();
-      })
-    );
-    const recordMail = (direction, payload) => {
-      const p = payload;
-      if (!p?.messageId) return;
-      const seen = direction === "incoming" ? this.seenIncomingMail : this.seenOutgoingMail;
-      if (!this.rememberMailId(seen, p.messageId)) return;
-      const receipt = {
-        id: p.messageId,
-        direction,
-        from: p.from ?? "?",
-        to: p.to ?? (direction === "incoming" ? "leader" : "?"),
-        type: p.type ?? "note",
-        subject: p.subject ?? "Message",
-        at: Date.now()
-      };
-      const directAgentId = direction === "outgoing" ? p.from : p.to;
-      const entry = directAgentId ? this.agents.get(directAgentId) : void 0;
-      if (entry) {
-        entry.recentMail = [receipt, ...entry.recentMail ?? []].slice(0, RECENT_MAIL_LIMIT);
-        entry.activity = addMailTotal(entry.activity, direction);
-      } else {
-        this.leaderRecentMail = [receipt, ...this.leaderRecentMail].slice(0, RECENT_MAIL_LIMIT);
-        this.leaderActivity = addMailTotal(this.leaderActivity, direction);
-      }
-      this.flush();
-    };
-    this.unsubscribers.push(
-      on("mailbox.message_sent", (_event, payload) => recordMail("outgoing", payload)),
-      on("mailbox.received", (_event, payload) => recordMail("incoming", payload))
-    );
-    this.unsubscribers.push(
-      on("llm.stream_started", () => {
-        this.markLeaderStarted();
-        this.leaderStatus = "streaming";
-        this.leaderPartialText = "";
-        this.flush();
-      })
-    );
-    this.unsubscribers.push(
-      on("provider.text_delta", (_e, payload) => {
-        const p = payload;
-        const text = p?.text;
-        if (!text) return;
-        this.markLeaderStarted();
-        this.captureLeaderContext(p?.ctx);
-        this.leaderStatus = "streaming";
-        const next = this.leaderPartialText + text;
-        this.leaderPartialText = next.length > PARTIAL_TEXT_CAP ? next.slice(next.length - PARTIAL_TEXT_CAP) : next;
-        this.schedulePartialFlush();
-      })
-    );
-    this.unsubscribers.push(
-      on("provider.response", (_e, payload) => {
-        const p = payload;
-        this.captureLeaderContext(p?.ctx);
-        this.flush();
-      })
-    );
-    this.unsubscribers.push(
-      on("provider.fallback", (_e, payload) => {
-        const p = payload;
-        if (p?.to?.model) {
-          this.leaderModel = p.to.providerId ? `${p.to.providerId}/${p.to.model}` : p.to.model;
-          this.flush();
-        }
-      })
-    );
-    this.unsubscribers.push(
-      on("ctx.pct", (_e, payload) => {
-        const p = payload;
-        if (typeof p?.load === "number" && Number.isFinite(p.load)) {
-          this.leaderCtxPct = clampPct(Math.round(p.load * 100));
-          this.flush();
-        }
-      })
-    );
-    this.unsubscribers.push(
-      on("token.accounted", (_e, payload) => {
-        const p = payload;
-        if (!p) return;
-        this.leaderTokensIn += p.usage?.input ?? 0;
-        this.leaderTokensOut += p.usage?.output ?? 0;
-        this.leaderCostUsd += p.cost?.total ?? 0;
-        this.flush();
-      })
-    );
-    const touch = (id) => {
-      let entry = this.agents.get(id);
-      if (!entry) {
-        const now = (/* @__PURE__ */ new Date()).toISOString();
-        entry = {
-          id,
-          name: id,
-          status: "idle",
-          iterations: 0,
-          toolCalls: 0,
-          startedAt: now,
-          lastActivityAt: now
-        };
-        this.agents.set(id, entry);
-      }
-      entry.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
-      return entry;
-    };
-    this.unsubscribers.push(
-      on("subagent.spawned", (_e, payload) => {
-        const p = payload;
-        if (!p?.subagentId) return;
-        const entry = touch(p.subagentId);
-        entry.name = p.name?.trim() || entry.name;
-        if (p.model) entry.model = p.model;
-        if (p.taskId) entry.taskId = p.taskId;
-        if (p.description?.trim()) entry.currentTask = boundedText(p.description, TASK_TEXT_CAP);
-        if (!entry.startedAt) entry.startedAt = (/* @__PURE__ */ new Date()).toISOString();
-        entry.status = "running";
-        this.flush();
-      })
-    );
-    this.unsubscribers.push(
-      on("subagent.ctx_pct", (_e, payload) => {
-        const p = payload;
-        if (!p?.subagentId) return;
-        const entry = touch(p.subagentId);
-        if (typeof p.load === "number") entry.ctxPct = clampPct(Math.round(p.load * 100));
-        this.flush();
-      })
-    );
-    this.unsubscribers.push(
-      on("subagent.task_started", (_e, payload) => {
-        const p = payload;
-        if (!p?.subagentId) return;
-        const entry = touch(p.subagentId);
-        entry.status = "running";
-        if (p.taskId) entry.taskId = p.taskId;
-        if (p.description?.trim()) entry.currentTask = boundedText(p.description, TASK_TEXT_CAP);
-        if (!entry.startedAt) entry.startedAt = (/* @__PURE__ */ new Date()).toISOString();
-        entry.iterations++;
-        this.flush();
-      })
-    );
-    this.unsubscribers.push(
-      on("subagent.tool_started", (_e, payload) => {
-        const p = payload;
-        if (!p?.subagentId || !p.name) return;
-        const entry = touch(p.subagentId);
-        entry.status = "running";
-        entry.currentTool = p.name;
-        this.subagentPendingTools.set(`${p.subagentId}:${p.id ?? p.name}`, {
-          name: p.name,
-          input: p.input,
-          startedAt: Date.now()
-        });
-        this.flush();
-      })
-    );
-    this.unsubscribers.push(
-      on("subagent.tool_executed", (_e, payload) => {
-        const p = payload;
-        if (!p?.subagentId || !p.name) return;
-        const entry = touch(p.subagentId);
-        entry.status = "running";
-        if (!entry.startedAt) entry.startedAt = (/* @__PURE__ */ new Date()).toISOString();
-        const key = `${p.subagentId}:${p.id ?? p.name}`;
-        const receipt = completedToolReceipt(p, this.subagentPendingTools.get(key));
-        entry.recentTools = [receipt, ...entry.recentTools ?? []].slice(0, RECENT_TOOL_LIMIT);
-        entry.activity = addToolActivity(entry.activity, receipt);
-        this.subagentPendingTools.delete(key);
-        entry.currentTool = void 0;
-        entry.toolCalls++;
-        this.flush();
-      })
-    );
-    this.unsubscribers.push(
-      on("subagent.iteration_summary", (_e, payload) => {
-        const p = payload;
-        if (!p?.subagentId) return;
-        const entry = touch(p.subagentId);
-        entry.status = "running";
-        if (!entry.startedAt) entry.startedAt = (/* @__PURE__ */ new Date()).toISOString();
-        if (typeof p.iteration === "number") entry.iterations = p.iteration;
-        if (typeof p.toolCalls === "number") entry.toolCalls = p.toolCalls;
-        if (typeof p.costUsd === "number") entry.costUsd = p.costUsd;
-        if (p.currentTool) entry.currentTool = p.currentTool;
-        if (typeof p.partialText === "string") {
-          entry.partialText = p.partialText.length > PARTIAL_TEXT_CAP ? p.partialText.slice(p.partialText.length - PARTIAL_TEXT_CAP) : p.partialText;
-        }
-        this.flush();
-      })
-    );
-    this.unsubscribers.push(
-      on("subagent.task_completed", (_e, payload) => {
-        const p = payload;
-        if (!p?.subagentId) return;
-        const entry = this.agents.get(p.subagentId);
-        if (!entry) return;
-        entry.status = p.status === "failed" || p.status === "timeout" ? "error" : "idle";
-        entry.currentTool = void 0;
-        entry.currentTask = void 0;
-        entry.taskId = void 0;
-        entry.partialText = void 0;
-        if (typeof p.iterations === "number") entry.iterations = p.iterations;
-        if (typeof p.toolCalls === "number") entry.toolCalls = p.toolCalls;
-        entry.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
-        this.flush();
-      })
-    );
-    this.unsubscribers.push(
-      on("subagent.stopped", (_e, payload) => {
-        const p = payload;
-        if (!p?.subagentId) return;
-        if (this.agents.delete(p.subagentId)) this.flush();
-      })
-    );
-    this.unsubscribers.push(
-      on("subagent.removed", (_e, payload) => {
-        const p = payload;
-        if (!p?.subagentId) return;
-        if (this.agents.delete(p.subagentId)) this.flush();
-      })
-    );
-    this.sweepTimer = setInterval(() => this.sweep(), AGENT_SWEEP_INTERVAL_MS);
-    if (typeof this.sweepTimer.unref === "function") this.sweepTimer.unref();
-  }
-  stop() {
-    for (const unsub of this.unsubscribers) {
-      try {
-        unsub();
-      } catch {
-      }
-    }
-    this.unsubscribers = [];
-    if (this.sweepTimer) {
-      clearInterval(this.sweepTimer);
-      this.sweepTimer = null;
-    }
-    if (this.partialTimer) {
-      clearTimeout(this.partialTimer);
-      this.partialTimer = null;
-    }
-    this.leaderPendingTools.clear();
-    this.subagentPendingTools.clear();
-  }
-  /**
-   * Coalesce streamed-text flushes: at most one registry write per
-   * {@link PARTIAL_FLUSH_THROTTLE_MS} while text streams in, so per-token
-   * deltas never thrash the cross-process registry file.
-   */
-  schedulePartialFlush() {
-    if (this.partialTimer) return;
-    this.partialTimer = setTimeout(() => {
-      this.partialTimer = null;
-      this.flush();
-    }, PARTIAL_FLUSH_THROTTLE_MS);
-    if (typeof this.partialTimer.unref === "function") this.partialTimer.unref();
-  }
-  /**
-   * Remove subagents that have been finished (idle/error) for longer than
-   * {@link AGENT_REAP_MS}. Running / streaming / waiting_user agents are kept
-   * regardless of age — only *not-working* agents are reaped.
-   *
-   * Also trims orphaned PendingTool entries older than {@link PENDING_TOOL_TTL_MS}
-   * from both leader and subagent pending-tools Maps. Piggybacks on the same
-   * 10-second interval to avoid a second timer.
-   */
-  sweep() {
-    const now = Date.now();
-    let removed = false;
-    for (const [id, a] of this.agents) {
-      const finished = a.status !== "running" && a.status !== "streaming" && a.status !== "waiting_user";
-      const age = now - Date.parse(a.lastActivityAt);
-      if (finished && Number.isFinite(age) && age > AGENT_REAP_MS) {
-        this.agents.delete(id);
-        removed = true;
-      }
-    }
-    this.trimPendingTools(this.leaderPendingTools, now);
-    this.trimPendingTools(this.subagentPendingTools, now);
-    if (removed) this.flush();
-  }
-  /**
-   * Evict pending-tool entries whose `startedAt` is older than
-   * {@link PENDING_TOOL_TTL_MS}. These are tool.started / subagent.tool_started
-   * events whose matching tool.executed / subagent.tool_executed never arrived
-   * (provider crash, abort, process kill). Without periodic cleanup the
-   * Maps retain the full tool-input objects for the process lifetime.
-   */
-  trimPendingTools(map, now) {
-    const cutoff = now - PENDING_TOOL_TTL_MS;
-    for (const [key, entry] of map) {
-      if (entry.startedAt < cutoff) map.delete(key);
-    }
-  }
-  flush() {
-    const leaderEntry = {
-      id: "leader",
-      name: this.leaderName,
-      startedAt: this.leaderStartedAt,
-      status: this.leaderStatus,
-      currentTool: this.leaderCurrentTool,
-      currentTask: this.leaderCurrentTask,
-      iterations: this.leaderIterations,
-      toolCalls: this.leaderToolCalls,
-      costUsd: this.leaderCostUsd,
-      tokensIn: this.leaderTokensIn,
-      tokensOut: this.leaderTokensOut,
-      ctxPct: this.leaderCtxPct,
-      model: this.leaderModel,
-      partialText: this.leaderPartialText || void 0,
-      recentTools: this.leaderRecentTools,
-      recentMail: this.leaderRecentMail,
-      todos: this.leaderTodos,
-      latestPrompt: this.leaderLatestPrompt,
-      latestPromptAt: this.leaderLatestPromptAt,
-      activity: this.leaderActivity,
-      lastActivityAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    const allAgents = [leaderEntry, ...this.agents.values()];
-    this.lastAgents = allAgents;
-    try {
-      this.events.emit("session.agents_updated", {
-        sessionId: this.currentSessionId(),
-        agents: allAgents
-      });
-    } catch {
-    }
-    const write = this.registry.updateAgents(allAgents);
-    const chain = write.then(() => {
-      try {
-        this.onUpdate?.();
-      } catch {
-      }
-    });
-    if (this.flushPromise) {
-      this.flushPromise = this.flushPromise.then(
-        () => chain,
-        () => chain
-      ).catch(() => void 0);
-    } else {
-      this.flushPromise = chain.catch(() => void 0);
-    }
-  }
-  currentSessionId() {
-    return typeof this.sessionId === "function" ? this.sessionId() : this.sessionId;
-  }
-  acceptsSession(payload) {
-    const expected = this.currentSessionId();
-    if (!expected) return true;
-    if (typeof payload !== "object" || payload === null) return true;
-    const actual = payload.sessionId;
-    return typeof actual !== "string" || actual.length === 0 || actual === expected;
-  }
-  markLeaderStarted(startedAt) {
-    if (this.leaderStartedAt && (this.leaderStatus === "running" || this.leaderStatus === "streaming" || this.leaderStatus === "waiting_user")) {
-      return;
-    }
-    this.leaderStartedAt = startedAt ?? (/* @__PURE__ */ new Date()).toISOString();
-  }
-  captureLeaderContext(ctx) {
-    if (typeof ctx !== "object" || ctx === null) return;
-    const c = ctx;
-    if (typeof c.model === "string" && c.model.length > 0) this.leaderModel = c.model;
-    const todos = compactTodos(c.todos);
-    if (todos !== void 0) this.leaderTodos = todos;
-    const metaLimit = c.meta?.["effectiveMaxContext"];
-    const providerMax = c.provider?.capabilities?.maxContext;
-    const maxContext = typeof metaLimit === "number" && metaLimit > 0 ? metaLimit : typeof providerMax === "number" && providerMax > 0 ? providerMax : void 0;
-    if (typeof c.lastRequestTokens === "number" && c.lastRequestTokens > 0 && maxContext !== void 0) {
-      this.leaderCtxPct = clampPct(Math.round(c.lastRequestTokens / maxContext * 100));
-    }
-  }
 };
-
-// src/fleet-notifier.ts
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-
-// src/utils/pid.ts
-function isPidAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  if (pid === process.pid) return true;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    const code = err.code;
-    if (code === "EPERM") return true;
-    return false;
-  }
+var port = void 0;
+function setBoardStorePort(impl) {
+  port = impl;
 }
-
-// src/fleet-notifier.ts
-var INSTANCES_FILE = "webui-instances.json";
-var DISCOVERY_TTL_MS = 2500;
-var COALESCE_MS = 50;
-var POST_TIMEOUT_MS = 500;
-var pidAlive = isPidAlive;
-function normRoot(root) {
-  const resolved = path.resolve(root);
-  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+function boardStore() {
+  return port ?? notWired();
 }
-var FleetNotifier = class {
-  baseDir;
-  projectRoot;
-  selfPid;
-  doPost;
-  cache = null;
-  timer = null;
-  disposed = false;
-  constructor(opts) {
-    this.baseDir = opts.baseDir;
-    this.projectRoot = normRoot(opts.projectRoot);
-    this.selfPid = opts.selfPid ?? process.pid;
-    this.doPost = opts.post ?? defaultPost;
-  }
-  /** Coalesced, best-effort nudge. Safe to call on every status change. */
-  notify() {
-    if (this.disposed || this.timer) return;
-    this.timer = setTimeout(() => {
-      this.timer = null;
-      void this.flush();
-    }, COALESCE_MS);
-    if (typeof this.timer.unref === "function") this.timer.unref();
-  }
-  /** Resolve same-project WebUI ping URLs (cached briefly). Exposed for tests. */
-  async endpoints() {
-    return (await this.targets()).map((t) => t.url);
-  }
-  /** Ping targets with their tokens (cached briefly). */
-  async targets() {
-    const now = Date.now();
-    if (this.cache && now - this.cache.at < DISCOVERY_TTL_MS) return this.cache.targets;
-    const targets = await this.discover();
-    this.cache = { at: now, targets };
-    return targets;
-  }
-  dispose() {
-    this.disposed = true;
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-  }
-  /** Re-scope notifications after an in-process project switch. */
-  setProjectRoot(projectRoot) {
-    this.projectRoot = normRoot(projectRoot);
-    this.cache = null;
-  }
-  async flush() {
-    const targets = await this.targets();
-    await Promise.all(targets.map((t) => this.doPost(t.url, t.token).catch(() => void 0)));
-  }
-  async discover() {
-    try {
-      const raw = await fs.readFile(path.join(this.baseDir, INSTANCES_FILE), "utf8");
-      const data = JSON.parse(raw);
-      const list = Array.isArray(data?.instances) ? data.instances : [];
-      return list.filter((i) => i && typeof i.httpPort === "number").filter((i) => i.pid !== this.selfPid).filter((i) => normRoot(i.projectRoot) === this.projectRoot).filter((i) => pidAlive(i.pid)).map((i) => {
-        const host = i.host === "0.0.0.0" || i.host === "::" || !i.host ? "127.0.0.1" : i.host;
-        return {
-          url: `http://${host}:${i.httpPort}/api/fleet/ping`,
-          token: typeof i.authToken === "string" ? i.authToken : void 0
-        };
-      });
-    } catch {
-      return [];
-    }
-  }
-};
-async function defaultPost(url, token) {
-  await fetch(url, {
-    method: "POST",
-    // The API requires a token on every bind (H3). Sent as a header rather
-    // than a query param so it never lands in an access log or the URL.
-    ...token ? { headers: { "x-ws-token": token } } : {},
-    signal: AbortSignal.timeout(POST_TIMEOUT_MS)
-  });
+function tryBoardStore() {
+  return port ?? null;
 }
 
 // src/session-catalog/client.ts
 import { spawn } from "node:child_process";
-import * as fs2 from "node:fs";
+import * as fs from "node:fs";
 import * as net from "node:net";
-import * as path3 from "node:path";
+import * as path2 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/session-catalog/endpoint.ts
 import { createHash } from "node:crypto";
 import * as os from "node:os";
-import * as path2 from "node:path";
+import * as path from "node:path";
 
 // src/session-catalog/protocol.ts
 var SESSION_CATALOG_PROTOCOL_VERSION = 1;
@@ -874,7 +38,7 @@ function encodeSessionCatalogMessage(message) {
 // src/session-catalog/endpoint.ts
 var SESSION_CATALOG_METADATA_FILE = ".session-catalog-server.json";
 function normalizedPath(value) {
-  const resolved = path2.resolve(value);
+  const resolved = path.resolve(value);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function sessionCatalogProjectServerKey(projectDir) {
@@ -885,10 +49,10 @@ function sessionCatalogProjectServerEndpoint(projectDir) {
   if (process.platform === "win32") {
     return `\\\\.\\pipe\\wrongstack-session-catalog-v${SESSION_CATALOG_PROTOCOL_VERSION}-${key}`;
   }
-  return path2.join(os.tmpdir(), `wssc-v${SESSION_CATALOG_PROTOCOL_VERSION}`, `${key}.sock`);
+  return path.join(os.tmpdir(), `wssc-v${SESSION_CATALOG_PROTOCOL_VERSION}`, `${key}.sock`);
 }
 function sessionCatalogProjectServerMetadataPath(projectDir) {
-  return path2.join(projectDir, SESSION_CATALOG_METADATA_FILE);
+  return path.join(projectDir, SESSION_CATALOG_METADATA_FILE);
 }
 
 // src/session-catalog/client.ts
@@ -912,22 +76,22 @@ function locateServer(moduleUrl, exists) {
   }
   return null;
 }
-function resolveSessionCatalogDaemonAvailability(moduleUrl = import.meta.url, exists = fs2.existsSync) {
+function resolveSessionCatalogDaemonAvailability(moduleUrl = import.meta.url, exists = fs.existsSync) {
   if (process.env["WRONGSTACK_SESSION_CATALOG_INLINE"] || process.env["WRONGSTACK_SESSION_CATALOG_SERVER"] === "0")
     return { kind: "inline-requested" };
   const url = locateServer(moduleUrl, exists);
   return url ? { kind: "available", url } : { kind: "missing-build" };
 }
-function resolveSessionCatalogProjectServerUrl(moduleUrl = import.meta.url, exists = fs2.existsSync) {
+function resolveSessionCatalogProjectServerUrl(moduleUrl = import.meta.url, exists = fs.existsSync) {
   const availability = resolveSessionCatalogDaemonAvailability(moduleUrl, exists);
   return availability.kind === "available" ? availability.url : null;
 }
 function normalize(value) {
-  const resolved = path3.resolve(value);
+  const resolved = path2.resolve(value);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function delay(ms) {
-  return new Promise((resolve14) => setTimeout(resolve14, ms));
+  return new Promise((resolve13) => setTimeout(resolve13, ms));
 }
 var SessionCatalogProjectClient = class {
   constructor(options) {
@@ -995,7 +159,7 @@ var SessionCatalogProjectClient = class {
     if (result.stopped) {
       const metadataPath = sessionCatalogProjectServerMetadataPath(this.options.projectDir);
       const deadline = Date.now() + 5e3;
-      while (fs2.existsSync(metadataPath) && Date.now() < deadline) await delay(20);
+      while (fs.existsSync(metadataPath) && Date.now() < deadline) await delay(20);
       if (result.pid && result.pid !== process.pid) {
         while (Date.now() < deadline) {
           try {
@@ -1017,8 +181,8 @@ var SessionCatalogProjectClient = class {
     this.socket = null;
     this.info = null;
     if (socket && !socket.destroyed)
-      await new Promise((resolve14) => {
-        socket.once("close", resolve14);
+      await new Promise((resolve13) => {
+        socket.once("close", resolve13);
         socket.end();
       });
   }
@@ -1056,7 +220,7 @@ var SessionCatalogProjectClient = class {
     this.info = null;
     this.authToken = void 0;
     this.buffer = "";
-    return new Promise((resolve14, reject) => {
+    return new Promise((resolve13, reject) => {
       const socket = net.createConnection(this.endpoint);
       this.socket = socket;
       socket.setEncoding("utf8");
@@ -1069,7 +233,7 @@ var SessionCatalogProjectClient = class {
         clearTimeout(timer);
         this.connectResolve = null;
         this.connectReject = null;
-        resolve14();
+        resolve13();
       };
       this.connectReject = (error) => {
         clearTimeout(timer);
@@ -1088,7 +252,7 @@ var SessionCatalogProjectClient = class {
     if (this.authToken === void 0) {
       try {
         const parsed = JSON.parse(
-          fs2.readFileSync(sessionCatalogProjectServerMetadataPath(this.options.projectDir), "utf8")
+          fs.readFileSync(sessionCatalogProjectServerMetadataPath(this.options.projectDir), "utf8")
         );
         if (typeof parsed.authToken === "string" && parsed.authToken)
           this.authToken = parsed.authToken;
@@ -1114,7 +278,7 @@ var SessionCatalogProjectClient = class {
     });
     if (encoded.length > SESSION_CATALOG_MAX_FRAME_CHARS)
       return Promise.reject(new Error("Session Catalog request exceeded frame limit"));
-    return new Promise((resolve14, reject) => {
+    return new Promise((resolve13, reject) => {
       const timer = setTimeout(() => {
         const pending = this.pending.get(id);
         if (!pending) return;
@@ -1126,7 +290,7 @@ var SessionCatalogProjectClient = class {
         );
       }, timeoutMs);
       timer.unref?.();
-      this.pending.set(id, { resolve: resolve14, reject, timer });
+      this.pending.set(id, { resolve: resolve13, reject, timer });
       socket.write(encoded);
     });
   }
@@ -1235,8 +399,8 @@ var SessionCatalogProjectClient = class {
 
 // src/session-catalog/registry.ts
 import { randomUUID } from "node:crypto";
-import * as fs3 from "node:fs/promises";
-import * as path4 from "node:path";
+import * as fs2 from "node:fs/promises";
+import * as path3 from "node:path";
 var HEARTBEAT_INTERVAL_MS = 5e3;
 var AGENT_WRITE_THROTTLE_MS = 300;
 var MAX_PROJECT_CLIENTS = 128;
@@ -1255,7 +419,7 @@ var ProjectSessionRegistry = class {
   agentTimer;
   lastAgentWriteAt = 0;
   bindingKey(projectDir) {
-    const resolved = path4.resolve(projectDir);
+    const resolved = path3.resolve(projectDir);
     return process.platform === "win32" ? resolved.toLowerCase() : resolved;
   }
   async closeBinding(binding) {
@@ -1265,7 +429,7 @@ var ProjectSessionRegistry = class {
     await binding.client.close();
   }
   binding(projectSlug2, projectRoot) {
-    const projectDir = path4.join(this.globalRoot, "projects", projectSlug2);
+    const projectDir = path3.join(this.globalRoot, "projects", projectSlug2);
     const key = this.bindingKey(projectDir);
     let binding = this.clients.get(key);
     if (!binding) {
@@ -1280,7 +444,7 @@ var ProjectSessionRegistry = class {
       }
       binding = {
         projectDir,
-        projectRoot: path4.resolve(projectRoot),
+        projectRoot: path3.resolve(projectRoot),
         client: new SessionCatalogProjectClient({ projectDir, projectRoot })
       };
       this.clients.set(key, binding);
@@ -1441,20 +605,20 @@ var ProjectSessionRegistry = class {
     }
   }
   async list() {
-    const projectsDir = path4.join(this.globalRoot, "projects");
+    const projectsDir = path3.join(this.globalRoot, "projects");
     let directories = [];
     try {
-      directories = (await fs3.readdir(projectsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).slice(0, 1e3).map((entry) => entry.name);
+      directories = (await fs2.readdir(projectsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).slice(0, 1e3).map((entry) => entry.name);
     } catch {
       return [];
     }
     const snapshots = await Promise.all(
       directories.map(async (slug) => {
-        const projectDir = path4.join(projectsDir, slug);
+        const projectDir = path3.join(projectsDir, slug);
         let client;
         try {
           const metadata = JSON.parse(
-            await fs3.readFile(sessionCatalogProjectServerMetadataPath(projectDir), "utf8")
+            await fs2.readFile(sessionCatalogProjectServerMetadataPath(projectDir), "utf8")
           );
           if (typeof metadata.projectRoot !== "string" || !metadata.projectRoot) return [];
           client = new SessionCatalogProjectClient({
@@ -1473,14 +637,14 @@ var ProjectSessionRegistry = class {
   }
   async listByProject(projectSlug2) {
     const current = this.current;
-    if (current && path4.basename(current.binding.projectDir) === projectSlug2) {
+    if (current && path3.basename(current.binding.projectDir) === projectSlug2) {
       return current.binding.client.call("list_live", {}).catch(() => []);
     }
-    const projectDir = path4.join(this.globalRoot, "projects", projectSlug2);
+    const projectDir = path3.join(this.globalRoot, "projects", projectSlug2);
     let client;
     try {
       const metadata = JSON.parse(
-        await fs3.readFile(sessionCatalogProjectServerMetadataPath(projectDir), "utf8")
+        await fs2.readFile(sessionCatalogProjectServerMetadataPath(projectDir), "utf8")
       );
       if (typeof metadata.projectRoot !== "string") return [];
       client = new SessionCatalogProjectClient({ projectDir, projectRoot: metadata.projectRoot });
@@ -1502,7 +666,7 @@ var ProjectSessionRegistry = class {
     });
   }
   get registryPath() {
-    return path4.join(this.globalRoot, "projects");
+    return path3.join(this.globalRoot, "projects");
   }
   async dispose() {
     await this.unregister().catch(() => void 0);
@@ -1545,7 +709,7 @@ var ProjectSessionRegistry = class {
 var registries = /* @__PURE__ */ new Map();
 var lastRegistryKey;
 function getProjectSessionRegistry(globalRoot) {
-  const key = globalRoot !== void 0 ? path4.resolve(globalRoot) : lastRegistryKey;
+  const key = globalRoot !== void 0 ? path3.resolve(globalRoot) : lastRegistryKey;
   if (!key)
     throw new Error("SessionRegistry not initialized. Call getSessionRegistry(globalRoot) first.");
   let registry = registries.get(key);
@@ -1568,31 +732,31 @@ function getProjectSessionRegistry(globalRoot) {
 }
 function hasProjectSessionRegistry(globalRoot) {
   if (globalRoot === void 0) return registries.size > 0;
-  return registries.has(path4.resolve(globalRoot));
+  return registries.has(path3.resolve(globalRoot));
 }
 
 // src/utils/wstack-paths.ts
 import { createHash as createHash2 } from "node:crypto";
-import * as fs4 from "node:fs";
+import * as fs3 from "node:fs";
 import * as os2 from "node:os";
-import * as path5 from "node:path";
+import * as path4 from "node:path";
 function canonicalProjectRoot(absRoot) {
-  const checkoutRoot = path5.resolve(absRoot);
-  const dotGit = path5.join(checkoutRoot, ".git");
+  const checkoutRoot = path4.resolve(absRoot);
+  const dotGit = path4.join(checkoutRoot, ".git");
   try {
-    if (!fs4.statSync(dotGit).isFile()) return checkoutRoot;
-    const gitDirLine = fs4.readFileSync(dotGit, "utf8").trim();
+    if (!fs3.statSync(dotGit).isFile()) return checkoutRoot;
+    const gitDirLine = fs3.readFileSync(dotGit, "utf8").trim();
     const match = /^gitdir:\s*(.+)$/i.exec(gitDirLine);
     if (!match?.[1]) return checkoutRoot;
-    const gitDir = path5.resolve(checkoutRoot, match[1].trim());
-    const commonDirFile = path5.join(gitDir, "commondir");
-    if (!fs4.statSync(commonDirFile).isFile()) return checkoutRoot;
-    const commonDir = path5.resolve(gitDir, fs4.readFileSync(commonDirFile, "utf8").trim());
-    const worktreesDir = path5.dirname(gitDir);
-    if (path5.basename(worktreesDir).toLowerCase() !== "worktrees") return checkoutRoot;
-    if (path5.resolve(worktreesDir, "..") !== commonDir) return checkoutRoot;
-    if (path5.basename(commonDir).toLowerCase() !== ".git") return checkoutRoot;
-    return path5.dirname(commonDir);
+    const gitDir = path4.resolve(checkoutRoot, match[1].trim());
+    const commonDirFile = path4.join(gitDir, "commondir");
+    if (!fs3.statSync(commonDirFile).isFile()) return checkoutRoot;
+    const commonDir = path4.resolve(gitDir, fs3.readFileSync(commonDirFile, "utf8").trim());
+    const worktreesDir = path4.dirname(gitDir);
+    if (path4.basename(worktreesDir).toLowerCase() !== "worktrees") return checkoutRoot;
+    if (path4.resolve(worktreesDir, "..") !== commonDir) return checkoutRoot;
+    if (path4.basename(commonDir).toLowerCase() !== ".git") return checkoutRoot;
+    return path4.dirname(commonDir);
   } catch {
     return checkoutRoot;
   }
@@ -1602,7 +766,7 @@ function projectHash(absRoot) {
 }
 function projectSlug(absRoot) {
   const identityRoot = canonicalProjectRoot(absRoot);
-  const base = slugify(path5.basename(identityRoot));
+  const base = slugify(path4.basename(identityRoot));
   const hash = createHash2("sha256").update(identityRoot).digest("hex").slice(0, 6);
   return `${base}-${hash}`;
 }
@@ -1615,7 +779,7 @@ function safeProfileName(name) {
 }
 function bootstrapProfileName(globalRoot) {
   try {
-    const parsed = JSON.parse(fs4.readFileSync(path5.join(globalRoot, "config.json"), "utf8"));
+    const parsed = JSON.parse(fs3.readFileSync(path4.join(globalRoot, "config.json"), "utf8"));
     return safeProfileName(
       typeof parsed.activeProfile === "string" ? parsed.activeProfile : void 0
     );
@@ -1625,17 +789,17 @@ function bootstrapProfileName(globalRoot) {
 }
 function wstackGlobalRoot() {
   const fromEnv = process.env["WRONGSTACK_HOME"];
-  if (fromEnv && fromEnv.trim().length > 0) return path5.resolve(fromEnv);
-  return path5.join(os2.homedir(), ".wrongstack");
+  if (fromEnv && fromEnv.trim().length > 0) return path4.resolve(fromEnv);
+  return path4.join(os2.homedir(), ".wrongstack");
 }
 function resolveWstackPaths(opts) {
-  const globalRoot = opts.globalRoot ?? (opts.userHome ? path5.join(opts.userHome, ".wrongstack") : wstackGlobalRoot());
+  const globalRoot = opts.globalRoot ?? (opts.userHome ? path4.join(opts.userHome, ".wrongstack") : wstackGlobalRoot());
   const homeDir = opts.userHome ?? os2.homedir();
   const profileName = safeProfileName(opts.profileName ?? bootstrapProfileName(globalRoot));
-  const profileDir = path5.join(globalRoot, "profiles", profileName);
+  const profileDir = path4.join(globalRoot, "profiles", profileName);
   const hash = projectHash(opts.projectRoot);
   const slug = projectSlug(opts.projectRoot);
-  const projectDir = path5.join(globalRoot, "projects", slug);
+  const projectDir = path4.join(globalRoot, "projects", slug);
   return {
     globalRoot,
     profileName,
@@ -1643,69 +807,69 @@ function resolveWstackPaths(opts) {
     projectRoot: opts.projectRoot,
     homeDir,
     configDir: profileDir,
-    globalConfig: path5.join(globalRoot, "config.json"),
-    profilesDir: path5.join(globalRoot, "profiles"),
+    globalConfig: path4.join(globalRoot, "config.json"),
+    profilesDir: path4.join(globalRoot, "profiles"),
     profileConfig: (name) => {
-      return path5.join(globalRoot, "profiles", safeProfileName(name), "config.json");
+      return path4.join(globalRoot, "profiles", safeProfileName(name), "config.json");
     },
     profileStatuslineConfig: (name) => {
-      return path5.join(globalRoot, "profiles", safeProfileName(name), "statusline.json");
+      return path4.join(globalRoot, "profiles", safeProfileName(name), "statusline.json");
     },
     profileModeConfig: (name) => {
-      return path5.join(globalRoot, "profiles", safeProfileName(name), "mode.json");
+      return path4.join(globalRoot, "profiles", safeProfileName(name), "mode.json");
     },
     profileProviderStatus: (name) => {
-      return path5.join(globalRoot, "profiles", safeProfileName(name), "provider-status.json");
+      return path4.join(globalRoot, "profiles", safeProfileName(name), "provider-status.json");
     },
     profileUpdateCache: (name) => {
-      return path5.join(globalRoot, "profiles", safeProfileName(name), "update-cache.json");
+      return path4.join(globalRoot, "profiles", safeProfileName(name), "update-cache.json");
     },
-    secretsKey: path5.join(globalRoot, ".key"),
-    globalMemory: path5.join(profileDir, "memory.md"),
-    globalSkills: path5.join(profileDir, "skills"),
-    globalClaudeSkills: path5.join(homeDir, ".claude", "skills"),
-    globalDesignKits: path5.join(profileDir, "design-kits"),
-    globalPrompts: path5.join(profileDir, "prompts"),
-    globalInstructions: path5.join(profileDir, "instructions"),
-    promptUsage: path5.join(profileDir, "prompt-usage.json"),
-    cacheDir: path5.join(globalRoot, "cache"),
-    modelsCache: path5.join(globalRoot, "cache", "models.dev.json"),
-    modelsOverlayCache: path5.join(globalRoot, "cache", "models-overlay.json"),
-    historyFile: path5.join(profileDir, "history"),
-    logFile: path5.join(globalRoot, "logs", "wrongstack.log"),
+    secretsKey: path4.join(globalRoot, ".key"),
+    globalMemory: path4.join(profileDir, "memory.md"),
+    globalSkills: path4.join(profileDir, "skills"),
+    globalClaudeSkills: path4.join(homeDir, ".claude", "skills"),
+    globalDesignKits: path4.join(profileDir, "design-kits"),
+    globalPrompts: path4.join(profileDir, "prompts"),
+    globalInstructions: path4.join(profileDir, "instructions"),
+    promptUsage: path4.join(profileDir, "prompt-usage.json"),
+    cacheDir: path4.join(globalRoot, "cache"),
+    modelsCache: path4.join(globalRoot, "cache", "models.dev.json"),
+    modelsOverlayCache: path4.join(globalRoot, "cache", "models-overlay.json"),
+    historyFile: path4.join(profileDir, "history"),
+    logFile: path4.join(globalRoot, "logs", "wrongstack.log"),
     projectDir,
-    projectCodebaseIndex: path5.join(projectDir, "codebase-index"),
-    projectMemory: path5.join(projectDir, "memory.md"),
-    projectSessions: path5.join(projectDir, "sessions"),
-    projectTrust: path5.join(projectDir, "trust.json"),
-    projectMeta: path5.join(projectDir, "meta.json"),
-    projectLocalConfig: path5.join(projectDir, "config.local.json"),
-    inProjectConfig: path5.join(opts.projectRoot, ".wrongstack", "config.json"),
-    inProjectAgentsFile: path5.join(opts.projectRoot, ".wrongstack", "AGENTS.md"),
-    inProjectSkills: path5.join(opts.projectRoot, ".wrongstack", "skills"),
-    inProjectClaudeSkills: path5.join(opts.projectRoot, ".claude", "skills"),
-    inProjectPrompts: path5.join(opts.projectRoot, ".wrongstack", "prompts"),
-    inProjectInstructions: path5.join(opts.projectRoot, ".wrongstack", "instructions"),
-    inProjectDesignKits: path5.join(opts.projectRoot, ".wrongstack", "design-kits"),
-    inProjectWorktrees: path5.join(opts.projectRoot, ".wrongstack", "worktrees"),
+    projectCodebaseIndex: path4.join(projectDir, "codebase-index"),
+    projectMemory: path4.join(projectDir, "memory.md"),
+    projectSessions: path4.join(projectDir, "sessions"),
+    projectTrust: path4.join(projectDir, "trust.json"),
+    projectMeta: path4.join(projectDir, "meta.json"),
+    projectLocalConfig: path4.join(projectDir, "config.local.json"),
+    inProjectConfig: path4.join(opts.projectRoot, ".wrongstack", "config.json"),
+    inProjectAgentsFile: path4.join(opts.projectRoot, ".wrongstack", "AGENTS.md"),
+    inProjectSkills: path4.join(opts.projectRoot, ".wrongstack", "skills"),
+    inProjectClaudeSkills: path4.join(opts.projectRoot, ".claude", "skills"),
+    inProjectPrompts: path4.join(opts.projectRoot, ".wrongstack", "prompts"),
+    inProjectInstructions: path4.join(opts.projectRoot, ".wrongstack", "instructions"),
+    inProjectDesignKits: path4.join(opts.projectRoot, ".wrongstack", "design-kits"),
+    inProjectWorktrees: path4.join(opts.projectRoot, ".wrongstack", "worktrees"),
     projectHash: hash,
     projectSlug: slug,
-    projectGoal: path5.join(projectDir, "goal.json"),
-    projectInputHistory: path5.join(projectDir, "input-history.json"),
-    projectSpecs: path5.join(projectDir, "specs"),
-    projectTaskGraphs: path5.join(projectDir, "task-graphs"),
-    projectSddSession: path5.join(projectDir, "sdd-session.json"),
-    projectPlan: path5.join(projectDir, "plan.json"),
-    projectAutophase: path5.join(projectDir, "autophase"),
-    projectSddBoards: path5.join(projectDir, "sdd-boards"),
-    projectRequirementIntakes: path5.join(projectDir, "requirement-intakes"),
-    syncConfig: path5.join(profileDir, "sync.json"),
-    configHistoryDir: path5.join(globalRoot, "config-history"),
+    projectGoal: path4.join(projectDir, "goal.json"),
+    projectInputHistory: path4.join(projectDir, "input-history.json"),
+    projectSpecs: path4.join(projectDir, "specs"),
+    projectTaskGraphs: path4.join(projectDir, "task-graphs"),
+    projectSddSession: path4.join(projectDir, "sdd-session.json"),
+    projectPlan: path4.join(projectDir, "plan.json"),
+    projectAutophase: path4.join(projectDir, "autophase"),
+    projectSddBoards: path4.join(projectDir, "sdd-boards"),
+    projectRequirementIntakes: path4.join(projectDir, "requirement-intakes"),
+    syncConfig: path4.join(profileDir, "sync.json"),
+    configHistoryDir: path4.join(globalRoot, "config-history"),
     projectStatus: (statusProjectSlug) => {
       if (!/^[a-z0-9](?:[a-z0-9-]{0,39})-[a-f0-9]{6}$/.test(statusProjectSlug)) {
         throw new Error(`Invalid project slug: ${statusProjectSlug}`);
       }
-      return path5.join(globalRoot, "projects", statusProjectSlug, "status.json");
+      return path4.join(globalRoot, "projects", statusProjectSlug, "status.json");
     }
   };
 }
@@ -1738,6 +902,14 @@ var PATTERNS = [
     anchor: "sk-ant-"
   },
   { type: "openai_key", regex: /(?<![A-Za-z0-9])sk-(?:proj-)?[A-Za-z0-9_-]{20,}(?![A-Za-z0-9])/g, anchor: "sk-" },
+  {
+    // `xai` is a first-class provider in this codebase, but its key shape was
+    // absent here — so the one credential format WrongStack itself hands users
+    // was the one the scrubber could not recognize (audit 2026-08-20).
+    type: "xai_key",
+    regex: /(?<![A-Za-z0-9])xai-[A-Za-z0-9]{20,}(?![A-Za-z0-9])/g,
+    anchor: "xai-"
+  },
   { type: "github_pat", regex: /(?<![A-Za-z0-9])ghp_[A-Za-z0-9]{36,}(?![A-Za-z0-9])/g, anchor: "ghp_" },
   { type: "github_pat_v2", regex: /(?<![A-Za-z0-9])github_pat_[A-Za-z0-9_]{50,}(?![A-Za-z0-9])/g, anchor: "github_pat_" },
   { type: "aws_access_key", regex: /(?<![A-Za-z0-9])AKIA[0-9A-Z]{16}(?![A-Za-z0-9])/g, anchor: "AKIA" },
@@ -1828,8 +1000,8 @@ var PATTERNS = [
     // replacement so the separator between adjacent secrets is preserved
     // rather than collapsed. Capture groups are therefore: 1=leading
     // delimiter, 2=key name, 3=value.
-    regex: /(^|\s)([A-Z_]{4,}(?:KEY|TOKEN|SECRET|PASSWORD|PWD))\s*[:=]\s*['"]?([A-Za-z0-9_/+=-]{20,512})['"]?(?=\s|$)/g,
-    anchor: ["KEY", "TOKEN", "SECRET", "PASSWORD", "PWD"]
+    regex: /(^|\s)([A-Z_]{4,}(?:KEY|TOKEN|SECRET|PASSWORD|PWD|PASSPHRASE))\s*[:=]\s*['"]?([A-Za-z0-9_/+=-]{20,512})['"]?(?=\s|$)/g,
+    anchor: ["KEY", "TOKEN", "SECRET", "PASSWORD", "PWD", "PASSPHRASE"]
   },
   {
     type: "json_credential_key",
@@ -1946,6 +1118,27 @@ var JSON_CREDENTIAL_REGEX = PATTERNS.find((p) => p.type === "json_credential_key
 var COMBINED_REPLACEMENTS = SIMPLE_PATTERNS.map((p) => `[REDACTED:${p.type}]`);
 var SCRUB_CHUNK_BYTES = 64 * 1024;
 var SCRUB_OVERLAP_BYTES = 1024;
+var PEM_PRIVATE_KEY_BEGIN_RE = /-----BEGIN (?:RSA|EC|OPENSSH|DSA|PGP)? ?PRIVATE KEY-----/;
+var PEM_END_MARKER = "-----END";
+var MAX_PEM_BLOCK_BYTES = 64 * 1024;
+var PEM_END_LINE_TOLERANCE = 64;
+function extendChunkBoundaryPastPem(text, chunkStart, proposedEnd) {
+  const head = text.slice(chunkStart, proposedEnd);
+  const lastBegin = head.lastIndexOf("-----BEGIN ");
+  if (lastBegin === -1) return proposedEnd;
+  const fromBegin = text.slice(chunkStart + lastBegin);
+  const marker = PEM_PRIVATE_KEY_BEGIN_RE.exec(fromBegin);
+  if (!marker || marker.index !== 0) return proposedEnd;
+  const bodyStart = marker[0].length;
+  const cap = Math.min(text.length, chunkStart + lastBegin + MAX_PEM_BLOCK_BYTES);
+  const closeIdx = fromBegin.indexOf(PEM_END_MARKER, bodyStart);
+  if (closeIdx === -1 || chunkStart + lastBegin + closeIdx >= cap + PEM_END_LINE_TOLERANCE) {
+    return proposedEnd;
+  }
+  const lineEnd = fromBegin.indexOf("\n", closeIdx);
+  const end = lineEnd === -1 ? text.length : chunkStart + lastBegin + lineEnd + 1;
+  return Math.max(proposedEnd, end);
+}
 var PATTERN_ANCHORS = [
   ...new Set(
     PATTERNS.flatMap(
@@ -1982,6 +1175,7 @@ var DefaultSecretScrubber = class {
           }
         }
         end = safe === -1 ? end : safe + 1;
+        end = extendChunkBoundaryPastPem(text, i, end);
       }
       out.push(this.scrubOne(text.slice(i, end)));
       i = end;
@@ -2188,15 +1382,29 @@ var atomicReplaceWithWriter = primitives.atomicReplaceWithWriter;
 var ensureDir = primitives.ensureDir;
 var withFileLock = primitives.withFileLock;
 
+// src/utils/pid.ts
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  if (pid === process.pid) return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    if (code === "EPERM") return true;
+    return false;
+  }
+}
+
 // src/utils/session-scoped-path.ts
-import * as path6 from "node:path";
+import * as path5 from "node:path";
 function sessionScopedPath(dir, sessionId, suffix) {
   if (!sessionId || sessionId.includes("\\") || sessionId.includes("..")) {
     throw invalid(sessionId);
   }
-  const resolved = path6.resolve(dir, `${sessionId}${suffix}`);
-  const rel = path6.relative(path6.resolve(dir), resolved);
-  if (rel.startsWith("..") || path6.isAbsolute(rel)) {
+  const resolved = path5.resolve(dir, `${sessionId}${suffix}`);
+  const rel = path5.relative(path5.resolve(dir), resolved);
+  if (rel.startsWith("..") || path5.isAbsolute(rel)) {
     throw invalid(sessionId);
   }
   return resolved;
@@ -2224,15 +1432,15 @@ function invalid(sessionId) {
   });
 }
 
-// src/session-registry.ts
-import * as fs6 from "node:fs/promises";
-import * as path8 from "node:path";
+// src/session-catalog/session-registry.ts
+import * as fs5 from "node:fs/promises";
+import * as path7 from "node:path";
 
-// src/session-registry-atomic-file.ts
+// src/session-catalog/session-registry-atomic-file.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import * as fs5 from "node:fs/promises";
+import * as fs4 from "node:fs/promises";
 import { hostname } from "node:os";
-import * as path7 from "node:path";
+import * as path6 from "node:path";
 var STALE_LOCK_MS = 1e4;
 var SAME_HOST_STALE_MS = 2 * STALE_LOCK_MS;
 var STALE_TMP_MS = 6e4;
@@ -2242,32 +1450,32 @@ function lockOwnerStamp() {
   return `${HOST_NAME}:${process.pid}`;
 }
 async function maybeUnlinkOwnedLock(lockPath) {
-  const owner = await fs5.readFile(lockPath, "utf8").catch(() => null);
+  const owner = await fs4.readFile(lockPath, "utf8").catch(() => null);
   if (owner === null || owner.trim() !== lockOwnerStamp()) return;
   for (let attempt = 0; attempt < 3; attempt++) {
     try {
-      await fs5.unlink(lockPath);
+      await fs4.unlink(lockPath);
       return;
     } catch {
-      if (attempt < 2) await new Promise((resolve14) => setTimeout(resolve14, 5));
+      if (attempt < 2) await new Promise((resolve13) => setTimeout(resolve13, 5));
     }
   }
 }
 async function breakStaleLock(lockPath) {
   try {
-    const content = await fs5.readFile(lockPath, "utf8").catch(() => "");
+    const content = await fs4.readFile(lockPath, "utf8").catch(() => "");
     const trimmed = content.trim();
     const colonIdx = trimmed.indexOf(":");
     if (colonIdx === -1) {
       const barePid = Number.parseInt(trimmed, 10);
       if (Number.isInteger(barePid) && barePid > 0 && !isPidAlive(barePid)) {
         return await breakStaleLockVerified(lockPath, async () => {
-          const reread = await fs5.readFile(lockPath, "utf8").catch(() => "");
+          const reread = await fs4.readFile(lockPath, "utf8").catch(() => "");
           return reread.trim() === trimmed;
         });
       }
       return await breakStaleLockVerified(lockPath, async () => {
-        const st = await fs5.stat(lockPath);
+        const st = await fs4.stat(lockPath);
         return Date.now() - st.mtimeMs > STALE_LOCK_MS;
       });
     }
@@ -2275,22 +1483,22 @@ async function breakStaleLock(lockPath) {
     const ownerPid = Number.parseInt(trimmed.slice(colonIdx + 1), 10);
     if (ownerHost === HOST_NAME && Number.isInteger(ownerPid) && ownerPid > 0) {
       if (isPidAlive(ownerPid)) {
-        const stat19 = await fs5.stat(lockPath);
+        const stat19 = await fs4.stat(lockPath);
         if (Date.now() - stat19.mtimeMs > SAME_HOST_STALE_MS) {
           return await breakStaleLockVerified(lockPath, async () => {
-            const st = await fs5.stat(lockPath);
+            const st = await fs4.stat(lockPath);
             return Date.now() - st.mtimeMs > SAME_HOST_STALE_MS;
           });
         }
         return false;
       }
       return await breakStaleLockVerified(lockPath, async () => {
-        const reread = await fs5.readFile(lockPath, "utf8").catch(() => "");
+        const reread = await fs4.readFile(lockPath, "utf8").catch(() => "");
         return reread.trim() === trimmed;
       });
     }
     return await breakStaleLockVerified(lockPath, async () => {
-      const st = await fs5.stat(lockPath);
+      const st = await fs4.stat(lockPath);
       return Date.now() - st.mtimeMs > STALE_LOCK_MS;
     });
   } catch {
@@ -2304,21 +1512,21 @@ async function breakStaleLockVerified(lockPath, verify) {
 async function breakLockAtomically(lockPath) {
   const tombstone = `${lockPath}.stale-${randomUUID2()}.tmp`;
   try {
-    await fs5.rename(lockPath, tombstone);
+    await fs4.rename(lockPath, tombstone);
   } catch {
     return false;
   }
-  void fs5.unlink(tombstone).catch(() => void 0);
+  void fs4.unlink(tombstone).catch(() => void 0);
   return true;
 }
 async function writeAtomicFile(filePath, registry) {
-  const tmp = path7.join(
-    path7.dirname(filePath),
-    `.${path7.basename(filePath)}.${randomUUID2().slice(0, 8)}.tmp`
+  const tmp = path6.join(
+    path6.dirname(filePath),
+    `.${path6.basename(filePath)}.${randomUUID2().slice(0, 8)}.tmp`
   );
   let tmpPersisted = false;
   try {
-    const handle = await fs5.open(tmp, "w");
+    const handle = await fs4.open(tmp, "w");
     try {
       await handle.writeFile(JSON.stringify(registry, null, 2), "utf8");
       await handle.sync().catch(() => void 0);
@@ -2327,14 +1535,14 @@ async function writeAtomicFile(filePath, registry) {
     }
     tmpPersisted = true;
     try {
-      await fs5.rename(tmp, filePath);
+      await fs4.rename(tmp, filePath);
       tmpPersisted = false;
     } catch (renameErr) {
       const code = renameErr?.code;
       if (code === "EPERM" || code === "EBUSY" || code === "EACCES") {
-        await fs5.copyFile(tmp, filePath);
+        await fs4.copyFile(tmp, filePath);
         try {
-          const destHandle = await fs5.open(filePath, "r+");
+          const destHandle = await fs4.open(filePath, "r+");
           try {
             await destHandle.sync().catch(() => void 0);
           } finally {
@@ -2342,41 +1550,41 @@ async function writeAtomicFile(filePath, registry) {
           }
         } catch {
         }
-        await fs5.unlink(tmp).catch(() => void 0);
+        await fs4.unlink(tmp).catch(() => void 0);
         tmpPersisted = false;
       } else {
         throw renameErr;
       }
     }
   } catch (err) {
-    if (tmpPersisted) await fs5.unlink(tmp).catch(() => void 0);
+    if (tmpPersisted) await fs4.unlink(tmp).catch(() => void 0);
     throw err;
   }
 }
 async function pruneStaleTempFiles(filePath) {
   try {
-    const dir = path7.dirname(filePath);
-    const base = path7.basename(filePath);
+    const dir = path6.dirname(filePath);
+    const base = path6.basename(filePath);
     const now = Date.now();
     const stale = [];
-    for (const name of await fs5.readdir(dir)) {
+    for (const name of await fs4.readdir(dir)) {
       const isTemp = (name.startsWith(`${base}.`) || name.startsWith(`.${base}.`)) && name.endsWith(".tmp");
       if (!isTemp) continue;
-      const stat19 = await fs5.stat(path7.join(dir, name)).catch(() => null);
+      const stat19 = await fs4.stat(path6.join(dir, name)).catch(() => null);
       if (!stat19) continue;
       if (now - stat19.mtimeMs > STALE_TMP_MS) stale.push({ name, mtimeMs: stat19.mtimeMs });
     }
-    stale.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    stale.sort((a, b) => a.mtimeMs - b.mtimeMs);
     await Promise.all(
-      stale.slice(MAX_STALE_TMP_FILES).map(async ({ name }) => {
-        await fs5.unlink(path7.join(dir, name)).catch(() => void 0);
+      stale.slice(0, MAX_STALE_TMP_FILES).map(async ({ name }) => {
+        await fs4.unlink(path6.join(dir, name)).catch(() => void 0);
       })
     );
   } catch {
   }
 }
 
-// src/session-registry.ts
+// src/session-catalog/session-registry.ts
 var REGISTRY_FILE = "session-registry.json";
 var HEARTBEAT_INTERVAL_MS2 = 5e3;
 var STALE_TIMEOUT_MS = 3e4;
@@ -2392,7 +1600,7 @@ var SessionOwnershipConflictError = class extends Error {
 var SessionRegistryWriteError = class extends Error {
 };
 var TEMP_PRUNE_INTERVAL_MS = STALE_TMP_MS;
-var pidAlive2 = isPidAlive;
+var pidAlive = isPidAlive;
 function sameOwner(entry, owner) {
   return entry.pid === owner.pid && entry.startedAt === owner.startedAt;
 }
@@ -2433,7 +1641,7 @@ var SessionRegistry = class {
   lastEntry = null;
   ownershipLockWaitMs;
   constructor(globalRoot, options = {}) {
-    this.filePath = path8.join(globalRoot, REGISTRY_FILE);
+    this.filePath = path7.join(globalRoot, REGISTRY_FILE);
     this.ownershipLockWaitMs = Math.max(0, options.ownershipLockWaitMs ?? OWNERSHIP_LOCK_WAIT_MS);
   }
   // ── Public API ──────────────────────────────────────────────────────────
@@ -2451,7 +1659,7 @@ var SessionRegistry = class {
     };
     const existingRegistry = await this.readAndPrune();
     const currentOwner = existingRegistry[entry.sessionId];
-    if (currentOwner && currentOwner.pid !== entry.pid && pidAlive2(currentOwner.pid)) {
+    if (currentOwner && currentOwner.pid !== entry.pid && pidAlive(currentOwner.pid)) {
       throw new SessionOwnershipConflictError(
         `Session ${entry.sessionId} is already open in another running wstack (pid ${currentOwner.pid}).`
       );
@@ -2464,12 +1672,12 @@ var SessionRegistry = class {
           continue;
         }
         const heartbeatAt = Date.parse(existing.lastHeartbeatAt);
-        if (!Number.isFinite(heartbeatAt) || now - heartbeatAt > PID_CHECK_AFTER_MS && !pidAlive2(existing.pid)) {
+        if (!Number.isFinite(heartbeatAt) || now - heartbeatAt > PID_CHECK_AFTER_MS && !pidAlive(existing.pid)) {
           delete registry[id];
         }
       }
       const lockedOwner = registry[entry.sessionId];
-      if (lockedOwner && lockedOwner.pid !== entry.pid && pidAlive2(lockedOwner.pid)) {
+      if (lockedOwner && lockedOwner.pid !== entry.pid && pidAlive(lockedOwner.pid)) {
         throw new SessionOwnershipConflictError(
           `Session ${entry.sessionId} is already open in another running wstack (pid ${lockedOwner.pid}).`
         );
@@ -2515,13 +1723,13 @@ var SessionRegistry = class {
     }
     if (!this.agentsFlushTimer) {
       const delay2 = Math.max(0, AGENTS_WRITE_THROTTLE_MS - sinceLastWrite);
-      this.pendingAgentsFlush = new Promise((resolve14, reject) => {
-        this.pendingAgentsResolve = resolve14;
+      this.pendingAgentsFlush = new Promise((resolve13, reject) => {
+        this.pendingAgentsResolve = resolve13;
         const timer = setTimeout(() => {
           this.agentsFlushTimer = null;
           this.pendingAgentsFlush = null;
           this.pendingAgentsResolve = null;
-          this.writeAgentsSnapshot().then(resolve14, reject);
+          this.writeAgentsSnapshot().then(resolve13, reject);
         }, delay2);
         if (typeof timer.unref === "function") timer.unref();
         this.agentsFlushTimer = timer;
@@ -2672,7 +1880,7 @@ var SessionRegistry = class {
   }
   async readAndPrune() {
     try {
-      const raw = await fs6.readFile(this.filePath, "utf8");
+      const raw = await fs5.readFile(this.filePath, "utf8");
       const registry = parseRegistry(raw);
       const observed = new Map(
         Object.entries(registry).map(([id, entry]) => [
@@ -2702,13 +1910,13 @@ var SessionRegistry = class {
           pruned = true;
         }
         if (entry.status === "closing" && heartbeatAge > CLOSING_GRACE_MS) {
-          if (!pidAlive2(entry.pid)) {
+          if (!pidAlive(entry.pid)) {
             delete registry[id];
             pruned = true;
           }
           continue;
         }
-        if (heartbeatAge > PID_CHECK_AFTER_MS && !pidAlive2(entry.pid)) {
+        if (heartbeatAge > PID_CHECK_AFTER_MS && !pidAlive(entry.pid)) {
           delete registry[id];
           pruned = true;
           continue;
@@ -2743,7 +1951,7 @@ var SessionRegistry = class {
     const deadline = Date.now() + waitBudgetMs;
     let attempt = 0;
     try {
-      await fs6.mkdir(path8.dirname(this.filePath), { recursive: true });
+      await fs5.mkdir(path7.dirname(this.filePath), { recursive: true });
       await this.maybePruneStaleTempFiles();
     } catch (err) {
       if (required) {
@@ -2755,17 +1963,17 @@ var SessionRegistry = class {
     }
     while (true) {
       try {
-        let lockHandle = await fs6.open(lockPath, "wx").catch(() => null);
+        let lockHandle = await fs5.open(lockPath, "wx").catch(() => null);
         if (!lockHandle) {
           if (await breakStaleLock(lockPath)) {
-            lockHandle = await fs6.open(lockPath, "wx").catch(() => null);
+            lockHandle = await fs5.open(lockPath, "wx").catch(() => null);
           }
           if (!lockHandle) {
             const remainingMs = deadline - Date.now();
             if (remainingMs <= 0) break;
             const retryDelayMs = Math.min(LOCK_RETRY_MAX_MS, 20 * (attempt + 1));
             await new Promise(
-              (resolve14) => setTimeout(resolve14, Math.min(retryDelayMs, remainingMs))
+              (resolve13) => setTimeout(resolve13, Math.min(retryDelayMs, remainingMs))
             );
             attempt += 1;
             continue;
@@ -2779,14 +1987,14 @@ var SessionRegistry = class {
               await lockHandle.writeFile(lockOwnerStamp());
               stamped = true;
             } catch {
-              if (stampAttempt < 2) await new Promise((resolve14) => setTimeout(resolve14, 5));
+              if (stampAttempt < 2) await new Promise((resolve13) => setTimeout(resolve13, 5));
             }
           }
           if (!stamped) {
             stampFailed = true;
             throw new Error("failed to stamp session-registry lock owner");
           }
-          const raw = await fs6.readFile(this.filePath, "utf8").catch(() => "{}");
+          const raw = await fs5.readFile(this.filePath, "utf8").catch(() => "{}");
           const registry = parseRegistry(raw);
           fn(registry);
           await this.writeAtomicWithRetry(registry);
@@ -2794,7 +2002,7 @@ var SessionRegistry = class {
         } finally {
           await lockHandle.close().catch(() => void 0);
           if (stampFailed) {
-            await fs6.unlink(lockPath).catch(() => void 0);
+            await fs5.unlink(lockPath).catch(() => void 0);
           } else {
             await maybeUnlinkOwnedLock(lockPath);
           }
@@ -2845,7 +2053,7 @@ var SessionRegistry = class {
           throw err;
         }
         const delayMs = Math.min(80, 5 * attempt);
-        await new Promise((resolve14) => setTimeout(resolve14, delayMs));
+        await new Promise((resolve13) => setTimeout(resolve13, delayMs));
       }
     }
     throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
@@ -2875,7 +2083,7 @@ var SessionRegistry = class {
 
 // src/storage/annotations-store.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import * as fs7 from "node:fs/promises";
+import * as fs6 from "node:fs/promises";
 
 // src/utils/expect-defined.ts
 function expectDefined(value, label) {
@@ -3114,7 +2322,7 @@ var AnnotationsStore = class {
     const fp = this.filePath(sessionId);
     let raw;
     try {
-      raw = await fs7.readFile(fp, "utf8");
+      raw = await fs6.readFile(fp, "utf8");
     } catch (err) {
       if (err.code === "ENOENT") return null;
       throw err;
@@ -3154,7 +2362,7 @@ var AnnotationsStore = class {
 // src/storage/attachment-store.ts
 import { randomBytes } from "node:crypto";
 import * as fsp from "node:fs/promises";
-import * as path9 from "node:path";
+import * as path8 from "node:path";
 var DEFAULT_SPOOL_THRESHOLD = 256 * 1024;
 var PLACEHOLDER_RE = /\[(pasted|image|file) #(\d+)[^\]]*\]|\[file:([^\]]+)\]/g;
 var DefaultAttachmentStore = class {
@@ -3175,7 +2383,7 @@ var DefaultAttachmentStore = class {
     let data = input.data;
     if (this.spoolDir && bytes >= this.spoolThreshold) {
       await fsp.mkdir(this.spoolDir, { recursive: true });
-      spooledPath = path9.join(this.spoolDir, `${id}.bin`);
+      spooledPath = path8.join(this.spoolDir, `${id}.bin`);
       await atomicWrite(spooledPath, input.data, {
         encoding: input.kind === "image" ? "base64" : "utf8"
       });
@@ -3295,8 +2503,8 @@ function mergeAdjacentText(blocks) {
 
 // src/storage/cloud-config-sync.ts
 import { createHash as createHash3, randomUUID as nodeRandomUUID } from "node:crypto";
-import * as fs8 from "node:fs/promises";
-import * as path10 from "node:path";
+import * as fs7 from "node:fs/promises";
+import * as path9 from "node:path";
 
 // src/storage/cloud-config-sync/sanitize.ts
 var SAGE_TREE = {
@@ -4017,7 +3225,7 @@ var CloudConfigSync = class {
   async loadState() {
     if (this.state) return this.state;
     try {
-      const raw = await fs8.readFile(this.deps.statePath, "utf8");
+      const raw = await fs7.readFile(this.deps.statePath, "utf8");
       const parsed = JSON.parse(raw);
       this.state = {
         ...structuredClone(EMPTY_STATE),
@@ -4031,7 +3239,7 @@ var CloudConfigSync = class {
   }
   async saveState(state) {
     this.state = state;
-    await fs8.mkdir(path10.dirname(this.deps.statePath), { recursive: true });
+    await fs7.mkdir(path9.dirname(this.deps.statePath), { recursive: true });
     await atomicWrite(this.deps.statePath, `${JSON.stringify(state, null, 2)}
 `, {
       mode: 384
@@ -4051,8 +3259,8 @@ function summary(partial) {
 }
 
 // src/storage/cloud-sync.ts
-import * as fs9 from "node:fs/promises";
-import * as path11 from "node:path";
+import * as fs8 from "node:fs/promises";
+import * as path10 from "node:path";
 import { createHash as createHash4 } from "node:crypto";
 var ALL_SYNC_CATEGORIES = ["settings", "skills", "prompts", "memory", "history"];
 var CloudSync = class {
@@ -4060,8 +3268,8 @@ var CloudSync = class {
     this.paths = paths;
     this.getConfig = getConfig;
     this.setConfig = setConfig;
-    this.statePath = path11.join(paths.configDir, "sync-state.json");
-    this.getSettingsConfigPath = getSettingsConfigPath ?? (() => path11.join(this.paths.configDir, "config.json"));
+    this.statePath = path10.join(paths.configDir, "sync-state.json");
+    this.getSettingsConfigPath = getSettingsConfigPath ?? (() => path10.join(this.paths.configDir, "config.json"));
   }
   paths;
   getConfig;
@@ -4216,7 +3424,7 @@ var CloudSync = class {
   }
   async loadState() {
     try {
-      const raw = await fs9.readFile(this.statePath, "utf8");
+      const raw = await fs8.readFile(this.statePath, "utf8");
       this.state = JSON.parse(raw);
     } catch {
       this.state = null;
@@ -4341,18 +3549,18 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat19 = await fs9.lstat(localPath);
+        const stat19 = await fs8.lstat(localPath);
         if (stat19.isSymbolicLink()) continue;
         if (stat19.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
-            const content = await fs9.readFile(file, "utf8");
-            const rel = path11.relative(localPath, file).replace(/\\/g, "/");
+            const content = await fs8.readFile(file, "utf8");
+            const rel = path10.relative(localPath, file).replace(/\\/g, "/");
             entries.push({ path: `data/${cat}/${rel}`, content, mode: "100644" });
             hashes.push(`${cat}/${rel}\0${content}`);
           }
         } else {
-          const content = await fs9.readFile(localPath, "utf8");
+          const content = await fs8.readFile(localPath, "utf8");
           entries.push({ path: `data/${cat}`, content, mode: "100644" });
           hashes.push(`${cat}\0${content}`);
         }
@@ -4368,17 +3576,17 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat19 = await fs9.lstat(localPath);
+        const stat19 = await fs8.lstat(localPath);
         if (stat19.isSymbolicLink()) continue;
         if (stat19.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
-            const content = await fs9.readFile(file, "utf8");
-            const rel = path11.relative(localPath, file).replace(/\\/g, "/");
+            const content = await fs8.readFile(file, "utf8");
+            const rel = path10.relative(localPath, file).replace(/\\/g, "/");
             hashes.push(`${cat}/${rel}\0${content}`);
           }
         } else {
-          const content = await fs9.readFile(localPath, "utf8");
+          const content = await fs8.readFile(localPath, "utf8");
           hashes.push(`${cat}\0${content}`);
         }
       } catch {
@@ -4405,10 +3613,10 @@ var CloudSync = class {
   }
   async walkDir(dir, base) {
     const results = [];
-    const entries = await fs9.readdir(dir, { withFileTypes: true });
+    const entries = await fs8.readdir(dir, { withFileTypes: true });
     entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
-      const full = path11.join(dir, entry.name);
+      const full = path10.join(dir, entry.name);
       if (entry.isSymbolicLink()) continue;
       if (entry.isDirectory()) {
         results.push(...await this.walkDir(full, base));
@@ -4421,17 +3629,17 @@ var CloudSync = class {
 };
 async function preparePulledDestination(cat, localPath, destPath, remotePath) {
   const directoryBacked = cat === "skills" || cat === "prompts";
-  const rootPath = directoryBacked ? localPath : path11.dirname(localPath);
+  const rootPath = directoryBacked ? localPath : path10.dirname(localPath);
   const rootStat = await lstatIfExists(rootPath);
   if (rootStat?.isSymbolicLink()) {
     throw unsafePulledSymlinkError(remotePath, rootPath);
   }
   if (directoryBacked) {
-    const relativeParent = path11.relative(rootPath, path11.dirname(destPath));
+    const relativeParent = path10.relative(rootPath, path10.dirname(destPath));
     let cursor = rootPath;
     if (relativeParent) {
-      for (const segment of relativeParent.split(path11.sep)) {
-        cursor = path11.join(cursor, segment);
+      for (const segment of relativeParent.split(path10.sep)) {
+        cursor = path10.join(cursor, segment);
         const stat19 = await lstatIfExists(cursor);
         if (stat19?.isSymbolicLink()) throw unsafePulledSymlinkError(remotePath, cursor);
       }
@@ -4439,11 +3647,11 @@ async function preparePulledDestination(cat, localPath, destPath, remotePath) {
   }
   const destStat = await lstatIfExists(destPath);
   if (destStat?.isSymbolicLink()) throw unsafePulledSymlinkError(remotePath, destPath);
-  await fs9.mkdir(path11.dirname(destPath), { recursive: true });
+  await fs8.mkdir(path10.dirname(destPath), { recursive: true });
 }
 async function lstatIfExists(filePath) {
   try {
-    return await fs9.lstat(filePath);
+    return await fs8.lstat(filePath);
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw err;
@@ -4469,9 +3677,9 @@ function resolvePulledCategoryPath(cat, localPath, rel, remotePath) {
     return localPath;
   }
   if (!rel) return localPath;
-  const normalizedRel = path11.normalize(rel);
-  const traversesUp = normalizedRel === ".." || normalizedRel.startsWith(`..${path11.sep}`);
-  if (path11.isAbsolute(normalizedRel) || traversesUp) {
+  const normalizedRel = path10.normalize(rel);
+  const traversesUp = normalizedRel === ".." || normalizedRel.startsWith(`..${path10.sep}`);
+  if (path10.isAbsolute(normalizedRel) || traversesUp) {
     throw new FsError({
       message: `Refusing CloudSync path traversal: ${remotePath}`,
       code: ERROR_CODES.FS_DELETE_FAILED,
@@ -4479,10 +3687,10 @@ function resolvePulledCategoryPath(cat, localPath, rel, remotePath) {
       context: { reason: "path_traversal", normalizedRel }
     });
   }
-  const dest = path11.resolve(localPath, normalizedRel);
-  const root = path11.resolve(localPath);
-  const relative8 = path11.relative(root, dest);
-  if (relative8.startsWith("..") || path11.isAbsolute(relative8)) {
+  const dest = path10.resolve(localPath, normalizedRel);
+  const root = path10.resolve(localPath);
+  const relative8 = path10.relative(root, dest);
+  if (relative8.startsWith("..") || path10.isAbsolute(relative8)) {
     throw new FsError({
       message: `Refusing CloudSync path outside category root: ${remotePath}`,
       code: ERROR_CODES.FS_DELETE_FAILED,
@@ -4605,7 +3813,7 @@ function isCompletedWorkEvidence(value) {
 }
 
 // src/storage/config-loader.ts
-import * as fs11 from "node:fs/promises";
+import * as fs10 from "node:fs/promises";
 
 // src/security/config-secrets.ts
 function decryptConfigSecrets(cfg, vault, opts) {
@@ -4639,7 +3847,7 @@ function walk(node, vault, transform) {
   }
   return out;
 }
-var SECRET_KEY_PATTERN = /(?:apikey|api_key|authtoken|auth_token|bearer|secret|password|passwd|pwd|refreshtoken|refresh_token|sessionkey|session_key|access[_-]?token|private[_-]?key|token\b)/i;
+var SECRET_KEY_PATTERN = /(?:api[-_]?key|auth[-_]?token|authorization|proxy-authorization|cookie|bearer|secret|password|passwd|pwd|refresh[-_]?token|session[-_]?key|access[_-]?token|private[_-]?key|token\b)/i;
 var NON_SECRET_OVERRIDES = /* @__PURE__ */ new Set(["publickey", "public_key"]);
 function isSecretField(name) {
   const lc = name.toLowerCase();
@@ -4703,20 +3911,20 @@ function isContextWindowModeId(id) {
 }
 
 // src/utils/config-backup.ts
-import * as fs10 from "node:fs/promises";
-import * as path12 from "node:path";
+import * as fs9 from "node:fs/promises";
+import * as path11 from "node:path";
 function configHistoryDir(globalRoot) {
-  return path12.join(globalRoot, "config-history");
+  return path11.join(globalRoot, "config-history");
 }
 function configSlug(absolutePath, globalRoot) {
-  const rel = path12.relative(globalRoot, absolutePath);
+  const rel = path11.relative(globalRoot, absolutePath);
   const normalized = rel.replace(/\\/g, "/").replace(/\.json$/i, "");
   return normalized.replace(/\//g, "-");
 }
 async function backupConfigFile(filePath, paths) {
   let currentContent;
   try {
-    currentContent = await fs10.readFile(filePath, "utf8");
+    currentContent = await fs9.readFile(filePath, "utf8");
     if (!currentContent.trim()) return;
   } catch {
     return;
@@ -4725,10 +3933,10 @@ async function backupConfigFile(filePath, paths) {
   const ts = now.toISOString().replace(/[:.]/g, "-").replace(/Z$/, "");
   const slug = configSlug(filePath, paths.globalRoot);
   const backupDir = configHistoryDir(paths.globalRoot);
-  const backupFile = path12.join(backupDir, `${slug}-${ts}.json`);
+  const backupFile = path11.join(backupDir, `${slug}-${ts}.json`);
   try {
-    await fs10.mkdir(backupDir, { recursive: true });
-    await fs10.writeFile(backupFile, currentContent, { mode: 384, encoding: "utf8" });
+    await fs9.mkdir(backupDir, { recursive: true });
+    await fs9.writeFile(backupFile, currentContent, { mode: 384, encoding: "utf8" });
   } catch {
   }
 }
@@ -5052,19 +4260,19 @@ function repairConfigDefaults(input) {
       });
     }
     for (const [key, defaultValue] of Object.entries(defaults)) {
-      const path36 = prefix ? `${prefix}.${key}` : key;
+      const path35 = prefix ? `${prefix}.${key}` : key;
       if (!Object.hasOwn(target, key)) {
         target[key] = cloneJsonValue(defaultValue);
-        changes.push({ path: path36, action: "added" });
+        changes.push({ path: path35, action: "added" });
         continue;
       }
       const current = target[key];
       if (isPlainRecord(defaultValue)) {
         if (isPlainRecord(current)) {
-          repair(current, defaultValue, path36, depth + 1);
+          repair(current, defaultValue, path35, depth + 1);
         } else {
           target[key] = cloneJsonValue(defaultValue);
-          changes.push({ path: path36, action: "replaced" });
+          changes.push({ path: path35, action: "replaced" });
         }
         continue;
       }
@@ -5072,7 +4280,7 @@ function repairConfigDefaults(input) {
       const compatible = defaultIsArray ? Array.isArray(current) : !Array.isArray(current) && typeof current === typeof defaultValue;
       if (!compatible) {
         target[key] = cloneJsonValue(defaultValue);
-        changes.push({ path: path36, action: "replaced" });
+        changes.push({ path: path35, action: "replaced" });
       }
     }
   };
@@ -5344,10 +4552,21 @@ var IN_PROJECT_DENIED_PATHS = [
     // See discover-mailbox-bridge.ts:findWorkspaceCliEntry.
     path: "features.mailboxBridge",
     reason: "Enables the mailbox bridge, whose CLI-entry resolution walks up from the project root \u2014 a repo-supplied packages/cli/dist/index.js would be spawned on WebUI boot."
+  },
+  {
+    // `plugins` is already denied above, so a repo cannot ADD a plugin. This
+    // closes the other half: a repo could previously ship
+    // `{"features":{"pluginsTrust":false}}` and switch off the integrity gate
+    // for plugins the user had ALREADY installed globally — disarming the
+    // trust-on-first-use pin that exists to catch a supply-chain update
+    // rewriting a plugin's entry file. Same operator-owned class as the
+    // switches above.
+    path: "features.pluginsTrust",
+    reason: "Disables the plugin trust-on-first-use integrity gate, re-trusting changed code in already-installed global plugins."
   }
 ];
-function deleteNestedPath(target, path36) {
-  const segments = path36.split(".");
+function deleteNestedPath(target, path35) {
+  const segments = path35.split(".");
   const last = segments[segments.length - 1];
   if (last === void 0) return false;
   let cursor = target;
@@ -5404,16 +4623,16 @@ function assertInProjectAllowListComplete() {
     );
   }
   const orphanedPaths = IN_PROJECT_DENIED_PATHS.filter(
-    ({ path: path36 }) => !IN_PROJECT_ALLOWED_KEYS.has(path36.split(".")[0] ?? "")
-  ).map(({ path: path36 }) => path36);
+    ({ path: path35 }) => !IN_PROJECT_ALLOWED_KEYS.has(path35.split(".")[0] ?? "")
+  ).map(({ path: path35 }) => path35);
   if (orphanedPaths.length > 0) {
     problems.push(
       `IN_PROJECT_DENIED_PATHS entr(ies) whose top-level parent is not allowed: ` + orphanedPaths.join(", ") + ". The parent is already stripped wholesale, so the nested denial is dead \u2014 remove it."
     );
   }
   const malformedPaths = IN_PROJECT_DENIED_PATHS.filter(
-    ({ path: path36 }) => path36.split(".").length < 2 || path36.split(".").some((s) => s.length === 0)
-  ).map(({ path: path36 }) => path36);
+    ({ path: path35 }) => path35.split(".").length < 2 || path35.split(".").some((s) => s.length === 0)
+  ).map(({ path: path35 }) => path35);
   if (malformedPaths.length > 0) {
     problems.push(
       `IN_PROJECT_DENIED_PATHS entr(ies) are not dotted nested paths: ` + malformedPaths.join(", ") + ". Top-level keys belong in KNOWN_DENIED_IN_PROJECT instead."
@@ -5441,8 +4660,8 @@ function stripUnsafeInProjectFields(inProject, sourcePath, warn = (msg) => conso
     }
     stripped.push(k);
   }
-  for (const { path: path36 } of IN_PROJECT_DENIED_PATHS) {
-    if (deleteNestedPath(out, path36)) stripped.push(path36);
+  for (const { path: path35 } of IN_PROJECT_DENIED_PATHS) {
+    if (deleteNestedPath(out, path35)) stripped.push(path35);
   }
   if (stripped.length > 0) {
     warn(
@@ -5631,10 +4850,10 @@ function removeLegacySageEngine(config) {
 }
 
 // src/storage/config-loader/path-identity.ts
-import * as path13 from "node:path";
+import * as path12 from "node:path";
 function samePath(a, b) {
-  let ra = path13.resolve(a);
-  let rb = path13.resolve(b);
+  let ra = path12.resolve(a);
+  let rb = path12.resolve(b);
   if (process.platform === "win32" || process.platform === "darwin") {
     ra = ra.toLowerCase();
     rb = rb.toLowerCase();
@@ -5794,7 +5013,7 @@ var DefaultConfigLoader = class _DefaultConfigLoader {
         let parsed;
         let fileExisted = true;
         try {
-          const raw = await fs11.readFile(fp, "utf8");
+          const raw = await fs10.readFile(fp, "utf8");
           const result = safeParse(raw);
           if (!result.ok || !isPlainRecord(result.value)) {
             return;
@@ -5890,7 +5109,7 @@ var DefaultConfigLoader = class _DefaultConfigLoader {
     let parsed;
     let existed = true;
     try {
-      const raw = await fs11.readFile(profileFp, "utf8");
+      const raw = await fs10.readFile(profileFp, "utf8");
       const result = safeParse(raw);
       if (!result.ok || !isPlainRecord(result.value)) {
         this.logWarn("Profile config parse failed \u2014 falling back to defaults", {
@@ -5989,7 +5208,7 @@ var DefaultConfigLoader = class _DefaultConfigLoader {
     const fp = this.paths.syncConfig;
     const t0 = Date.now();
     try {
-      const raw = await fs11.readFile(fp, "utf8");
+      const raw = await fs10.readFile(fp, "utf8");
       const parsed = safeParse(raw);
       if (!parsed.ok || !parsed.value) {
         this.events?.emit("storage.read", {
@@ -6051,7 +5270,7 @@ var DefaultConfigLoader = class _DefaultConfigLoader {
     const t0 = Date.now();
     let mtimeMs = null;
     try {
-      const stat19 = await fs11.stat(file);
+      const stat19 = await fs10.stat(file);
       mtimeMs = stat19.mtimeMs;
       const cached = this.jsonCache.get(file);
       if (cached && cached.mtimeMs === mtimeMs) {
@@ -6081,7 +5300,7 @@ var DefaultConfigLoader = class _DefaultConfigLoader {
     }
     let raw;
     try {
-      raw = await fs11.readFile(file, "utf8");
+      raw = await fs10.readFile(file, "utf8");
     } catch (err) {
       if (err.code !== "ENOENT") {
         this.events?.emit("storage.read", {
@@ -6557,12 +5776,6 @@ var DirectorStateCheckpoint = class {
   }
 };
 
-// src/storage/goal-coordination.ts
-import { updateTask } from "@wrongstack/kanban";
-
-// src/storage/goal-kanban.ts
-import { addTask, createBoard, getBoard, listBoards, removeBoard } from "@wrongstack/kanban";
-
 // src/utils/term.ts
 var hasStdout = () => typeof process !== "undefined" && !!process.stdout;
 function isStdoutTTY() {
@@ -6611,14 +5824,16 @@ var color = {
 var GOAL_BOARD_TAG_PREFIX = "goal:";
 async function createGoalKanbanBoard(projectRoot, goalFile) {
   if (!projectRoot) return null;
+  const store = tryBoardStore();
+  if (!store) return null;
   const existingId = goalFile.kanbanBoardId;
   if (existingId) {
-    const existing = await getBoard(projectRoot, existingId).catch(() => null);
+    const existing = await store.getBoard(projectRoot, existingId).catch(() => null);
     if (existing) return existingId;
   }
   const displayGoal = (goalFile.refinedGoal || goalFile.goal).replace(/\s+/g, " ").trim();
   const titleSuffix = displayGoal.length > 80 ? displayGoal.slice(0, 77) + "\u2026" : displayGoal;
-  const board = await createBoard(projectRoot, {
+  const board = await store.createBoard(projectRoot, {
     title: `\u{1F3AF} ${titleSuffix}`,
     description: `Kanban board auto-created for goal: ${displayGoal}`,
     tags: [goalTag(goalFile)],
@@ -6632,7 +5847,7 @@ async function createGoalKanbanBoard(projectRoot, goalFile) {
       const d = goalFile.deliverables[index];
       const cleaned = d.replace(/^\[[x✓]\]|✅|\(done\)\s*/i, "").trim();
       if (cleaned) {
-        await addTask(projectRoot, board.id, {
+        await store.addTask(projectRoot, board.id, {
           title: cleaned,
           columnId: targetColumnId,
           description: `Deliverable for goal: ${displayGoal}`,
@@ -6652,23 +5867,27 @@ async function createGoalKanbanBoard(projectRoot, goalFile) {
 async function findGoalKanbanBoard(projectRoot, boardId) {
   if (!projectRoot || !boardId) return null;
   try {
-    return await getBoard(projectRoot, boardId);
+    return await boardStore().getBoard(projectRoot, boardId);
   } catch {
     return null;
   }
 }
 async function deleteGoalKanbanBoard(projectRoot, boardId) {
   if (!projectRoot || !boardId) return;
-  await removeBoard(projectRoot, boardId).catch(() => {
+  const store = tryBoardStore();
+  if (!store) return;
+  await store.removeBoard(projectRoot, boardId).catch(() => {
   });
 }
 async function findGoalBoardByTag(projectRoot, goalFile) {
   if (!projectRoot) return null;
+  const store = tryBoardStore();
+  if (!store) return null;
   const tag = goalTag(goalFile);
-  const boards = await listBoards(projectRoot);
+  const boards = await store.listBoards(projectRoot);
   const matched = boards.find((b) => b.tags?.includes(tag));
   if (!matched) return null;
-  return getBoard(projectRoot, matched.id).catch(() => null);
+  return store.getBoard(projectRoot, matched.id).catch(() => null);
 }
 function formatGoalKanbanPreview(goalFile, boardId, taskCount) {
   const lines = [];
@@ -7184,7 +6403,7 @@ async function refreshGoalKanban(projectRoot, goal, completed, resolvedBoard) {
     const originMatch = task.origin?.system === "goal" && task.origin?.taskId ? originKeys.has(task.origin.taskId) : false;
     const titleMatch = !task.origin?.taskId && completedTitles.has(normalizeTitle(task.title));
     if (!originMatch && !titleMatch) continue;
-    const result = await updateTask(
+    const result = await boardStore().updateTask(
       projectRoot,
       board.id,
       task.id,
@@ -7220,8 +6439,8 @@ function normalizeTitle(value) {
 }
 
 // src/storage/input-history-store.ts
-import * as fs12 from "node:fs/promises";
-import * as path14 from "node:path";
+import * as fs11 from "node:fs/promises";
+import * as path13 from "node:path";
 var INPUT_HISTORY_DEFAULT_MAX = 100;
 var InputHistoryStore = class {
   /**
@@ -7243,7 +6462,7 @@ var InputHistoryStore = class {
    */
   async load() {
     try {
-      const raw = JSON.parse(await fs12.readFile(this.file, "utf8"));
+      const raw = JSON.parse(await fs11.readFile(this.file, "utf8"));
       if (raw && typeof raw === "object" && Array.isArray(raw.entries) && raw.entries.every((e) => typeof e === "string")) {
         return raw.entries.slice(0, this.maxEntries);
       }
@@ -7260,7 +6479,7 @@ var InputHistoryStore = class {
    */
   async save(entries) {
     const cleaned = this.scrubAndFilter(entries);
-    await ensureDir(path14.dirname(this.file));
+    await ensureDir(path13.dirname(this.file));
     const payload = {
       version: 1,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -7270,7 +6489,7 @@ var InputHistoryStore = class {
   }
   /** Truncate the file to an empty entry list (used by /clear). */
   async clear() {
-    await ensureDir(path14.dirname(this.file));
+    await ensureDir(path13.dirname(this.file));
     const payload = { version: 1, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), entries: [] };
     await atomicWrite(this.file, JSON.stringify(payload, null, 2));
   }
@@ -7301,8 +6520,8 @@ var InputHistoryStore = class {
 
 // src/storage/memory-backend.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
-import * as fs13 from "node:fs/promises";
-import * as path15 from "node:path";
+import * as fs12 from "node:fs/promises";
+import * as path14 from "node:path";
 
 // src/security/file-permissions.ts
 import {
@@ -7477,7 +6696,7 @@ var FileMemoryBackend = class {
   }
   async getMtime(file) {
     try {
-      const stat19 = await fs13.stat(file);
+      const stat19 = await fs12.stat(file);
       return stat19.mtimeMs;
     } catch {
       return 0;
@@ -7529,7 +6748,7 @@ var FileMemoryBackend = class {
     const line = `- [${entry.ts}] ${id}${meta} ${entry.text.replace(/\n/g, " ")}
 `;
     await withFileLock(file, async () => {
-      const handle = await fs13.open(file, "a+", SECRET_FILE_MODE);
+      const handle = await fs12.open(file, "a+", SECRET_FILE_MODE);
       try {
         const stat19 = await handle.stat();
         let prefix = "";
@@ -7553,7 +6772,7 @@ var FileMemoryBackend = class {
     return withFileLock(file, async () => {
       let existing;
       try {
-        existing = await fs13.readFile(file, "utf8");
+        existing = await fs12.readFile(file, "utf8");
       } catch {
         return 0;
       }
@@ -7590,7 +6809,7 @@ var FileMemoryBackend = class {
   async readAll(scope, filePath) {
     const file = this.resolveFile(filePath, scope);
     try {
-      return await fs13.readFile(file, "utf8");
+      return await fs12.readFile(file, "utf8");
     } catch {
       return "";
     }
@@ -7614,7 +6833,7 @@ var FileMemoryBackend = class {
     const file = this.resolveFile(filePath, scope);
     let existing;
     try {
-      existing = await fs13.readFile(file, "utf8");
+      existing = await fs12.readFile(file, "utf8");
     } catch {
       return 0;
     }
@@ -7634,7 +6853,7 @@ var FileMemoryBackend = class {
     const next = lines.join("\n");
     const backup = `${file}.bak.${Date.now()}`;
     try {
-      await fs13.copyFile(file, backup);
+      await fs12.copyFile(file, backup);
       await pruneConsolidateBackups(file);
     } catch {
     }
@@ -7648,14 +6867,14 @@ var FileMemoryBackend = class {
   }
 };
 async function pruneConsolidateBackups(file) {
-  const dir = path15.dirname(file);
-  const base = path15.basename(file);
+  const dir = path14.dirname(file);
+  const base = path14.basename(file);
   const prefix = `${base}.bak.`;
-  const backups = (await fs13.readdir(dir)).filter((name) => name.startsWith(prefix)).sort().reverse();
+  const backups = (await fs12.readdir(dir)).filter((name) => name.startsWith(prefix)).sort().reverse();
   await Promise.all(
     backups.slice(MAX_MEMORY_CONSOLIDATE_BACKUPS).map(async (name) => {
       try {
-        await fs13.unlink(path15.join(dir, name));
+        await fs12.unlink(path14.join(dir, name));
       } catch {
       }
     })
@@ -7671,11 +6890,11 @@ function parseEntries(raw, scope = "project-memory") {
 }
 
 // src/storage/memory-consolidator.ts
-import * as path17 from "node:path";
+import * as path16 from "node:path";
 
 // src/utils/instruction-file.ts
 import { readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
-import * as path16 from "node:path";
+import * as path15 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var textCache = /* @__PURE__ */ new Map();
 var rootCandidates;
@@ -7685,7 +6904,7 @@ function readBundledInstructionText(relativePath) {
   let resolved = "";
   for (const root of instructionRootCandidates()) {
     try {
-      resolved = readFileSync3(path16.join(root, relativePath), "utf8").trimEnd();
+      resolved = readFileSync3(path15.join(root, relativePath), "utf8").trimEnd();
       break;
     } catch {
     }
@@ -7701,11 +6920,11 @@ function renderInstructionTemplate(template, values) {
 }
 function instructionRootCandidates() {
   if (rootCandidates !== void 0) return rootCandidates;
-  const here = path16.dirname(fileURLToPath2(import.meta.url));
+  const here = path15.dirname(fileURLToPath2(import.meta.url));
   const candidates = [
-    path16.resolve(here, "../../instructions"),
-    path16.resolve(here, "../instructions"),
-    path16.resolve(here, "instructions")
+    path15.resolve(here, "../../instructions"),
+    path15.resolve(here, "../instructions"),
+    path15.resolve(here, "instructions")
   ];
   rootCandidates = candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
   return rootCandidates;
@@ -7775,8 +6994,8 @@ ${existingEntries.map((e) => `- [${e.ts.slice(0, 10)}] ${e.text}`).join("\n")}`
   });
 }
 function relativeEvidencePath(projectRoot, filePath) {
-  const relative8 = path17.relative(projectRoot, filePath);
-  return relative8 && !relative8.startsWith("..") && !path17.isAbsolute(relative8) ? relative8.replaceAll("\\", "/") : filePath.replaceAll("\\", "/");
+  const relative8 = path16.relative(projectRoot, filePath);
+  return relative8 && !relative8.startsWith("..") && !path16.isAbsolute(relative8) ? relative8.replaceAll("\\", "/") : filePath.replaceAll("\\", "/");
 }
 function safeCommandEvidence(value) {
   if (typeof value !== "string") return void 0;
@@ -7986,7 +7205,7 @@ function buildSessionDigestText(finalText, iterations, factsAdded) {
 }
 
 // src/storage/memory-graph-backend.ts
-import * as fs14 from "node:fs/promises";
+import * as fs13 from "node:fs/promises";
 var GraphMemoryBackend = class _GraphMemoryBackend {
   kind = "graph";
   file;
@@ -8154,7 +7373,7 @@ var GraphMemoryBackend = class _GraphMemoryBackend {
     this.loadedScope = scope;
     this.loaded = true;
     try {
-      await fs14.unlink(this.graphFile);
+      await fs13.unlink(this.graphFile);
     } catch {
     }
   }
@@ -8194,7 +7413,7 @@ var GraphMemoryBackend = class _GraphMemoryBackend {
   async loadGraph(scope) {
     if (this.loaded && this.loadedScope === scope) return;
     try {
-      const raw = await fs14.readFile(this.graphFile, "utf8");
+      const raw = await fs13.readFile(this.graphFile, "utf8");
       const data = JSON.parse(raw);
       this.nodes = new Map(data.nodes);
       this.edges = data.edges;
@@ -8216,10 +7435,10 @@ var GraphMemoryBackend = class _GraphMemoryBackend {
         edges: this.edges
       };
       const dir = this.graphFile.substring(0, this.graphFile.lastIndexOf("/"));
-      await fs14.mkdir(dir, { recursive: true });
+      await fs13.mkdir(dir, { recursive: true });
       const tmp = `${this.graphFile}.tmp`;
-      await fs14.writeFile(tmp, JSON.stringify(data));
-      await fs14.rename(tmp, this.graphFile);
+      await fs13.writeFile(tmp, JSON.stringify(data));
+      await fs13.rename(tmp, this.graphFile);
     } catch {
     }
   }
@@ -8677,8 +7896,8 @@ ${cat}:`);
 
 // src/storage/prompt-store.ts
 import { createHash as createHash5 } from "node:crypto";
-import * as fs15 from "node:fs/promises";
-import * as path18 from "node:path";
+import * as fs14 from "node:fs/promises";
+import * as path17 from "node:path";
 
 // src/utils/slug.ts
 function slugify2(name, fallback = "prompt", maxLen = 64) {
@@ -8777,12 +7996,12 @@ var DefaultPromptStore = class {
     await ensureDir(this.dir);
     const entries = [];
     try {
-      const files = await fs15.readdir(this.dir);
+      const files = await fs14.readdir(this.dir);
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
         try {
           const raw = JSON.parse(
-            await fs15.readFile(path18.join(this.dir, file), "utf8")
+            await fs14.readFile(path17.join(this.dir, file), "utf8")
           );
           const migrated = migratePromptEntry(raw.entry);
           if (migrated) entries.push(migrated);
@@ -8796,9 +8015,9 @@ var DefaultPromptStore = class {
     );
   }
   async get(id) {
-    const file = path18.join(this.dir, `${id}.json`);
+    const file = path17.join(this.dir, `${id}.json`);
     try {
-      const raw = JSON.parse(await fs15.readFile(file, "utf8"));
+      const raw = JSON.parse(await fs14.readFile(file, "utf8"));
       return migratePromptEntry(raw.entry);
     } catch {
       return null;
@@ -8806,14 +8025,14 @@ var DefaultPromptStore = class {
   }
   async save(entry) {
     await ensureDir(this.dir);
-    const file = path18.join(this.dir, `${entry.id}.json`);
+    const file = path17.join(this.dir, `${entry.id}.json`);
     const raw = { version: SCHEMA_VERSION, entry };
     await atomicWrite(file, JSON.stringify(raw, null, 2));
   }
   async delete(id) {
-    const file = path18.join(this.dir, `${id}.json`);
+    const file = path17.join(this.dir, `${id}.json`);
     try {
-      await fs15.unlink(file);
+      await fs14.unlink(file);
       return true;
     } catch {
       return false;
@@ -8852,7 +8071,7 @@ var DefaultPromptStore = class {
 };
 
 // src/storage/prompt-usage-store.ts
-import * as fs16 from "node:fs/promises";
+import * as fs15 from "node:fs/promises";
 var PromptUsageStore = class {
   constructor(file) {
     this.file = file;
@@ -8872,7 +8091,7 @@ var PromptUsageStore = class {
       return this.cachedUsage;
     }
     try {
-      const raw = JSON.parse(await fs16.readFile(this.file, "utf8"));
+      const raw = JSON.parse(await fs15.readFile(this.file, "utf8"));
       if (raw && typeof raw === "object" && raw.usage && typeof raw.usage === "object") {
         this.cachedUsage = raw.usage;
         this.cachedSignature = signature;
@@ -8885,8 +8104,8 @@ var PromptUsageStore = class {
     return this.cachedUsage;
   }
   async record(slug, at = (/* @__PURE__ */ new Date()).toISOString()) {
-    return await new Promise((resolve14, reject) => {
-      this.pendingRecords.push({ slug, at, resolve: resolve14, reject });
+    return await new Promise((resolve13, reject) => {
+      this.pendingRecords.push({ slug, at, resolve: resolve13, reject });
       this.scheduleDrain();
     });
   }
@@ -8952,7 +8171,7 @@ var PromptUsageStore = class {
   }
   async fileSignature() {
     try {
-      const stat19 = await fs16.stat(this.file);
+      const stat19 = await fs15.stat(this.file);
       return { size: stat19.size, mtimeMs: stat19.mtimeMs, ctimeMs: stat19.ctimeMs };
     } catch {
       return null;
@@ -8969,12 +8188,12 @@ function cloneUsage(usage) {
 
 // src/storage/provider-config-watcher.ts
 import * as syncFs from "node:fs";
-import * as fs17 from "node:fs/promises";
-import * as path19 from "node:path";
+import * as fs16 from "node:fs/promises";
+import * as path18 from "node:path";
 async function readProviderSnapshot(configPath, vault, warn) {
   let raw;
   try {
-    raw = await fs17.readFile(configPath, "utf8");
+    raw = await fs16.readFile(configPath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") {
       warn?.(`Could not read ${configPath}: ${err.message}`);
@@ -9046,7 +8265,7 @@ function serializeSnapshot(s) {
 function watchProviderConfig(configPath, vault, onChange, opts = {}) {
   const debounceMs = opts.debounceMs ?? 200;
   const warn = opts.warn;
-  const base = path19.basename(configPath);
+  const base = path18.basename(configPath);
   let timer;
   let closed = false;
   let lastSerialized;
@@ -9057,7 +8276,7 @@ function watchProviderConfig(configPath, vault, onChange, opts = {}) {
   });
   let watcher;
   try {
-    watcher = syncFs.watch(path19.dirname(configPath), { recursive: false });
+    watcher = syncFs.watch(path18.dirname(configPath), { recursive: false });
   } catch (err) {
     warn?.(`Provider config watcher could not start: ${err.message}`);
     return { close: () => {
@@ -9101,7 +8320,7 @@ function watchProviderConfig(configPath, vault, onChange, opts = {}) {
 
 // src/storage/queue-store.ts
 import * as fsp6 from "node:fs/promises";
-import * as path20 from "node:path";
+import * as path19 from "node:path";
 var QUEUE_MAX_ITEMS = 100;
 var QUEUE_MAX_BYTES = 16 * 1024 * 1024;
 var QUEUE_MAX_ITEM_BYTES = 8 * 1024 * 1024;
@@ -9134,7 +8353,7 @@ var QueueStore = class {
   traceId;
   logger;
   constructor(opts) {
-    this.file = path20.join(opts.dir, "queue.json");
+    this.file = path19.join(opts.dir, "queue.json");
     this.events = opts.events;
     this.traceId = opts.traceId;
     this.logger = opts.logger;
@@ -9350,7 +8569,7 @@ function isPersistedQueueItem(v) {
 // src/storage/recovery-lock.ts
 import * as fsp7 from "node:fs/promises";
 import * as os3 from "node:os";
-import * as path21 from "node:path";
+import * as path20 from "node:path";
 
 // src/storage/session-workspace-checkpoints.ts
 function requiredCheckpointCas(checkpointCas, operation) {
@@ -9435,7 +8654,7 @@ var RecoveryLock = class {
   sessionStore;
   probe;
   constructor(opts) {
-    this.file = path21.join(opts.dir, LOCK_FILE);
+    this.file = path20.join(opts.dir, LOCK_FILE);
     this.pid = opts.pid ?? process.pid;
     this.hostname = opts.hostname ?? os3.hostname();
     this.maxAgeMs = opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
@@ -9509,7 +8728,7 @@ var RecoveryLock = class {
    * null return before calling this.
    */
   async write(sessionId) {
-    await ensureDir(path21.dirname(this.file));
+    await ensureDir(path20.dirname(this.file));
     const lock = {
       v: 1,
       sessionId,
@@ -9568,30 +8787,30 @@ var defaultIsPidAlive = isPidAlive;
 
 // src/storage/orphan-lock-cleaner.ts
 import * as fsp8 from "node:fs/promises";
-import * as path22 from "node:path";
+import * as path21 from "node:path";
 async function cleanOrphanLocks(projectRoot, options) {
   const result = {
     cleanedGitLocks: [],
     cleanedWorktrees: [],
     errors: []
   };
-  const pidAlive3 = options?.isPidAlive ?? isPidAlive;
+  const pidAlive2 = options?.isPidAlive ?? isPidAlive;
   const maxAgeMs = options?.maxLockAgeMs ?? 10 * 60 * 1e3;
   const now = Date.now();
-  const worktreesDir = path22.join(projectRoot, ".wrongstack", "worktrees");
+  const worktreesDir = path21.join(projectRoot, ".wrongstack", "worktrees");
   try {
     const entries = await fsp8.readdir(worktreesDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const wtPath = path22.join(worktreesDir, entry.name);
-      const lockPath = path22.join(wtPath, ".lock");
+      const wtPath = path21.join(worktreesDir, entry.name);
+      const lockPath = path21.join(wtPath, ".lock");
       try {
         const lockStat = await fsp8.stat(lockPath).catch(() => null);
         if (lockStat) {
           const raw = await fsp8.readFile(lockPath, "utf8").catch(() => "");
           const pid = parseInt(raw.trim(), 10);
           if (Number.isInteger(pid) && pid > 0) {
-            if (!pidAlive3(pid)) {
+            if (!pidAlive2(pid)) {
               await fsp8.unlink(lockPath).catch(() => void 0);
               result.cleanedWorktrees.push(wtPath);
             }
@@ -9613,8 +8832,8 @@ async function cleanOrphanLocks(projectRoot, options) {
 }
 
 // src/storage/replay-log-store.ts
-import * as fs18 from "node:fs/promises";
-import * as path23 from "node:path";
+import * as fs17 from "node:fs/promises";
+import * as path22 from "node:path";
 
 // src/replay/hash.ts
 import { createHash as createHash6 } from "node:crypto";
@@ -9708,12 +8927,12 @@ var ReplayLogStore = class _ReplayLogStore {
             const line = JSON.stringify(entry) + "\n";
             let offset2 = 0;
             try {
-              const stat19 = await fs18.stat(fp);
+              const stat19 = await fs17.stat(fp);
               offset2 = stat19.size;
             } catch (err) {
               if (err.code !== "ENOENT") throw err;
             }
-            await fs18.appendFile(fp, line, { encoding: "utf8", mode: SECRET_FILE_MODE });
+            await fs17.appendFile(fp, line, { encoding: "utf8", mode: SECRET_FILE_MODE });
             cache.set(hash, { entry, offset: offset2, length: Buffer.byteLength(line, "utf8") });
             this.diskCount.set(input.sessionId, currentCount + 1);
             this.events?.emit("storage.write", {
@@ -9841,7 +9060,7 @@ var ReplayLogStore = class _ReplayLogStore {
     const scan = async (dir, prefix, depth) => {
       let entries;
       try {
-        entries = await fs18.readdir(dir, { withFileTypes: true });
+        entries = await fs17.readdir(dir, { withFileTypes: true });
       } catch (err) {
         if (depth === 0 && err.code !== "ENOENT") {
           console.warn(
@@ -9859,13 +9078,13 @@ var ReplayLogStore = class _ReplayLogStore {
       for (const entry of entries) {
         if (entry.name.startsWith(".")) continue;
         if (entry.isDirectory()) {
-          if (depth === 0) await scan(path23.join(dir, entry.name), entry.name, depth + 1);
+          if (depth === 0) await scan(path22.join(dir, entry.name), entry.name, depth + 1);
           continue;
         }
         if (!entry.isFile() || !entry.name.endsWith(".replay.jsonl")) continue;
         const base = entry.name.slice(0, -".replay.jsonl".length);
         const sessionId = prefix ? `${prefix}/${base}` : base;
-        const fp = path23.join(dir, entry.name);
+        const fp = path22.join(dir, entry.name);
         out.push({
           sessionId,
           entryCount: await this.countEntries(fp),
@@ -9881,7 +9100,7 @@ var ReplayLogStore = class _ReplayLogStore {
     return sessionScopedPath(this.dir, sessionId, ".replay.jsonl");
   }
   async countEntries(filePath) {
-    const handle = await fs18.open(filePath, "r");
+    const handle = await fs17.open(filePath, "r");
     const buffer = Buffer.allocUnsafe(64 * 1024);
     let count = 0;
     let hasNonWhitespace2 = false;
@@ -9922,7 +9141,7 @@ var ReplayLogStore = class _ReplayLogStore {
   async readAll(sessionId) {
     const fp = this.filePath(sessionId);
     try {
-      const raw = await fs18.readFile(fp, "utf8");
+      const raw = await fs17.readFile(fp, "utf8");
       const out = [];
       for (const line of raw.split("\n")) {
         if (!line.trim()) continue;
@@ -9962,7 +9181,7 @@ var ReplayLogStore = class _ReplayLogStore {
     const fp = this.filePath(sessionId);
     cache = /* @__PURE__ */ new Map();
     try {
-      const handle = await fs18.open(fp, "r");
+      const handle = await fs17.open(fp, "r");
       const CHUNK = 64 * 1024;
       const buffer = Buffer.alloc(CHUNK);
       let leftover = "";
@@ -10048,7 +9267,7 @@ var ReplayLogStore = class _ReplayLogStore {
     const fp = this.filePath(sessionId);
     let handle;
     try {
-      handle = await fs18.open(fp, "r");
+      handle = await fs17.open(fp, "r");
     } catch {
       return null;
     }
@@ -10178,7 +9397,7 @@ var SessionAnalyzer = class {
 import { spawn as spawn2 } from "node:child_process";
 import { createHash as createHash7, randomUUID as randomUUID6 } from "node:crypto";
 import * as fsp9 from "node:fs/promises";
-import * as path24 from "node:path";
+import * as path23 from "node:path";
 
 // src/utils/child-env.ts
 var ALLOWED_KEYS = /* @__PURE__ */ new Set([
@@ -10345,13 +9564,13 @@ function sha256(content) {
   return createHash7("sha256").update(content).digest("hex");
 }
 function isInside(root, target) {
-  const relative8 = path24.relative(root, target);
-  return relative8 === "" || !relative8.startsWith("..") && !path24.isAbsolute(relative8);
+  const relative8 = path23.relative(root, target);
+  return relative8 === "" || !relative8.startsWith("..") && !path23.isAbsolute(relative8);
 }
 function normalizeRelative(input) {
-  if (!input || path24.isAbsolute(input)) return null;
+  if (!input || path23.isAbsolute(input)) return null;
   const normalized = input.replace(/\\/g, "/").replace(/^\.\//, "");
-  const resolved = path24.posix.normalize(normalized);
+  const resolved = path23.posix.normalize(normalized);
   if (!resolved || resolved === "." || resolved === ".." || resolved.startsWith("../")) return null;
   return resolved;
 }
@@ -10366,8 +9585,8 @@ var SessionCheckpointCas = class {
   projectRoot;
   runGit;
   constructor(opts) {
-    this.rootDir = path24.resolve(opts.rootDir);
-    this.projectRoot = path24.resolve(opts.projectRoot);
+    this.rootDir = path23.resolve(opts.rootDir);
+    this.projectRoot = path23.resolve(opts.projectRoot);
     this.runGit = opts.runGit ?? defaultRunGit;
   }
   async capture(_sessionId, _promptIndex) {
@@ -10392,7 +9611,7 @@ var SessionCheckpointCas = class {
       relativePaths,
       CAPTURE_CONCURRENCY,
       async (relative8) => {
-        const absolute = path24.resolve(this.projectRoot, ...relative8.split("/"));
+        const absolute = path23.resolve(this.projectRoot, ...relative8.split("/"));
         if (!isInside(this.projectRoot, absolute)) {
           unresolved.push({ path: relative8, reason: "path escapes project root" });
           return null;
@@ -10401,8 +9620,8 @@ var SessionCheckpointCas = class {
           const stat19 = await fsp9.lstat(absolute);
           if (stat19.isSymbolicLink()) {
             const linkTarget = await fsp9.readlink(absolute);
-            const resolvedLink = path24.resolve(path24.dirname(absolute), linkTarget);
-            if (path24.isAbsolute(linkTarget) || !isInside(this.projectRoot, resolvedLink)) {
+            const resolvedLink = path23.resolve(path23.dirname(absolute), linkTarget);
+            if (path23.isAbsolute(linkTarget) || !isInside(this.projectRoot, resolvedLink)) {
               unresolved.push({
                 path: relative8,
                 reason: "symlink target escapes project root"
@@ -10464,7 +9683,7 @@ var SessionCheckpointCas = class {
     };
   }
   async materialize(checkpoint, targetRoot) {
-    const target = path24.resolve(targetRoot);
+    const target = path23.resolve(targetRoot);
     if (target === this.projectRoot) {
       throw new Error("Refusing to materialize a workspace checkpoint over the parent project root");
     }
@@ -10504,10 +9723,10 @@ var SessionCheckpointCas = class {
       try {
         const output = await this.safeOutputPath(target, realTarget, entry.path);
         if (entry.state === "symlink") {
-          if (path24.isAbsolute(entry.linkTarget)) {
+          if (path23.isAbsolute(entry.linkTarget)) {
             throw new Error("absolute symlink target refused");
           }
-          const resolvedLink = path24.resolve(path24.dirname(output), entry.linkTarget);
+          const resolvedLink = path23.resolve(path23.dirname(output), entry.linkTarget);
           if (!isInside(target, resolvedLink)) throw new Error("symlink target escapes checkpoint root");
         }
         prepared.push({
@@ -10535,7 +9754,7 @@ var SessionCheckpointCas = class {
           await fsp9.unlink(output).catch((err) => {
             if (err.code !== "ENOENT") throw err;
           });
-          await fsp9.mkdir(path24.dirname(output), { recursive: true });
+          await fsp9.mkdir(path23.dirname(output), { recursive: true });
           await fsp9.symlink(entry.linkTarget, output);
           writtenFiles.push(entry.path);
           continue;
@@ -10552,15 +9771,15 @@ var SessionCheckpointCas = class {
   }
   objectPath(hash) {
     if (!HASH_RE.test(hash)) throw new Error(`Invalid CAS object hash: ${hash}`);
-    return path24.join(this.rootDir, "objects", hash.slice(0, 2), hash.slice(2));
+    return path23.join(this.rootDir, "objects", hash.slice(0, 2), hash.slice(2));
   }
   manifestPath(hash) {
     if (!HASH_RE.test(hash)) throw new Error(`Invalid checkpoint manifest hash: ${hash}`);
-    return path24.join(this.rootDir, "manifests", `${hash}.json`);
+    return path23.join(this.rootDir, "manifests", `${hash}.json`);
   }
   async putBlob(hash, content) {
     const target = this.objectPath(hash);
-    await fsp9.mkdir(path24.dirname(target), { recursive: true });
+    await fsp9.mkdir(path23.dirname(target), { recursive: true });
     try {
       const existing = await fsp9.readFile(target);
       if (sha256(existing) !== hash) throw new Error(`Corrupt CAS object collision: ${hash}`);
@@ -10568,9 +9787,9 @@ var SessionCheckpointCas = class {
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
-    const temp = path24.join(
-      path24.dirname(target),
-      `.${path24.basename(target)}.${process.pid}.${randomUUID6()}.tmp`
+    const temp = path23.join(
+      path23.dirname(target),
+      `.${path23.basename(target)}.${process.pid}.${randomUUID6()}.tmp`
     );
     let handle;
     try {
@@ -10631,7 +9850,7 @@ var SessionCheckpointCas = class {
   async safeOutputPath(target, realTarget, relative8) {
     const normalized = normalizeRelative(relative8);
     if (!normalized) throw new Error("invalid relative path");
-    const output = path24.resolve(target, ...normalized.split("/"));
+    const output = path23.resolve(target, ...normalized.split("/"));
     if (!isInside(target, output)) throw new Error("path escapes checkpoint target");
     let probe = output;
     for (; ; ) {
@@ -10641,7 +9860,7 @@ var SessionCheckpointCas = class {
         return output;
       } catch (err) {
         if (err.code !== "ENOENT") throw err;
-        const parent = path24.dirname(probe);
+        const parent = path23.dirname(probe);
         if (parent === probe) throw err;
         probe = parent;
       }
@@ -10649,7 +9868,7 @@ var SessionCheckpointCas = class {
   }
 };
 function defaultRunGit(args, cwd) {
-  return new Promise((resolve14) => {
+  return new Promise((resolve13) => {
     const stdoutChunks = [];
     const stderrChunks = [];
     let stdoutBytes = 0;
@@ -10692,8 +9911,8 @@ function defaultRunGit(args, cwd) {
       stdoutTruncated,
       stderrTruncated
     });
-    child.on("error", (err) => resolve14(result(1, err.message)));
-    child.on("close", (code) => resolve14(result(code ?? 1)));
+    child.on("error", (err) => resolve13(result(1, err.message)));
+    child.on("close", (code) => resolve13(result(code ?? 1)));
   });
 }
 
@@ -10846,13 +10065,13 @@ function generateSessionId(startedAt, _model) {
 }
 
 // src/storage/session-id-resolver.ts
-import * as path25 from "node:path";
+import * as path24 from "node:path";
 function resolveSessionId(query, candidateIds) {
   const normalized = query.trim();
   if (!normalized) return { status: "missing", query: normalized };
   const uniqueIds = [...new Set(candidateIds)];
   if (uniqueIds.includes(normalized)) return { status: "resolved", id: normalized };
-  const leaf = (id) => path25.posix.basename(id.replace(/\\/g, "/"));
+  const leaf = (id) => path24.posix.basename(id.replace(/\\/g, "/"));
   const exactLeafMatches = uniqueIds.filter((id) => leaf(id) === normalized);
   if (exactLeafMatches.length === 1) {
     return { status: "resolved", id: exactLeafMatches[0] };
@@ -10904,127 +10123,11 @@ function scrubPersistedSessionSummary(summary2, scrubber) {
 }
 
 // src/utils/regex-guard.ts
-var MAX_PATTERN_LEN = 256;
-var DANGEROUS_PATTERNS = [
-  // (a+)+, (.*)+, etc — nested quantifier on a group with internal quantifier
-  /(\([^)]*[+*][^)]*\))[+*]/,
-  /(\(\?:[^)]*[+*][^)]*\))[+*]/,
-  // Adjacent quantifiers: a++ a*+
-  /[+*]{2,}/,
-  // Quantifier on alternation with length 2+
-  /\([^|)]+\|[^)]+\)[+*][+*]/,
-  // Greedy quantifier inside lookahead/lookbehind — (?!.*a+)
-  /[([][^)\]]*[+*][^)\]]*[)\]][^)]*\?\??/
-];
-function hasAmbiguousQuantifiedAlternation(pattern) {
-  for (let i = 0; i < pattern.length; i++) {
-    if (pattern[i] !== "(") continue;
-    if (i > 0 && pattern[i - 1] === "\\") continue;
-    let depth = 0;
-    let inClass = false;
-    let j = i;
-    for (; j < pattern.length; j++) {
-      const ch = pattern[j];
-      if (ch === "\\") {
-        j++;
-        continue;
-      }
-      if (inClass) {
-        if (ch === "]") inClass = false;
-        continue;
-      }
-      if (ch === "[") {
-        inClass = true;
-        continue;
-      }
-      if (ch === "(") depth++;
-      else if (ch === ")") {
-        depth--;
-        if (depth === 0) break;
-      }
-    }
-    if (j >= pattern.length) return false;
-    const next = pattern[j + 1];
-    if (next !== "+" && next !== "*" && next !== "{") continue;
-    let inner = pattern.slice(i + 1, j);
-    inner = inner.replace(/^\?(?::|<?[=!])/u, "");
-    const branches = [];
-    let current = "";
-    let d = 0;
-    let cls = false;
-    for (let k = 0; k < inner.length; k++) {
-      const ch = inner[k];
-      if (ch === "\\") {
-        current += ch + (inner[k + 1] ?? "");
-        k++;
-        continue;
-      }
-      if (cls) {
-        if (ch === "]") cls = false;
-        current += ch;
-        continue;
-      }
-      if (ch === "[") {
-        cls = true;
-        current += ch;
-        continue;
-      }
-      if (ch === "(") d++;
-      if (ch === ")") d--;
-      if (ch === "|" && d === 0) {
-        branches.push(current);
-        current = "";
-        continue;
-      }
-      current += ch;
-    }
-    branches.push(current);
-    if (branches.length < 2) continue;
-    for (let a = 0; a < branches.length; a++) {
-      for (let b = a + 1; b < branches.length; b++) {
-        const x = branches[a];
-        const y = branches[b];
-        if (x === "" || y === "") return true;
-        if (x === y || x.startsWith(y) || y.startsWith(x)) return true;
-      }
-    }
-  }
-  return false;
-}
-function compileUserRegex(pattern, flags) {
-  if (typeof pattern !== "string") {
-    return { ok: false, reason: "pattern must be a string" };
-  }
-  if (pattern.length === 0) {
-    return { ok: false, reason: "pattern is empty" };
-  }
-  if (pattern.length > MAX_PATTERN_LEN) {
-    return { ok: false, reason: `pattern exceeds ${MAX_PATTERN_LEN} characters` };
-  }
-  for (const rx of DANGEROUS_PATTERNS) {
-    if (rx.test(pattern)) {
-      return {
-        ok: false,
-        reason: "pattern looks vulnerable to catastrophic backtracking \u2014 rewrite without nested quantifiers"
-      };
-    }
-  }
-  if (hasAmbiguousQuantifiedAlternation(pattern)) {
-    return {
-      ok: false,
-      reason: "pattern quantifies an alternation with overlapping branches \u2014 rewrite so no two branches can match the same text"
-    };
-  }
-  try {
-    return { ok: true, regex: new RegExp(pattern, flags) };
-  } catch (err) {
-    return {
-      ok: false,
-      reason: err instanceof Error ? err.message : "invalid regex"
-    };
-  }
-}
-var MAX_SUBJECT_LEN = 64 * 1024;
+import {
+  capSubject,
+  compileUserRegex,
+  MAX_SUBJECT_LEN
+} from "@wrongstack/primitives";
 
 // src/storage/session-reader.ts
 var DefaultSessionReader = class {
@@ -11380,13 +10483,13 @@ function renderPlainText(meta, events) {
 
 // src/storage/session-recovery.ts
 import { createReadStream } from "node:fs";
-import * as fs19 from "node:fs/promises";
-import * as path27 from "node:path";
+import * as fs18 from "node:fs/promises";
+import * as path26 from "node:path";
 import { createInterface } from "node:readline";
 
 // src/storage/session-store/directory-session-files.ts
 import * as fsp10 from "node:fs/promises";
-import * as path26 from "node:path";
+import * as path25 from "node:path";
 
 // src/storage/session-store/directory-scan.ts
 function shouldSkipSessionDirectoryEntry(name) {
@@ -11415,12 +10518,12 @@ async function collectSessionFiles(dir, prefix = "", depth = 0) {
     if (entry.isDirectory()) {
       dirEntries.push(entry);
     } else if (entry.isFile() && isSessionTranscriptFileName(entry.name)) {
-      files.push({ id: sessionIdForFile(prefix, entry.name), filePath: path26.join(dir, entry.name) });
+      files.push({ id: sessionIdForFile(prefix, entry.name), filePath: path25.join(dir, entry.name) });
     }
   }
   const childFileArrays = await Promise.all(
     dirEntries.map(
-      (entry) => collectSessionFiles(path26.join(dir, entry.name), childPrefixFor(entry, prefix, depth), depth + 1)
+      (entry) => collectSessionFiles(path25.join(dir, entry.name), childPrefixFor(entry, prefix, depth), depth + 1)
     )
   );
   return [...childFileArrays.flat(), ...files];
@@ -11444,7 +10547,7 @@ async function collectSessionIds(dir, prefix = "", depth = 0) {
   }
   const childIdArrays = await Promise.all(
     dirEntries.map(
-      (entry) => collectSessionIds(path26.join(dir, entry.name), childPrefixFor(entry, prefix, depth), depth + 1)
+      (entry) => collectSessionIds(path25.join(dir, entry.name), childPrefixFor(entry, prefix, depth), depth + 1)
     )
   );
   return [...childIdArrays.flat(), ...fileIds];
@@ -11454,11 +10557,14 @@ async function collectSessionIds(dir, prefix = "", depth = 0) {
 function extractInterruptedTools(plan) {
   const tools = [];
   const openCalls = /* @__PURE__ */ new Map();
+  let anonymousSeq = 0;
   for (const ev of plan.pendingEvents) {
     if ((ev.type === "tool_use" || ev.type === "tool_call_start") && typeof ev.name === "string") {
       const toolName = ev.name;
-      const callId = ev.id ?? toolName;
+      const rawId = ev.id;
+      const callId = rawId ?? toolName;
       openCalls.set(callId, {
+        id: rawId,
         name: toolName,
         args: ev.input ?? ev.args,
         ts: ev.ts
@@ -11469,8 +10575,10 @@ function extractInterruptedTools(plan) {
     } else if (ev.type === "llm_response" && Array.isArray(ev.content)) {
       for (const block of ev.content) {
         if (block && block.type === "tool_use" && typeof block.name === "string") {
-          const callId = block.id ?? block.name;
+          const rawId = block.id;
+          const callId = rawId ?? `${block.name}#${++anonymousSeq}`;
           openCalls.set(callId, {
+            id: rawId,
             name: block.name,
             args: block.input,
             ts: ev.ts
@@ -11482,8 +10590,10 @@ function extractInterruptedTools(plan) {
       if (Array.isArray(msg.content)) {
         for (const block of msg.content) {
           if (block && block.type === "tool_use" && typeof block.name === "string") {
-            const callId = block.id ?? block.name;
+            const rawId = block.id;
+            const callId = rawId ?? `${block.name}#${++anonymousSeq}`;
             openCalls.set(callId, {
+              id: rawId,
               name: block.name,
               args: block.input,
               ts: ev.ts
@@ -11506,6 +10616,7 @@ function extractInterruptedTools(plan) {
       }
     }
     tools.push({
+      id: call.id,
       name: call.name,
       argsSummary,
       ts: call.ts
@@ -11520,6 +10631,47 @@ var SessionRecovery = class _SessionRecovery {
   dir;
   static MAX_PENDING_EVENTS = 1e4;
   static MAX_PENDING_BYTES = 16 * 1024 * 1024;
+  /**
+   * Build a recovery plan from ALREADY-LOADED events without touching disk.
+   * executeResumeSession uses this because load() has already paid for the
+   * transcript read; recover()'s file scan would duplicate it.
+   */
+  static buildRecoveryPlan(events, sessionId) {
+    const pendingEvents = [];
+    const pendingSizes = [];
+    let pendingBytes = 0;
+    let lastCheckpoint = null;
+    let latestBoundary = null;
+    for (const event of events) {
+      if (!event || typeof event !== "object" || typeof event.type !== "string") continue;
+      if (event.type === "checkpoint") {
+        lastCheckpoint = event;
+        pendingEvents.length = 0;
+        pendingSizes.length = 0;
+        pendingBytes = 0;
+        continue;
+      }
+      if (isLifecycleBoundary(event)) latestBoundary = event;
+      const bytes = Buffer.byteLength(JSON.stringify(event), "utf8");
+      if (bytes > _SessionRecovery.MAX_PENDING_BYTES) continue;
+      while (pendingEvents.length >= _SessionRecovery.MAX_PENDING_EVENTS || pendingBytes + bytes > _SessionRecovery.MAX_PENDING_BYTES) {
+        pendingBytes -= pendingSizes.shift();
+        pendingEvents.shift();
+      }
+      pendingEvents.push(event);
+      pendingSizes.push(bytes);
+      pendingBytes += bytes;
+    }
+    const inFlightStart = latestBoundary?.type === "in_flight_start" ? latestBoundary : null;
+    return {
+      sessionId,
+      stale: inFlightStart !== null,
+      lastCheckpoint,
+      pendingEvents,
+      inFlightStart,
+      context: inFlightStart?.context ?? null
+    };
+  }
   /**
    * Scan a session log and return a `StaleSession` if and only if the newest
    * lifecycle boundary is an `in_flight_start` without a later
@@ -11550,9 +10702,8 @@ var SessionRecovery = class _SessionRecovery {
     const fp = this.filePath(sessionId);
     let stat19;
     try {
-      stat19 = await fs19.stat(fp);
-    } catch (err) {
-      if (err.code === "ENOENT") return null;
+      stat19 = await fs18.stat(fp);
+    } catch {
       return null;
     }
     if (stat19.size === 0) return null;
@@ -11612,7 +10763,7 @@ var SessionRecovery = class _SessionRecovery {
           if (bytes <= _SessionRecovery.MAX_PENDING_BYTES) {
             while (pendingEvents.length >= _SessionRecovery.MAX_PENDING_EVENTS || pendingBytes + bytes > _SessionRecovery.MAX_PENDING_BYTES) {
               pendingEvents.shift();
-              pendingBytes = Math.max(0, pendingBytes - (pendingSizes.shift() ?? 0));
+              pendingBytes = Math.max(0, pendingBytes - pendingSizes.shift());
             }
             pendingEvents.push(event);
             pendingSizes.push(bytes);
@@ -11621,8 +10772,7 @@ var SessionRecovery = class _SessionRecovery {
         }
         if (isLifecycleBoundary(event)) latestBoundary = event;
       }
-    } catch (err) {
-      if (err.code === "ENOENT") return null;
+    } catch {
       return null;
     } finally {
       lines.close();
@@ -11650,7 +10800,7 @@ var SessionRecovery = class _SessionRecovery {
     const collect = async (dir, prefix, depth) => {
       let entries;
       try {
-        entries = await fs19.readdir(dir, { withFileTypes: true });
+        entries = await fs18.readdir(dir, { withFileTypes: true });
       } catch {
         return;
       }
@@ -11660,7 +10810,7 @@ var SessionRecovery = class _SessionRecovery {
           continue;
         if (entry.isDirectory()) {
           if (depth === 0) {
-            await collect(path27.join(dir, entry.name), entry.name, depth + 1);
+            await collect(path26.join(dir, entry.name), entry.name, depth + 1);
           }
           continue;
         }
@@ -11698,7 +10848,7 @@ function hasNonWhitespace(line) {
 }
 async function scanLatestLifecycleBoundary(filePath, size) {
   const CHUNK_SIZE2 = 64 * 1024;
-  const handle = await fs19.open(filePath, "r");
+  const handle = await fs18.open(filePath, "r");
   let position = size;
   let laterLineFragment = Buffer.alloc(0);
   let latestBoundary = null;
@@ -11738,7 +10888,7 @@ async function scanLatestLifecycleBoundary(filePath, size) {
 // src/storage/session-store.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
 import * as fsp26 from "node:fs/promises";
-import * as path34 from "node:path";
+import * as path33 from "node:path";
 
 // src/utils/message-invariants.ts
 function repairToolUseAdjacency(messages) {
@@ -11848,7 +10998,7 @@ function isEmptyMessage(msg) {
 
 // src/storage/file-session-writer.ts
 import * as fsp14 from "node:fs/promises";
-import * as path28 from "node:path";
+import * as path27 from "node:path";
 
 // src/storage/session-summary-tracker.ts
 import { createReadStream as createReadStream2 } from "node:fs";
@@ -11904,6 +11054,29 @@ var SessionSummaryTracker = class {
   get currentSummary() {
     return this.summary;
   }
+  /**
+   * Non-destructive materialization of every live counter into a summary
+   * snapshot. Unlike finalize(), it stamps no endedAt, applies no final
+   * outcome, and resolves no name — mid-session metadata checkpoints use it
+   * so a killed process leaves accurate listing metadata behind without
+   * pretending the session ended cleanly.
+   */
+  snapshot() {
+    const { lastUserMessage: _lastUserMessage, ...rest } = this.summary;
+    return {
+      ...rest,
+      messageCount: this.messageCount,
+      ...this.lastUserMessage !== void 0 ? { lastUserMessage: this.lastUserMessage } : {},
+      iterationCount: this.iterationCount,
+      toolCallCount: this.toolCallCount,
+      toolErrorCount: this.toolErrorCount,
+      fileChangeCount: this.fileChangeCount,
+      compactionCount: this.compactionCount > 0 ? this.compactionCount : void 0,
+      toolBreakdown: { ...this.toolBreakdown },
+      lastActivityAt: this.lastActivityAt,
+      ...this.outcome !== void 0 ? { outcome: this.outcome } : {}
+    };
+  }
   get pendingToolUses() {
     return Array.from(this.openToolUses);
   }
@@ -12096,6 +11269,12 @@ var SessionWriteBuffer = class _SessionWriteBuffer {
   lastAppendWarnAt = 0;
   writeChain = Promise.resolve();
   flushPromise = null;
+  /**
+   * Batch currently inside enqueueWrite. `flushSync` may steal it if the
+   * async append has not started, so a dying process writes in-flight +
+   * remaining buffer as one ordered append instead of racing a second fd.
+   */
+  inFlight = null;
   get isClosed() {
     return false;
   }
@@ -12136,14 +11315,20 @@ var SessionWriteBuffer = class _SessionWriteBuffer {
     return true;
   }
   enqueueWrite(data) {
+    return this.enqueueFlight({ data, stolen: false, started: false });
+  }
+  enqueueFlight(flight) {
     const write = this.writeChain.then(async () => {
+      if (flight.stolen) return;
+      flight.started = true;
+      if (flight.stolen) return;
       try {
-        return await this.opts.getHandle().appendFile(data, "utf8");
+        return await this.opts.getHandle().appendFile(flight.data, "utf8");
       } catch (err) {
         if (isClosedHandleError(err)) {
           const reloaded = await fsp12.open(this.opts.filePath, "a", 384);
           this.opts.setHandle(reloaded);
-          return await reloaded.appendFile(data, "utf8");
+          return await reloaded.appendFile(flight.data, "utf8");
         }
         throw err;
       }
@@ -12168,17 +11353,29 @@ var SessionWriteBuffer = class _SessionWriteBuffer {
       this.flushTimer = null;
     }
   }
-  async flushBuffer(isClosed = false) {
-    if (this.flushPromise) return this.flushPromise;
+  async flushBuffer(isClosed = false, opts = {}) {
+    if (this.flushPromise) {
+      const joined = this.flushPromise;
+      const continueIfDirty = () => {
+        if (this.writeBuffer.length === 0) return Promise.resolve();
+        return this.flushBuffer(isClosed, opts);
+      };
+      if (opts.datasync === true) {
+        return joined.then(
+          () => this.opts.getHandle().datasync().catch(() => void 0).then(continueIfDirty)
+        );
+      }
+      return joined.then(continueIfDirty);
+    }
     const flush = (async () => {
-      while (this.writeBuffer.length > 0) await this.flushBufferOnce(isClosed);
+      while (this.writeBuffer.length > 0) await this.flushBufferOnce(isClosed, opts);
     })().finally(() => {
       if (this.flushPromise === flush) this.flushPromise = null;
     });
     this.flushPromise = flush;
     return flush;
   }
-  async flushBufferOnce(isClosed) {
+  async flushBufferOnce(isClosed, opts) {
     if (this.writeBuffer.length === 0) return;
     const events = this.writeBuffer;
     const eventCount = events.length;
@@ -12186,12 +11383,21 @@ var SessionWriteBuffer = class _SessionWriteBuffer {
     const batch = events.map((e) => JSON.stringify(e)).join("\n") + "\n";
     this.writeBuffer = [];
     this.writeBufferBytes = 0;
+    const flight = { data: batch, stolen: false, started: false };
+    this.inFlight = flight;
     const t0 = Date.now();
     let outcome = "success";
     let errorMsg;
     try {
-      await this.enqueueWrite(batch);
+      await this.enqueueFlight(flight);
+      if (flight.stolen) {
+        return;
+      }
+      if (opts?.datasync === true) {
+        await this.opts.getHandle().datasync().catch(() => void 0);
+      }
     } catch (err) {
+      if (flight.stolen) return;
       outcome = "failure";
       errorMsg = toErrorMessage(err);
       const newer = this.writeBuffer;
@@ -12229,6 +11435,7 @@ var SessionWriteBuffer = class _SessionWriteBuffer {
         ...eventCount !== void 0 ? { eventCount } : {},
         ...this.opts.getTraceId?.() ? { traceId: this.opts.getTraceId() } : {}
       });
+      if (this.inFlight === flight) this.inFlight = null;
     }
   }
   async drainWriteChain() {
@@ -12237,18 +11444,56 @@ var SessionWriteBuffer = class _SessionWriteBuffer {
   async drainFlushPromise() {
     await this.flushPromise?.catch(() => void 0);
   }
+  /**
+   * Last-gasp synchronous append (SIGKILL/SIGTERM traps, `process.on('exit')`).
+   *
+   * Failure contract: nothing is discarded before the write is known to have
+   * landed. Buffered events stay in `writeBuffer` — it is cleared only after
+   * `fsyncSync` returns — and a stolen in-flight batch is handed back to the
+   * async write chain, so a survivable failure (EACCES, ENOSPC, EMFILE) loses
+   * nothing. Failure is never silent: a structured `session.flush_sync_failed`
+   * warning names exactly what was still pending, which is what SIGKILL-trap
+   * tests assert against.
+   */
   flushSync() {
-    if (this.writeBuffer.length === 0 || !this.opts.filePath) return;
+    if (!this.opts.filePath) return;
     this.cancelTimer();
-    const batch = this.writeBuffer.map((e) => JSON.stringify(e)).join("\n") + "\n";
-    this.writeBuffer = [];
-    this.writeBufferBytes = 0;
+    const chunks = [];
+    const flight = this.inFlight;
+    const stole = flight !== null && !flight.started && !flight.stolen;
+    if (stole && flight) {
+      flight.stolen = true;
+      chunks.push(flight.data);
+    }
+    const events = this.writeBuffer;
+    if (events.length > 0) {
+      chunks.push(events.map((e) => JSON.stringify(e)).join("\n") + "\n");
+    }
+    if (chunks.length === 0) return;
     let fd;
     try {
       fd = openSync(this.opts.filePath, "a");
-      writeSync(fd, batch, null, "utf8");
+      writeSync(fd, chunks.join(""), null, "utf8");
       fsyncSync(fd);
-    } catch {
+      if (this.writeBuffer === events) {
+        this.writeBuffer = [];
+        this.writeBufferBytes = 0;
+      }
+    } catch (err) {
+      if (stole && flight) flight.stolen = false;
+      console.warn(
+        JSON.stringify({
+          level: "error",
+          event: "session.flush_sync_failed",
+          sessionId: this.opts.sessionId,
+          filePath: this.opts.filePath,
+          message: toErrorMessage(err),
+          pendingEvents: events.length,
+          pendingBytes: this.writeBufferBytes,
+          hadInFlightBatch: stole,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
     } finally {
       if (fd !== void 0) {
         try {
@@ -12416,6 +11661,17 @@ function isClosedHandleError2(err) {
   const code = err?.code;
   return code === "EBADF" || code === "ERR_CLOSED_RESOURCE" || code === "ERR_INVALID_HANDLE";
 }
+var CRITICAL_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "user_input",
+  "llm_response",
+  "checkpoint",
+  "in_flight_start",
+  "in_flight_end"
+]);
+function isCriticalEvent(event) {
+  return CRITICAL_EVENT_TYPES.has(event.type);
+}
+var METADATA_CHECKPOINT_INTERVAL_MS = 1e4;
 var FileSessionWriter = class _FileSessionWriter {
   constructor(id, handle, startedAt, meta, events, opts = {}, traceId) {
     this.id = id;
@@ -12424,13 +11680,15 @@ var FileSessionWriter = class _FileSessionWriter {
     this.meta = meta;
     this.events = events;
     this.resumed = opts.resumed ?? false;
-    this.manifestFile = opts.dir ? path28.join(opts.dir, `${path28.basename(id)}.summary.json`) : "";
+    this.manifestFile = opts.dir ? path27.join(opts.dir, `${path27.basename(id)}.summary.json`) : "";
     this.filePath = opts.filePath ?? "";
     this.secretScrubber = opts.secretScrubber;
     this.checkpointCas = opts.checkpointCas;
     this._onAppend = opts.onAppend;
     this._onAppendBatch = opts.onAppendBatch;
     this.onCloseCb = opts.onClose;
+    this.onMetadataCheckpointCb = opts.onMetadataCheckpoint;
+    this.metadataCheckpointMs = opts.metadataCheckpointMs ?? METADATA_CHECKPOINT_INTERVAL_MS;
     this.summaryTracker = new SessionSummaryTracker({
       id,
       startedAt,
@@ -12498,6 +11756,15 @@ var FileSessionWriter = class _FileSessionWriter {
     this._onAppendBatch = cb;
   }
   onCloseCb;
+  /** Mid-session metadata checkpoint throttle. 0 disables checkpointing. */
+  metadataCheckpointMs;
+  /** One-shot guard for the "interval set but no sink" warning below. */
+  _checkpointNoSinkWarned = false;
+  onMetadataCheckpointCb;
+  /** Set whenever summary counters changed since the last metadata checkpoint. */
+  metadataDirty = false;
+  metadataTimer = null;
+  metadataCheckpointInFlight = null;
   /** Implements SessionWriter.traceId — propagated from ContextInit.traceId. */
   traceId;
   /**
@@ -12529,18 +11796,31 @@ var FileSessionWriter = class _FileSessionWriter {
     void this.ensureInit();
     const appendEvent = scrubSessionWriterEvent(event, this.secretScrubber);
     this.summaryTracker.observe(appendEvent);
+    this.metadataDirty = true;
+    this.scheduleMetadataCheckpoint();
     try {
       this._onAppend?.(appendEvent);
     } catch {
     }
+    const critical = isCriticalEvent(appendEvent);
     if (!this.buffer.push(appendEvent)) {
       this.buffer.cancelTimer();
-      void this.buffer.flushBuffer(this.closed).catch(() => void 0).then(() => {
-        this.buffer.push(appendEvent);
+      void this.buffer.flushBuffer(this.closed, { datasync: true }).catch(() => void 0).then(() => {
+        if (this.buffer.push(appendEvent)) {
+          if (!critical) return;
+          this.buffer.cancelTimer();
+          void this.buffer.flushBuffer(this.closed, { datasync: true }).catch(() => void 0);
+          return;
+        }
+        void this.buffer.drainWriteChain().then(() => this.buffer.enqueueWrite(`${JSON.stringify(appendEvent)}
+`)).then(() => {
+          if (!critical) return;
+          return this.handle.datasync().catch(() => void 0);
+        }).catch(() => void 0);
       });
-    } else if (this.buffer.shouldFlushNow()) {
+    } else if (critical || this.buffer.shouldFlushNow()) {
       this.buffer.cancelTimer();
-      void this.buffer.flushBuffer(this.closed).catch(() => {
+      void this.buffer.flushBuffer(this.closed, { datasync: true }).catch(() => {
       });
     } else {
       this.buffer.scheduleFlush(this.closed);
@@ -12611,23 +11891,112 @@ var FileSessionWriter = class _FileSessionWriter {
       provider: this.meta.provider ?? "unknown"
     });
   }
+  /**
+   * Arm the mid-session metadata checkpoint timer if it is not already armed.
+   * Called after every observed event; the timer itself is unref'd so an idle
+   * session never keeps the process alive for a cosmetic sidecar refresh.
+   */
+  scheduleMetadataCheckpoint() {
+    if (this.closed || this.metadataTimer) return;
+    if (this.metadataCheckpointMs <= 0) return;
+    if (!this.onMetadataCheckpointCb && !this.manifestFile) {
+      if (!this._checkpointNoSinkWarned) {
+        this._checkpointNoSinkWarned = true;
+        console.warn(
+          JSON.stringify({
+            level: "warn",
+            event: "session.metadata_checkpoint_no_sink",
+            sessionId: this.id,
+            message: "metadataCheckpointMs set but neither onMetadataCheckpoint nor manifestFile configured; mid-session checkpoints disabled.",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+      }
+      return;
+    }
+    this.metadataTimer = setTimeout(() => {
+      this.metadataTimer = null;
+      void this.runMetadataCheckpoint();
+    }, this.metadataCheckpointMs);
+    this.metadataTimer.unref?.();
+  }
+  /**
+   * Persist a mid-session summary snapshot: the `.summary.json` sidecar under
+   * the manifest lock, then the store-level index row / catalog upsert via
+   * `onMetadataCheckpoint`. Runs at most once per throttle interval and only
+   * when summary counters changed since the last checkpoint; a failed
+   * checkpoint stays dirty and retries on the next armed tick.
+   */
+  runMetadataCheckpoint() {
+    if (this.closed || !this.metadataDirty) return Promise.resolve();
+    if (this.metadataCheckpointInFlight) return this.metadataCheckpointInFlight;
+    const {
+      endedAt: _priorEndedAt,
+      outcome: _priorOutcome,
+      ...snapshot
+    } = this.summaryTracker.snapshot();
+    const run = (async () => {
+      const t0 = Date.now();
+      let outcome = "success";
+      let errorMsg;
+      try {
+        if (this.manifestFile) {
+          await withFileLock(this.manifestFile, async () => {
+            await atomicWrite(this.manifestFile, JSON.stringify(snapshot), { mode: 384 });
+          });
+        }
+        this.metadataDirty = false;
+        await this.onMetadataCheckpointCb?.(snapshot);
+        if (this.metadataDirty && !this.closed) this.scheduleMetadataCheckpoint();
+      } catch (err) {
+        outcome = "failure";
+        errorMsg = toErrorMessage(err);
+        this.metadataDirty = true;
+        this.scheduleMetadataCheckpoint();
+      } finally {
+        this.metadataCheckpointInFlight = null;
+        this.events?.emit("storage.write", {
+          sessionId: this.id,
+          store: "session",
+          filePath: this.manifestFile || this.filePath,
+          operation: "metadata_checkpoint",
+          outcome,
+          durationMs: Date.now() - t0,
+          ...errorMsg !== void 0 ? { error: errorMsg } : {},
+          ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+        });
+      }
+    })();
+    this.metadataCheckpointInFlight = run;
+    return run;
+  }
   async append(event) {
     if (this.closed) return;
     await this.ensureInit();
     const scrubbed = scrubSessionWriterEvent(event, this.secretScrubber);
     this.summaryTracker.observe(scrubbed);
+    this.metadataDirty = true;
+    this.scheduleMetadataCheckpoint();
     try {
       this._onAppend?.(scrubbed);
     } catch {
     }
-    if (!this.buffer.push(scrubbed)) {
+    let pushed = this.buffer.push(scrubbed);
+    if (!pushed) {
       this.buffer.cancelTimer();
-      await this.buffer.flushBuffer(this.closed).catch(() => void 0);
-      this.buffer.push(scrubbed);
+      await this.buffer.flushBuffer(this.closed, { datasync: true }).catch(() => void 0);
+      pushed = this.buffer.push(scrubbed);
+      if (!pushed) {
+        await this.buffer.drainWriteChain().then(() => this.buffer.enqueueWrite(`${JSON.stringify(scrubbed)}
+`)).then(() => {
+          if (!isCriticalEvent(scrubbed)) return;
+          return this.handle.datasync().catch(() => void 0);
+        }).catch(() => void 0);
+      }
     }
-    if (this.buffer.shouldFlushNow()) {
+    if (isCriticalEvent(scrubbed) || this.buffer.shouldFlushNow()) {
       this.buffer.cancelTimer();
-      await this.buffer.flushBuffer(this.closed).catch(() => {
+      await this.buffer.flushBuffer(this.closed, { datasync: true }).catch(() => {
       });
     } else {
       this.buffer.scheduleFlush(this.closed);
@@ -12644,20 +12013,33 @@ var FileSessionWriter = class _FileSessionWriter {
         this._onAppend?.(scrubbed);
       } catch {
       }
-      if (!this.buffer.push(scrubbed)) {
+      let pushed = this.buffer.push(scrubbed);
+      if (!pushed) {
         this.buffer.cancelTimer();
-        await this.buffer.flushBuffer(this.closed).catch(() => void 0);
-        this.buffer.push(scrubbed);
+        await this.buffer.flushBuffer(this.closed, { datasync: true }).catch(() => void 0);
+        pushed = this.buffer.push(scrubbed);
+        if (!pushed) {
+          await this.buffer.drainWriteChain().then(() => this.buffer.enqueueWrite(`${JSON.stringify(scrubbed)}
+`)).then(() => {
+            if (!isCriticalEvent(scrubbed)) return;
+            return this.handle.datasync().catch(() => void 0);
+          }).catch(() => void 0);
+        }
       }
       scrubbedBatch.push(scrubbed);
     }
+    if (scrubbedBatch.length > 0) {
+      this.metadataDirty = true;
+      this.scheduleMetadataCheckpoint();
+    }
     try {
       this._onAppendBatch?.(scrubbedBatch);
     } catch {
     }
-    if (this.buffer.shouldFlushNow()) {
+    const hasCritical = scrubbedBatch.some(isCriticalEvent);
+    if (hasCritical || this.buffer.shouldFlushNow()) {
       this.buffer.cancelTimer();
-      await this.buffer.flushBuffer(this.closed).catch(() => {
+      await this.buffer.flushBuffer(this.closed, { datasync: true }).catch(() => {
       });
     } else {
       this.buffer.scheduleFlush(this.closed);
@@ -12665,8 +12047,10 @@ var FileSessionWriter = class _FileSessionWriter {
   }
   /**
    * Flush buffered events to disk immediately. Critical events
-   * (user_input, llm_response) call this so they survive SIGKILL/crash
-   * instead of sitting in the in-memory buffer for up to 500ms.
+   * (user_input, llm_response, checkpoint, in_flight_*) already flush
+   * themselves inside append()/appendBatch(), so calling this matters for
+   * non-critical tails that would otherwise sit in the in-memory buffer
+   * for up to 500ms.
    *
    * Idempotent — cancels any pending timer, writes whatever has accumulated,
    * then asks the OS to synchronize the file data before resolving. Even an
@@ -12675,7 +12059,7 @@ var FileSessionWriter = class _FileSessionWriter {
   async flush() {
     if (this.closed) return;
     this.buffer.cancelTimer();
-    await this.buffer.flushBuffer(this.closed);
+    await this.buffer.flushBuffer(this.closed, { datasync: true });
     await this.buffer.drainWriteChain();
     try {
       await this.handle.datasync();
@@ -12691,23 +12075,35 @@ var FileSessionWriter = class _FileSessionWriter {
    * Last-gasp synchronous drain for hard-exit paths (process.exit after
    * rapid Ctrl+C). The async write chain cannot be awaited when the process
    * is about to die, but whatever still sits in the in-memory buffer CAN be
-   * saved with a blocking append. Best-effort: an in-flight async write may
-   * be cut off by the exit regardless; errors here are swallowed.
+   * saved with a blocking append. A failed sync append leaves the buffer
+   * intact so a subsequent close()/flush() can retry. An in-flight async
+   * write may still be cut off by a hard exit.
    */
   flushSync() {
     this.buffer.flushSync();
   }
   async close() {
     if (this.closePromise) return this.closePromise;
-    this.closePromise = this.doClose().catch((err) => {
+    this.closePromise = this.doClose().catch(async (err) => {
+      if (this.metadataTimer) {
+        clearTimeout(this.metadataTimer);
+        this.metadataTimer = null;
+      }
+      await this.metadataCheckpointInFlight?.catch(() => void 0);
       this.closed = false;
       this.closePromise = null;
       if (this.buffer.length > 0) this.buffer.scheduleFlush(this.closed);
+      if (this.metadataDirty) this.scheduleMetadataCheckpoint();
       throw err;
     });
     return this.closePromise;
   }
   async doClose() {
+    if (this.metadataTimer) {
+      clearTimeout(this.metadataTimer);
+      this.metadataTimer = null;
+    }
+    await this.metadataCheckpointInFlight?.catch(() => void 0);
     await this.ensureInit();
     if (this.pendingFileSnapshots.length > 0) {
       await this.writeFileSnapshot(this.activePromptIndex ?? 0, [...this.pendingFileSnapshots]);
@@ -12715,8 +12111,13 @@ var FileSessionWriter = class _FileSessionWriter {
       this.pendingFileSnapshotBytes = 0;
     }
     this.closed = true;
+    if (this.metadataTimer) {
+      clearTimeout(this.metadataTimer);
+      this.metadataTimer = null;
+    }
+    await this.metadataCheckpointInFlight?.catch(() => void 0);
     this.buffer.cancelTimer();
-    await this.buffer.flushBuffer(this.closed);
+    await this.buffer.flushBuffer(this.closed, { datasync: true });
     await this.buffer.drainWriteChain();
     try {
       await this.handle.datasync();
@@ -12831,10 +12232,23 @@ var FileSessionWriter = class _FileSessionWriter {
   async truncateToCheckpoint(targetPromptIndex, revertedFiles = []) {
     if (!this.filePath) return 0;
     this.buffer.cancelTimer();
-    await this.buffer.flushBuffer(this.closed);
+    await this.buffer.flushBuffer(this.closed, { datasync: true });
     await this.buffer.drainWriteChain();
-    const plan = await findSessionCheckpointTruncatePlan(this.filePath, targetPromptIndex);
-    if (!plan) return 0;
+    if (this.metadataTimer) {
+      clearTimeout(this.metadataTimer);
+      this.metadataTimer = null;
+    }
+    await this.metadataCheckpointInFlight?.catch(() => void 0);
+    const plan = await findSessionCheckpointTruncatePlan(this.filePath, targetPromptIndex).catch(
+      (err) => {
+        this.scheduleMetadataCheckpoint();
+        throw err;
+      }
+    );
+    if (!plan) {
+      this.scheduleMetadataCheckpoint();
+      return 0;
+    }
     await this.buffer.drainWriteChain();
     try {
       await this.handle.close();
@@ -12845,6 +12259,7 @@ var FileSessionWriter = class _FileSessionWriter {
       this.handle = await fsp14.open(this.filePath, "a", 384);
     } catch (err) {
       this.handle = await fsp14.open(this.filePath, "a", 384).catch(() => this.handle);
+      this.scheduleMetadataCheckpoint();
       throw err;
     }
     await this.summaryTracker.recomputeFromDisk(this.filePath);
@@ -12870,6 +12285,11 @@ var FileSessionWriter = class _FileSessionWriter {
     await this.buffer.drainFlushPromise();
     this.buffer.clear();
     await this.buffer.drainWriteChain();
+    if (this.metadataTimer) {
+      clearTimeout(this.metadataTimer);
+      this.metadataTimer = null;
+    }
+    await this.metadataCheckpointInFlight?.catch(() => void 0);
     const resetAt = (/* @__PURE__ */ new Date()).toISOString();
     const record = `${JSON.stringify({
       type: "session_start",
@@ -12880,8 +12300,10 @@ var FileSessionWriter = class _FileSessionWriter {
     })}
 `;
     await this.handle.close();
-    await fsp14.writeFile(this.filePath, record, "utf8");
+    await atomicWrite(this.filePath, record, { mode: 384 });
     this.summaryTracker.reset(resetAt);
+    this.metadataDirty = true;
+    this.scheduleMetadataCheckpoint();
     this.activePromptIndex = null;
     this.pendingFileSnapshots = [];
     this.pendingFileSnapshotBytes = 0;
@@ -12935,22 +12357,22 @@ var FileSessionWriter = class _FileSessionWriter {
 
 // src/storage/session-store/delete-session-artifacts.ts
 import * as fsp15 from "node:fs/promises";
-import * as path30 from "node:path";
+import * as path29 from "node:path";
 
 // src/storage/session-store/paths.ts
-import * as path29 from "node:path";
+import * as path28 from "node:path";
 function sessionPath(storeDir, id, ext) {
   return sessionScopedPath(storeDir, id, ext);
 }
 function shardManifestPath(storeDir, shardKey) {
-  return shardKey ? path29.join(storeDir, shardKey, "_manifest.json") : path29.join(storeDir, "_manifest.json");
+  return shardKey ? path28.join(storeDir, shardKey, "_manifest.json") : path28.join(storeDir, "_manifest.json");
 }
 function shardKeyForSessionId(id) {
-  const dirName = path29.dirname(id);
+  const dirName = path28.dirname(id);
   return dirName === "." ? "" : dirName;
 }
 async function ensureShardDir(storeDir, id) {
-  const dirPath = path29.dirname(sessionScopedPath(storeDir, id, ""));
+  const dirPath = path28.dirname(sessionScopedPath(storeDir, id, ""));
   await ensureDir(dirPath);
   return dirPath;
 }
@@ -12961,9 +12383,9 @@ async function deleteSessionArtifacts({
   id,
   jsonlPath
 }) {
-  const shardDir = path30.dirname(jsonlPath);
-  const base = path30.basename(id);
-  const sessDir = path30.join(shardDir, base);
+  const shardDir = path29.dirname(jsonlPath);
+  const base = path29.basename(id);
+  const sessDir = path29.join(shardDir, base);
   const deletions = [
     fsp15.unlink(jsonlPath),
     fsp15.unlink(sessionPath(rootDir, id, ".summary.json")),
@@ -13505,7 +12927,7 @@ function emitDamaged(params, detail) {
 
 // src/storage/session-store/prune-helpers.ts
 import * as fsp16 from "node:fs/promises";
-import * as path31 from "node:path";
+import * as path30 from "node:path";
 function isPrunableSessionJsonl(name) {
   return isSessionTranscriptFileName(name);
 }
@@ -13513,7 +12935,7 @@ async function pruneSessionFiles(storeDir, maxAgeDays, deleteSession) {
   const cutoff = Date.now() - maxAgeDays * 864e5;
   let deleted = 0;
   const pruneFile = async (dir, name, prefix) => {
-    const jsonlPath = path31.join(dir, name);
+    const jsonlPath = path30.join(dir, name);
     try {
       const stat19 = await fsp16.stat(jsonlPath);
       if (stat19.mtimeMs >= cutoff) return;
@@ -13532,7 +12954,7 @@ async function pruneSessionFiles(storeDir, maxAgeDays, deleteSession) {
       continue;
     }
     if (!entry.isDirectory()) continue;
-    const dateDir = path31.join(storeDir, entry.name);
+    const dateDir = path30.join(storeDir, entry.name);
     const files = await fsp16.readdir(dateDir, { withFileTypes: true }).catch(() => []);
     for (const file of files) {
       if (!file.isFile() || !isPrunableSessionJsonl(file.name)) continue;
@@ -13541,7 +12963,7 @@ async function pruneSessionFiles(storeDir, maxAgeDays, deleteSession) {
   }
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const dateDir = path31.join(storeDir, entry.name);
+    const dateDir = path30.join(storeDir, entry.name);
     try {
       const remaining = await fsp16.readdir(dateDir);
       if (remaining.length === 0) {
@@ -13617,18 +13039,18 @@ async function executeRenameSession(params) {
 
 // src/storage/session-store/resume-session.ts
 import * as fsp19 from "node:fs/promises";
-import * as path33 from "node:path";
+import * as path32 from "node:path";
 
 // src/storage/session-resume-validation.ts
 import { createHash as createHash9 } from "node:crypto";
 import * as fsp18 from "node:fs/promises";
-import * as path32 from "node:path";
+import * as path31 from "node:path";
 var MAX_REVALIDATE_BYTES = 5 * 1024 * 1024;
 var VALIDATION_CONCURRENCY = 8;
 var NOTICE_PATH_LIMIT = 20;
 function isInside2(root, target) {
-  const relative8 = path32.relative(root, target);
-  return relative8 === "" || !relative8.startsWith("..") && !path32.isAbsolute(relative8);
+  const relative8 = path31.relative(root, target);
+  return relative8 === "" || !relative8.startsWith("..") && !path31.isAbsolute(relative8);
 }
 function errno(err) {
   return err && typeof err === "object" && "code" in err ? String(err.code) : void 0;
@@ -13639,7 +13061,7 @@ function latestObservations(events, projectRoot) {
     if (event.type !== "file_observation" || typeof event.path !== "string" || event.path.length === 0 || typeof event.hash !== "string" || !/^[a-f\d]{64}$/i.test(event.hash)) {
       continue;
     }
-    const normalized = path32.resolve(projectRoot, event.path);
+    const normalized = path31.resolve(projectRoot, event.path);
     latest.set(normalized, {
       path: normalized,
       hash: event.hash.toLowerCase(),
@@ -13697,7 +13119,7 @@ async function validateOne(observation, lexicalRoot, realRoot) {
   }
 }
 async function validateResumeFileObservations(events, projectRoot) {
-  const lexicalRoot = path32.resolve(projectRoot);
+  const lexicalRoot = path31.resolve(projectRoot);
   const realRoot = await fsp18.realpath(lexicalRoot).catch(() => lexicalRoot);
   const observations = latestObservations(events, lexicalRoot);
   const results = await mapWithConcurrency(
@@ -13713,8 +13135,22 @@ async function validateResumeFileObservations(events, projectRoot) {
 }
 var RESUME_NOTICE_HEADERS = [
   "[SESSION RESUME FILE VALIDATION]",
-  "[SESSION RESUME INTERRUPTED WORK]"
+  "[SESSION RESUME INTERRUPTED WORK]",
+  "[SESSION RESUME CRASH RECOVERY]"
 ];
+function formatCrashRecoveryNotice(interruptedTools, lastContext) {
+  if (interruptedTools.length === 0) return null;
+  const plural = interruptedTools.length === 1 ? "call was" : "calls were";
+  const lines = [
+    "[SESSION RESUME CRASH RECOVERY]",
+    `The previous run stopped mid-iteration${lastContext ? ` while: ${lastContext}` : ""} \u2014 ${interruptedTools.length} tool ${plural} left without a recorded result.`,
+    "Those interrupted tool calls were removed from the restored conversation and were NOT re-executed; their workspace side effects were NOT rolled back."
+  ];
+  for (const tool of interruptedTools.slice(0, NOTICE_PATH_LIMIT)) {
+    lines.push(`- ${tool.name}${tool.argsSummary ? ` (${tool.argsSummary})` : ""}`);
+  }
+  return lines.join("\n");
+}
 function isResumeNoticeMessage(message) {
   if (message.role !== "system" || typeof message.content !== "string") return false;
   return RESUME_NOTICE_HEADERS.some((header) => message.content === header || message.content.startsWith(`${header}
@@ -13722,9 +13158,9 @@ function isResumeNoticeMessage(message) {
 }
 function formatResumeValidationNotice(validation, projectRoot) {
   if (validation.staleFiles.length === 0) return null;
-  const root = path32.resolve(projectRoot);
+  const root = path31.resolve(projectRoot);
   const shown = validation.staleFiles.slice(0, NOTICE_PATH_LIMIT).map((entry) => {
-    const relative8 = path32.relative(root, entry.path);
+    const relative8 = path31.relative(root, entry.path);
     const display = isInside2(root, entry.path) ? relative8 || "." : entry.path;
     return `- ${JSON.stringify(display)} [${entry.status}]`;
   });
@@ -13917,7 +13353,8 @@ async function executeResumeSession(params) {
     readSummaryManifest,
     searchEvents,
     persistCatalogSummary,
-    logWarn
+    logWarn,
+    sessionsDir
   } = params;
   const t0 = Date.now();
   const data = await load(canonicalId);
@@ -13938,6 +13375,24 @@ async function executeResumeSession(params) {
     ...derivedSummary,
     ...persistedSummary?.name !== void 0 ? { name: persistedSummary.name } : {}
   };
+  let recoveryPlan = SessionRecovery.buildRecoveryPlan(data.events, canonicalId);
+  if (eventsDropped > 0 && sessionsDir) {
+    const fromDisk = await new SessionRecovery(sessionsDir).recover(canonicalId);
+    if (fromDisk) recoveryPlan = fromDisk;
+  }
+  const interruptedTools = recoveryPlan.stale ? extractInterruptedTools(recoveryPlan) : [];
+  const synthesizedResults = interruptedTools.flatMap(
+    (tool) => typeof tool.id === "string" ? [
+      {
+        type: "tool_result",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        id: tool.id,
+        content: "[interrupted] No result was recorded \u2014 the previous process stopped before this call completed. Re-run it if still needed.",
+        isError: true
+      }
+    ] : []
+  );
+  if (synthesizedResults.length > 0) data.events.push(...synthesizedResults);
   const noticeMessages = [];
   let resumeValidation;
   if (projectRoot) {
@@ -13966,7 +13421,7 @@ async function executeResumeSession(params) {
       );
     }
   }
-  const interruptedNotice = formatInterruptedToolNotice(data.pendingToolUseCount ?? 0);
+  const interruptedNotice = recoveryPlan.stale ? null : formatInterruptedToolNotice(data.pendingToolUseCount ?? 0);
   if (interruptedNotice) {
     noticeMessages.push({
       role: "system",
@@ -13974,6 +13429,14 @@ async function executeResumeSession(params) {
       ts: (/* @__PURE__ */ new Date()).toISOString()
     });
   }
+  const crashNotice = formatCrashRecoveryNotice(interruptedTools, recoveryPlan.context);
+  if (crashNotice) {
+    noticeMessages.push({
+      role: "system",
+      content: crashNotice,
+      ts: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
   const carriedMessages = data.messages.filter((message) => !isResumeNoticeMessage(message));
   const resumedData = {
     ...data,
@@ -14004,7 +13467,7 @@ async function executeResumeSession(params) {
       {
         resumed: true,
         initialSummary,
-        dir: path33.dirname(file),
+        dir: path32.dirname(file),
         filePath: file,
         secretScrubber,
         checkpointCas,
@@ -14015,9 +13478,21 @@ async function executeResumeSession(params) {
           if (!current) return null;
           return current.name === void 0 ? {} : { name: sessionContentText(secretScrubber.scrub(current.name)) };
         },
-        onClose: (s) => persistCatalogSummary(s)
+        onClose: (s) => persistCatalogSummary(s),
+        // Resumed sessions checkpoint their index/catalog metadata mid-flight
+        // too, so a kill during a resumed session still leaves fresh listing
+        // state behind.
+        onMetadataCheckpoint: (s) => persistCatalogSummary(s)
       }
     );
+    if (synthesizedResults.length > 0) {
+      await writer.appendBatch(synthesizedResults);
+      await writer.flush();
+    }
+    if (recoveryPlan.stale) {
+      await writer.clearInFlightMarker("recovered");
+      await writer.flush();
+    }
     emitSessionStoreWrite(events, canonicalId, file, "resume", "success", Date.now() - t0);
     return { writer, data: resumedData };
   } catch (err) {
@@ -14236,6 +13711,11 @@ function applySessionIndexLines(raw, byId, deleted) {
         byId.delete(entry.id);
         continue;
       }
+      if (entry.action === "create" && entry.id) {
+        deleted.delete(entry.id);
+        byId.delete(entry.id);
+        continue;
+      }
       if (entry.id && !deleted.has(entry.id)) {
         byId.set(entry.id, entry);
       }
@@ -14280,6 +13760,7 @@ async function readFileRange(file, start, end) {
 
 // src/storage/session-store/session-store-index.ts
 var COMPACT_EVERY = 30;
+var NO_DELETED_IDS = /* @__PURE__ */ new Set();
 async function appendToIndexStrict(dir, indexFile, summary2, invalidateShard, onAppended, compactInner) {
   await ensureDir(dir);
   let shouldCompact = false;
@@ -14312,10 +13793,14 @@ async function readIndexFile(indexFile, currentCache) {
     const s = await fsp23.stat(indexFile);
     stat19 = { mtimeMs: s.mtimeMs, size: s.size, ino: s.ino, birthtimeMs: s.birthtimeMs };
   } catch {
-    return { summaries: [], cache: null };
+    return { summaries: [], deletedIds: NO_DELETED_IDS, cache: null };
   }
   if (currentCache !== null && currentCache.mtimeMs === stat19.mtimeMs && currentCache.size === stat19.size && currentCache.ino === stat19.ino && currentCache.birthtimeMs === stat19.birthtimeMs) {
-    return { summaries: currentCache.summaries, cache: currentCache };
+    return {
+      summaries: currentCache.summaries,
+      deletedIds: currentCache.deleted,
+      cache: currentCache
+    };
   }
   const cached = currentCache;
   const sameFile = cached !== null && cached.ino === stat19.ino && cached.birthtimeMs === stat19.birthtimeMs;
@@ -14331,14 +13816,14 @@ async function readIndexFile(indexFile, currentCache) {
         byId: cached.byId,
         deleted: cached.deleted
       };
-      return { summaries: summaries2, cache: nextCache2 };
+      return { summaries: summaries2, deletedIds: cached.deleted, cache: nextCache2 };
     }
   }
   let raw;
   try {
     raw = await fsp23.readFile(indexFile, "utf8");
   } catch {
-    return { summaries: [], cache: null };
+    return { summaries: [], deletedIds: NO_DELETED_IDS, cache: null };
   }
   const deleted = /* @__PURE__ */ new Set();
   const byId = /* @__PURE__ */ new Map();
@@ -14346,7 +13831,18 @@ async function readIndexFile(indexFile, currentCache) {
   const summaries = Array.from(byId.values());
   summaries.sort(compareSessionSummaries);
   const nextCache = { ...stat19, summaries, byId, deleted };
-  return { summaries, cache: nextCache };
+  return { summaries, deletedIds: deleted, cache: nextCache };
+}
+async function compactIndexInner(indexFile, entries, deletedIds) {
+  const parts = entries.map((s) => JSON.stringify(s));
+  if (deletedIds) {
+    for (const id of deletedIds) {
+      parts.push(JSON.stringify({ action: "delete", id }));
+    }
+  }
+  if (parts.length === 0) return;
+  const lines = parts.join("\n") + "\n";
+  await atomicWrite(indexFile, lines, { mode: 384 });
 }
 
 // src/storage/session-store/shard-manifest.ts
@@ -14465,6 +13961,7 @@ function damagedSummary(id, startedAt) {
 }
 
 // src/storage/session-store.ts
+var SESSION_FILTER_POOL_LIMIT = 1e4;
 var DefaultSessionStore = class _DefaultSessionStore {
   dir;
   events;
@@ -14480,14 +13977,36 @@ var DefaultSessionStore = class _DefaultSessionStore {
   _loadCache = /* @__PURE__ */ new Map();
   loadCache = new SessionLoadCache(this._loadCache);
   _indexCache = null;
+  /**
+   * Tombstoned ids — hidden even if their JSONL remains on disk.
+   * Convention: readIndex() REASSIGNS this set from the parsed index file
+   * MERGED with _manualTombstones; writeTombstone() adds in-place immediately
+   * so an incremental cache rebuild can never resurrect a just-deleted
+   * session.
+   */
+  _indexDeletedIds = /* @__PURE__ */ new Set();
+  /**
+   * Tombstones added by THIS store between reads. Merged into every fresh
+   * snapshot so a read racing writeTombstone cannot drop an in-flight
+   * deletion; entries are pruned once the parsed index file itself carries
+   * them.
+   */
+  _manualTombstones = /* @__PURE__ */ new Set();
+  /**
+   * File-truth tombstones from the last readIndex() parse (EXCLUDES
+   * _manualTombstones additions). compactIndexInner persists THIS snapshot so
+   * concurrent writeTombstones that landed after the parse are not written
+   * prematurely — they persist through their own append path instead.
+   */
+  _indexFileDeletedIds = /* @__PURE__ */ new Set();
   shardManifestCache = /* @__PURE__ */ new Map();
   static LIST_SCAN_CONCURRENCY = 32;
   indexAppendCount = 0;
   constructor(opts) {
     this.dir = opts.dir;
-    this.projectRoot = opts.projectRoot ? path34.resolve(opts.projectRoot) : void 0;
+    this.projectRoot = opts.projectRoot ? path33.resolve(opts.projectRoot) : void 0;
     this.checkpointCas = this.projectRoot ? new SessionCheckpointCas({
-      rootDir: path34.join(this.dir, "_cas"),
+      rootDir: path33.join(this.dir, "_cas"),
       projectRoot: this.projectRoot
     }) : void 0;
     this.events = opts.events;
@@ -14498,7 +14017,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     this.onAppendBatch = opts.onAppendBatch;
     const builtRuntime = import.meta.url.includes("/dist/");
     this.catalogClient = this.projectRoot && (builtRuntime || process.env["WRONGSTACK_SESSION_CATALOG_FORCE"] === "1") && resolveSessionCatalogProjectServerUrl() ? new SessionCatalogProjectClient({
-      projectDir: path34.dirname(this.dir),
+      projectDir: path33.dirname(this.dir),
       projectRoot: this.projectRoot
     }) : void 0;
   }
@@ -14520,7 +14039,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     this.clearLoadCache();
   }
   get indexFile() {
-    return path34.join(this.dir, "_index.jsonl");
+    return path33.join(this.dir, "_index.jsonl");
   }
   sessionPath(id, ext) {
     return sessionPath(this.dir, id, ext);
@@ -14546,19 +14065,94 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async ensureShardDir(id) {
     return ensureShardDir(this.dir, id);
   }
+  /**
+   * Create a fresh session writer.
+   *
+   * @threadSafety Failure-prone steps (manifest invalidation, sidecar
+   * removal, catalog upsert, the durable `{action:'create'}` index row)
+   * run BEFORE the truncating `'w'` open, so no rejection path can destroy
+   * prior bytes. Ordinary index summary rows never undelete a tombstone
+   * (the parser only honors `{action:'create'}`), so a swallowed create-row
+   * would leave a live writer whose id stays hidden forever — that append
+   * is therefore required, not best-effort.
+   */
   async create(meta) {
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const id = meta.id && meta.id.length > 0 ? meta.id : generateSessionId(startedAt);
     const shardDir = await this.ensureShardDir(id);
     const file = this.sessionPath(id, ".jsonl");
+    const inUseBy = this.isSessionInUse ? await this.isSessionInUse(id) : null;
+    if (inUseBy) {
+      throw new Error(`Refusing to create session ${id}: in use (${inUseBy}).`);
+    }
     const t0 = Date.now();
+    try {
+      await this.invalidateShardManifestBySessionId(id);
+    } catch (cause) {
+      throw new Error(
+        `Failed to invalidate stale shard manifest for ${id}: ${toErrorMessage(cause)}`,
+        { cause }
+      );
+    }
+    const sidecar = path33.join(shardDir, `${path33.basename(id)}.summary.json`);
+    try {
+      await fsp26.rm(sidecar, { force: true });
+    } catch (cause) {
+      emitSessionStoreError(this.events, id, sidecar, "create", toErrorMessage(cause), true);
+      try {
+        await fsp26.access(sidecar);
+        throw new Error(
+          `Failed to remove stale session sidecar for ${id}: ${toErrorMessage(cause)}`,
+          { cause }
+        );
+      } catch (accessErr) {
+        const code = accessErr.code;
+        if (code !== "ENOENT" && code !== "ENAMETOOLONG") throw accessErr;
+      }
+    }
+    if (this.catalogClient) {
+      await this.catalogClient.call("upsert_summary", {
+        summary: {
+          id,
+          title: meta.title ?? "",
+          startedAt,
+          model: meta.model ?? "",
+          provider: meta.provider ?? "",
+          tokenTotal: 0,
+          lastActivityAt: startedAt
+        },
+        transcriptRelativePath: `${id}.jsonl`,
+        summaryRelativePath: `${id}.summary.json`
+      });
+    }
+    try {
+      await withFileLock(this.indexFile, async () => {
+        try {
+          await fsp26.appendFile(this.indexFile, `${JSON.stringify({ action: "create", id })}
+`, {
+            encoding: "utf8",
+            mode: 384
+          });
+        } finally {
+          this._indexCache = null;
+        }
+        this._manualTombstones.delete(id);
+        this._indexDeletedIds.delete(id);
+      });
+    } catch (cause) {
+      throw new Error(
+        `Failed to record session create in the index for ${id}: ${toErrorMessage(cause)}`,
+        { cause }
+      );
+    }
     let handle;
     try {
-      handle = await fsp26.open(file, "a", 384);
+      handle = await fsp26.open(file, "w", 384);
     } catch (err) {
       emitSessionStoreError(this.events, id, file, "create", toErrorMessage(err), false);
       throw new Error(`Failed to open session file: ${toErrorMessage(err)}`, { cause: err });
     }
+    await this.invalidateShardManifestBySessionId(id).catch(() => void 0);
     try {
       const writer = new FileSessionWriter(id, handle, startedAt, meta, this.events, {
         dir: shardDir,
@@ -14572,23 +14166,11 @@ var DefaultSessionStore = class _DefaultSessionStore {
           if (!current) return null;
           return current.name === void 0 ? {} : { name: sessionContentText(this.secretScrubber.scrub(current.name)) };
         },
-        onClose: (s) => this.persistCatalogSummary(s)
+        onClose: (s) => this.persistCatalogSummary(s),
+        // Mid-session metadata checkpoints reuse the same sink as close so
+        // killed sessions leave accurate index rows / catalog entries behind.
+        onMetadataCheckpoint: (s) => this.persistCatalogSummary(s)
       });
-      if (this.catalogClient) {
-        await this.catalogClient.call("upsert_summary", {
-          summary: {
-            id,
-            title: meta.title ?? "",
-            startedAt,
-            model: meta.model ?? "",
-            provider: meta.provider ?? "",
-            tokenTotal: 0,
-            lastActivityAt: startedAt
-          },
-          transcriptRelativePath: `${id}.jsonl`,
-          summaryRelativePath: `${id}.summary.json`
-        });
-      }
       emitSessionStoreWrite(this.events, id, file, "create", "success", Date.now() - t0);
       return writer;
     } catch (err) {
@@ -14650,7 +14232,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
       readSummaryManifest: (summaryId) => this.readSummaryManifest(summaryId),
       searchEvents: (searchId, pred) => this.searchEvents(searchId, pred),
       persistCatalogSummary: (sum) => this.persistCatalogSummary(sum),
-      logWarn: (msg, ctx) => this.logWarn(msg, ctx)
+      logWarn: (msg, ctx) => this.logWarn(msg, ctx),
+      sessionsDir: this.dir
     });
   }
   async load(id) {
@@ -14724,11 +14307,14 @@ var DefaultSessionStore = class _DefaultSessionStore {
       return this.scrubSummaries(records);
     }
     try {
-      const indexed = await this.readIndex();
-      if (indexed.length > 0) {
-        return this.scrubSummaries(indexed.slice(0, limit));
-      }
-      return this.scrubSummaries(await this.listFromDirectoryScan(limit));
+      const [indexed, scanned] = await Promise.all([
+        this.readIndex(),
+        // Wide scan bound: mergeIndexWithScan slices to `limit`, so killed
+        // sessions deep in history stay visible instead of being dropped by
+        // the user-facing page size before the union runs.
+        this.listFromDirectoryScan(SESSION_FILTER_POOL_LIMIT).catch(() => [])
+      ]);
+      return this.scrubSummaries(this.mergeIndexWithScan(indexed, scanned, limit));
     } catch {
       return [];
     }
@@ -14743,15 +14329,14 @@ var DefaultSessionStore = class _DefaultSessionStore {
       return this.scrubSummaries(records);
     }
     try {
-      const indexed = await this.readIndex();
-      if (indexed.length === 0) {
-        const raw = await this.list(Math.max(limit, 100));
-        return raw.filter((s) => matchesSessionFilter(s, criteria)).slice(0, limit);
-      }
-      const filtered = this.scrubSummaries(indexed).filter(
-        (s) => matchesSessionFilter(s, criteria)
-      );
-      return filtered.slice(0, limit);
+      const [indexed, scanned] = await Promise.all([
+        this.readIndex(),
+        // Same best-effort contract as list(): scan failures enrich nothing
+        // but must not blank the filtered result set.
+        this.listFromDirectoryScan(SESSION_FILTER_POOL_LIMIT).catch(() => [])
+      ]);
+      const pool = this.mergeIndexWithScan(indexed, scanned, SESSION_FILTER_POOL_LIMIT);
+      return this.scrubSummaries(pool).filter((s) => matchesSessionFilter(s, criteria)).slice(0, limit);
     } catch {
       return [];
     }
@@ -14793,6 +14378,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
       id,
       (sid) => this.invalidateShardManifestBySessionId(sid),
       () => {
+        this._manualTombstones.add(id);
+        this._indexDeletedIds.add(id);
         this._indexCache = null;
         this.indexAppendCount++;
       }
@@ -14820,34 +14407,92 @@ var DefaultSessionStore = class _DefaultSessionStore {
       );
     }
   }
+  /**
+   * Compact the local index in place.
+   *
+   * Contract carried into the shared compactIndexInner helper
+   * (session-store-index.ts): `entries` MUST already exclude tombstoned ids,
+   * and the deleted-set argument is persisted VERBATIM — neither the helper
+   * nor its callers may resurrect filtered rows or invent deletions.
+   * Locking: callers MUST already hold the indexFile lock (both do:
+   * compactIndex() below and the appendToIndexStrict compaction hook);
+   * readIndex() inside reads that same locked file, so no second lock may
+   * be taken here (non-reentrant → deadlock).
+   *
+   * That same lock is what makes the _indexFileDeletedIds snapshot safe to
+   * pass across the await below: writeTombstone() appends under the identical
+   * non-reentrant indexFile lock, so no tombstone can land between our
+   * readIndex() and the snapshot handed to the helper. Compaction would
+   * otherwise be racing a delete it cannot see.
+   */
   async compactIndexInner() {
     const entries = await this.readIndex();
-    if (entries.length === 0) return;
-    const lines = entries.map((s) => JSON.stringify(s)).join("\n") + "\n";
-    await atomicWrite(this.indexFile, lines, { mode: 384 });
+    await compactIndexInner(this.indexFile, entries, this._indexFileDeletedIds);
     this._indexCache = null;
   }
   async readIndex() {
-    const { summaries, cache } = await readIndexFile(this.indexFile, this._indexCache);
+    const { summaries, deletedIds, cache } = await readIndexFile(this.indexFile, this._indexCache);
     this._indexCache = cache;
+    const merged = new Set(deletedIds);
+    for (const manual of this._manualTombstones) {
+      merged.add(manual);
+      if (deletedIds.has(manual)) this._manualTombstones.delete(manual);
+    }
+    this._indexFileDeletedIds = deletedIds;
+    this._indexDeletedIds = merged;
     return summaries;
   }
+  /**
+   * Merge close-time index rows with directory-scan results, keyed by id.
+   * Scanned entries win — their metadata is re-derived from the transcript,
+   * so it reflects mid-session activity that index rows (written on close)
+   * cannot know about. Indexed-only ids fill gaps; duplicates within the
+   * index resolve last-wins, matching append order.
+   */
+  mergeIndexWithScan(indexed, scanned, limit) {
+    const byId = /* @__PURE__ */ new Map();
+    for (const row of indexed) byId.set(row.id, row);
+    for (const row of scanned) byId.set(row.id, row);
+    return [...byId.values()].filter((row) => !this._indexDeletedIds.has(row.id)).sort(compareSessionSummaries).slice(0, limit);
+  }
+  /**
+   * Rebuild the index from what is actually on disk.
+   *
+   * @returns the number of healthy, live entries in the rebuilt index. Both
+   * backends report that same quantity: ids whose summary could not be derived
+   * are excluded (the catalog counts them as `damaged`; the local scan drops
+   * them when `summaryFor` rejects), and ids carrying a surviving tombstone are
+   * excluded (the catalog rebuilds only from live files; the local branch skips
+   * them explicitly). It is NOT a count of rows written to the file — tombstone
+   * rows are persisted but never counted.
+   */
   async rebuildIndex() {
     if (this.catalogClient) {
       const result = await this.catalogClient.call("rebuild_catalog", {}, { timeoutMs: 12e4 });
       return result.indexed;
     }
-    const ids = await this.collectSessionIds(this.dir);
-    const summaries = await Promise.all(
-      ids.map((id) => this.summaryFor(id).catch(() => null))
-    );
-    const valid = summaries.filter((s) => s !== null);
-    const lines = valid.map((s) => JSON.stringify(s)).join("\n") + "\n";
-    await withFileLock(this.indexFile, async () => {
+    return withFileLock(this.indexFile, async () => {
+      await this.readIndex();
+      const ids = await this.collectSessionIds(this.dir);
+      const summaries = await Promise.all(ids.map((id) => this.summaryFor(id).catch(() => null)));
+      const valid = summaries.filter((s) => s !== null);
+      const parts = [];
+      let tombstoned = 0;
+      for (const s of valid) {
+        if (this._indexDeletedIds.has(s.id)) {
+          tombstoned++;
+          continue;
+        }
+        parts.push(JSON.stringify(s));
+      }
+      for (const id of this._indexDeletedIds) {
+        parts.push(JSON.stringify({ action: "delete", id }));
+      }
+      const lines = parts.join("\n") + "\n";
       await atomicWrite(this.indexFile, lines, { mode: 384 });
       this._indexCache = null;
+      return valid.length - tombstoned;
     });
-    return valid.length;
   }
   async listFromDirectoryScan(limit) {
     const shardKeys = await this.collectShardKeys();
@@ -14929,7 +14574,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     return void 0;
   }
   async collectSessionFilesInShard(shardKey) {
-    const dir = shardKey ? path34.join(this.dir, shardKey) : this.dir;
+    const dir = shardKey ? path33.join(this.dir, shardKey) : this.dir;
     const entries = await this.collectSessionFiles(dir, shardKey);
     return shardKey ? entries.filter((entry) => entry.id.startsWith(`${shardKey}/`)) : entries.filter((entry) => !entry.id.includes("/"));
   }
@@ -15110,7 +14755,7 @@ async function applyRewindToConversation(opts) {
 // src/storage/session-rewinder.ts
 import { createReadStream as createReadStream6 } from "node:fs";
 import * as fsp27 from "node:fs/promises";
-import * as path35 from "node:path";
+import * as path34 from "node:path";
 import { createInterface as createInterface6 } from "node:readline";
 var DefaultSessionRewinder = class {
   constructor(sessionsDir, projectRoot) {
@@ -15244,10 +14889,10 @@ async function revertSnapshots(snapshots, projectRoot) {
   for (const snapshot of [...snapshots].reverse()) {
     for (const file of [...snapshot.files].reverse()) {
       try {
-        const absPath = path35.resolve(file.path);
-        const root = path35.resolve(projectRoot);
-        const rel = path35.relative(root, absPath);
-        if (rel.startsWith("..") || path35.isAbsolute(rel)) {
+        const absPath = path34.resolve(file.path);
+        const root = path34.resolve(projectRoot);
+        const rel = path34.relative(root, absPath);
+        if (rel.startsWith("..") || path34.isAbsolute(rel)) {
           errors.push(`${file.path}: path resolves outside project root \u2014 skipping`);
           continue;
         }
@@ -15614,7 +15259,7 @@ function attachTodosCheckpoint(state, filePath, sessionId, events, traceId, warn
 
 // src/storage/tool-audit-log.ts
 import { createHash as createHash10, randomUUID as randomUUID8 } from "node:crypto";
-import * as fs20 from "node:fs/promises";
+import * as fs19 from "node:fs/promises";
 var GENESIS_PREV = "0".repeat(64);
 var DEFAULT_FSYNC_EVERY = 100;
 var ToolAuditLog = class {
@@ -15684,7 +15329,7 @@ var ToolAuditLog = class {
             isError: input.isError,
             index
           };
-          await fs20.appendFile(fp, JSON.stringify(entry) + "\n", {
+          await fs19.appendFile(fp, JSON.stringify(entry) + "\n", {
             encoding: "utf8",
             // WS-035: this file records raw tool INPUT and OUTPUT. Created
             // without a mode it lands 0644 — world-readable — while its
@@ -15692,7 +15337,7 @@ var ToolAuditLog = class {
             mode: SECRET_FILE_MODE
           });
           try {
-            const st = await fs20.stat(fp);
+            const st = await fs19.stat(fp);
             this.tailStat.set(input.sessionId, { mtimeMs: st.mtimeMs, size: st.size });
           } catch {
           }
@@ -15739,7 +15384,7 @@ var ToolAuditLog = class {
     const cachedStat = this.tailStat.get(sessionId);
     if (cachedHash !== void 0 && cachedIndex !== void 0 && cachedStat) {
       try {
-        const st = await fs20.stat(fp);
+        const st = await fs19.stat(fp);
         if (st.mtimeMs === cachedStat.mtimeMs && st.size === cachedStat.size) {
           return { prevHash: cachedHash, nextIndex: cachedIndex };
         }
@@ -15760,7 +15405,7 @@ var ToolAuditLog = class {
     this.tailHash.set(sessionId, prevHash);
     this.tailIndex.set(sessionId, nextIndex);
     try {
-      const st = await fs20.stat(fp);
+      const st = await fs19.stat(fp);
       this.tailStat.set(sessionId, { mtimeMs: st.mtimeMs, size: st.size });
     } catch {
     }
@@ -15881,7 +15526,7 @@ var ToolAuditLog = class {
   async readAll(sessionId) {
     const fp = this.filePath(sessionId);
     try {
-      const raw = await fs20.readFile(fp, "utf8");
+      const raw = await fs19.readFile(fp, "utf8");
       const out = [];
       for (const line of raw.split("\n")) {
         if (!line.trim()) continue;
@@ -15919,7 +15564,7 @@ var ToolAuditLog = class {
   }
   async sync(sessionId, fp) {
     try {
-      const fh = await fs20.open(fp, "r+");
+      const fh = await fs19.open(fp, "r+");
       try {
         await fh.sync();
       } finally {
@@ -15958,7 +15603,6 @@ function sortKeys2(value) {
 }
 export {
   ALL_SYNC_CATEGORIES,
-  AgentStatusTracker,
   AnnotationsStore,
   CLOUD_SYNC_CONTRACT,
   CLOUD_SYNC_NAMESPACES,
@@ -15977,7 +15621,6 @@ export {
   DefaultSessionStore,
   DirectorStateCheckpoint,
   FileMemoryBackend,
-  FleetNotifier,
   GraphMemoryBackend,
   INPUT_HISTORY_DEFAULT_MAX,
   InputHistoryStore,
@@ -16008,6 +15651,7 @@ export {
   applyRewindToConversation,
   attachPlanCheckpoint,
   attachTodosCheckpoint,
+  boardStore,
   buildNamespacePayloads,
   cleanOrphanLocks,
   clearPlan,
@@ -16069,6 +15713,7 @@ export {
   scrubPersistedSessionEvent,
   scrubPersistedSessionSummary,
   sessionIdResolutionError,
+  setBoardStorePort,
   setPlanItemStatus,
   setProgress,
   stripGoalDeliverableMarker,