@wrongstack/core 0.309.1 → 0.310.0

package/dist/coordination/index.js

@@ -224,7 +224,7 @@ var InMemoryAgentBridge = class {
       });
     }
     this.inflightGuards.add(correlationId);
-    return new Promise((resolve16, reject) => {
+    return new Promise((resolve17, reject) => {
       const timer = setTimeout(() => {
         this.inflightGuards.delete(correlationId);
         this.pendingRequests.delete(correlationId);
@@ -243,7 +243,7 @@ var InMemoryAgentBridge = class {
         return;
       }
       this.pendingRequests.set(correlationId, {
-        resolve: resolve16,
+        resolve: resolve17,
         reject,
         timer
       });
@@ -714,13 +714,13 @@ var SubagentBudget = class _SubagentBudget {
     if (!bus?.hasListenerFor("budget.threshold_reached")) {
       return Promise.resolve("stop");
     }
-    return new Promise((resolve16) => {
+    return new Promise((resolve17) => {
       let resolved = false;
       const respond = (d) => {
         if (resolved) return;
         resolved = true;
         clearTimeout(fallback);
-        resolve16(d);
+        resolve17(d);
       };
       const fallback = setTimeout(() => respond("stop"), _SubagentBudget.DECISION_TIMEOUT_MS);
       const sessionId = this.currentSessionId();
@@ -7649,13 +7649,13 @@ var BrainDecisionQueue = class {
       options: request.options,
       rationale: "Decision escalated to human authority."
     };
-    const pending = new Promise((resolve16) => {
-      const entry = { request, resolve: resolve16 };
+    const pending = new Promise((resolve17) => {
+      const entry = { request, resolve: resolve17 };
       if (this.opts.timeoutMs && this.opts.timeoutMs > 0) {
         entry.timer = setTimeout(() => {
           this.pending.delete(request.id);
           markDecisionTier(request, "terminal");
-          resolve16(
+          resolve17(
             this.opts.onTimeout?.(request) ?? {
               type: "deny",
               reason: "Brain human decision timed out."
@@ -8439,26 +8439,26 @@ var BrainMonitor = class {
   trackFileChurn(toolName, ok, input) {
     if (!this.signals.fileChurn) return;
     if (!ok || !this.fileEditTools.has(toolName.toLowerCase())) return;
-    const path42 = editedPath(input);
-    if (!path42) return;
+    const path44 = editedPath(input);
+    if (!path44) return;
     const now = Date.now();
-    const stamps = (this.editTimestamps.get(path42) ?? []).filter(
+    const stamps = (this.editTimestamps.get(path44) ?? []).filter(
       (t) => now - t <= this.fileChurnWindowMs
     );
     stamps.push(now);
     if (stamps.length >= this.fileChurnThreshold) {
-      this.editTimestamps.delete(path42);
+      this.editTimestamps.delete(path44);
       void this.engage("file_churn", {
-        question: `The file "${path42}" has been edited ${stamps.length} times within ${Math.round(this.fileChurnWindowMs / 6e4)} minutes \u2014 the agent may be oscillating (edit/revert loop) instead of converging. Should it be steered?`,
+        question: `The file "${path44}" has been edited ${stamps.length} times within ${Math.round(this.fileChurnWindowMs / 6e4)} minutes \u2014 the agent may be oscillating (edit/revert loop) instead of converging. Should it be steered?`,
         context: [
-          `File: ${path42}`,
+          `File: ${path44}`,
           `Edits in window: ${stamps.length}`,
           `Window: ${Math.round(this.fileChurnWindowMs / 1e3)}s`
         ].join("\n")
       });
       return;
     }
-    if (this.editTimestamps.size >= 500 && !this.editTimestamps.has(path42)) {
+    if (this.editTimestamps.size >= 500 && !this.editTimestamps.has(path44)) {
       for (const [p, times] of this.editTimestamps) {
         if (times.every((t) => now - t > this.fileChurnWindowMs)) {
           this.editTimestamps.delete(p);
@@ -8469,7 +8469,7 @@ var BrainMonitor = class {
         if (oldest !== void 0) this.editTimestamps.delete(oldest);
       }
     }
-    this.editTimestamps.set(path42, stamps);
+    this.editTimestamps.set(path44, stamps);
   }
   async engage(kind, input) {
     const last = this.lastEngagedAt.get(kind) ?? 0;
@@ -9289,49 +9289,57 @@ async function expandGlob(pattern) {
   async function walk(dir, pat) {
     let entries;
     try {
-      entries = await fsp.readdir(dir);
+      entries = await fsp.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
-    const firstGlob = pat.search(/[*?[[]/);
-    if (firstGlob < 0) {
-      const re = globToRegex(pat);
+    if (pat.startsWith("**/")) {
+      const rest = pat.slice(3);
+      await walk(dir, rest);
       for (const e of entries) {
-        if (re.test(e)) {
-          const full = `${dir}${SEP}${e}`;
-          results.add(abs ? resolve4(full) : full);
+        if (e.isDirectory()) {
+          const subDir = `${dir}${SEP}${e.name}`;
+          await walk(subDir, pat);
         }
       }
       return;
     }
-    const before = pat.slice(0, firstGlob);
-    const rest = pat.slice(firstGlob);
-    if (before.endsWith("**")) {
-      await walk(dir, rest);
+    if (pat === "**") {
       for (const e of entries) {
-        const full = `${dir}${SEP}${e}`;
-        try {
-          const stat13 = await fsp.stat(full);
-          if (stat13.isDirectory()) await walk(full, rest);
-        } catch {
+        const full = `${dir}${SEP}${e.name}`;
+        results.add(abs ? resolve4(full) : full);
+        if (e.isDirectory()) {
+          await walk(full, "**");
         }
       }
-    } else if (before === "") {
-      const re = globToRegex(rest);
+      return;
+    }
+    const firstSlash = pat.indexOf("/");
+    if (firstSlash < 0) {
+      const re = globToRegex(pat);
       for (const e of entries) {
-        if (re.test(e)) {
-          const full = `${dir}${SEP}${e}`;
+        if (re.test(e.name)) {
+          const full = `${dir}${SEP}${e.name}`;
           results.add(abs ? resolve4(full) : full);
         }
       }
+      return;
+    }
+    const currentSeg = pat.slice(0, firstSlash);
+    const remainingPat = pat.slice(firstSlash + 1);
+    if (isGlob(currentSeg)) {
+      const re = globToRegex(currentSeg);
+      for (const e of entries) {
+        if (e.isDirectory() && re.test(e.name)) {
+          const subDir = `${dir}${SEP}${e.name}`;
+          await walk(subDir, remainingPat);
+        }
+      }
     } else {
-      const seg = before.replace(/[*?[\]]/g, "").replace(/\/$/, "");
-      if (entries.includes(seg)) {
-        const full = `${dir}${SEP}${seg}`;
-        try {
-          const stat13 = await fsp.stat(full);
-          if (stat13.isDirectory()) await walk(full, rest);
-        } catch {
+      for (const e of entries) {
+        if (e.isDirectory() && e.name === currentSeg) {
+          const subDir = `${dir}${SEP}${e.name}`;
+          await walk(subDir, remainingPat);
         }
       }
     }
@@ -10466,7 +10474,7 @@ async function gitOtherWorktrees(cwd, signal) {
   return branches.slice(1);
 }
 function runGit(args, cwd, signal) {
-  return new Promise((resolve16, reject) => {
+  return new Promise((resolve17, reject) => {
     let stdout = "";
     let stderr = "";
     const child = spawn("git", args, {
@@ -10485,7 +10493,7 @@ function runGit(args, cwd, signal) {
     });
     child.on("error", (err) => reject(err));
     child.on("close", (code) => {
-      if (code === 0) resolve16(stdout);
+      if (code === 0) resolve17(stdout);
       else reject(new Error(stderr || `git ${args[0]} exited ${code}`));
     });
   });
@@ -11163,7 +11171,7 @@ function createDelegateTool(opts) {
   };
 }
 async function awaitDelegateAttempt(director, subagentId, taskId, timeoutMs, abortSignal) {
-  return new Promise((resolve16) => {
+  return new Promise((resolve17) => {
     let settled = false;
     let timer;
     let offAbort = () => {
@@ -11176,7 +11184,7 @@ async function awaitDelegateAttempt(director, subagentId, taskId, timeoutMs, abo
       offIter();
       offProgress();
       offAbort();
-      resolve16(value);
+      resolve17(value);
     };
     const arm = () => {
       if (timer) clearTimeout(timer);
@@ -11797,31 +11805,31 @@ var ExploreCompanion = class {
   // ── signal handlers ──────────────────────────────────────────────────────
   trackToolExecuted(e) {
     const tool = e.name.toLowerCase();
-    const path42 = extractedPath(e.input);
-    if (e.ok && this.cfg.signals.editUnreadFile && this.cfg.fileEditTools.has(tool) && path42) {
-      if (!this.readSet.has(path42)) {
+    const path44 = extractedPath(e.input);
+    if (e.ok && this.cfg.signals.editUnreadFile && this.cfg.fileEditTools.has(tool) && path44) {
+      if (!this.readSet.has(path44)) {
         this.engage({
           id: randomUUID6(),
-          probe: `Map file ${path42}: role, exports, dependencies, and callers \u2014 the leader is about to edit it.`,
-          hint: { file: path42 },
-          context: `Leader edited ${path42} without reading it first.`,
+          probe: `Map file ${path44}: role, exports, dependencies, and callers \u2014 the leader is about to edit it.`,
+          hint: { file: path44 },
+          context: `Leader edited ${path44} without reading it first.`,
           source: "edit_unread_file",
-          subject: `file:${path42}`,
+          subject: `file:${path44}`,
           createdAt: this.now()
         });
       }
       return;
     }
-    if (e.ok && this.cfg.signals.unfamiliarRead && tool === "read" && path42) {
-      if (!this.readSet.has(path42)) {
-        this.readSet.add(path42);
+    if (e.ok && this.cfg.signals.unfamiliarRead && tool === "read" && path44) {
+      if (!this.readSet.has(path44)) {
+        this.readSet.add(path44);
         this.engage({
           id: randomUUID6(),
-          probe: `Skeleton + callers + dependents of ${path42}: what it exports, who imports it, and how it fits the feature flow.`,
-          hint: { file: path42 },
-          context: `Leader read unfamiliar file ${path42}.`,
+          probe: `Skeleton + callers + dependents of ${path44}: what it exports, who imports it, and how it fits the feature flow.`,
+          hint: { file: path44 },
+          context: `Leader read unfamiliar file ${path44}.`,
           source: "unfamiliar_read",
-          subject: `file:${path42}`,
+          subject: `file:${path44}`,
           createdAt: this.now()
         });
       }
@@ -12010,13 +12018,13 @@ function makeDependencyWatcherConfig(opts) {
   const globPatterns = patterns.filter((p) => p.includes("*"));
   const plainPatterns = patterns.filter((p) => !p.includes("*"));
   function matchesPattern(filePath) {
-    const basename6 = filePath.split("/").pop()?.split("\\").pop() ?? "";
-    if (plainPatterns.includes(basename6)) return true;
+    const basename7 = filePath.split("/").pop()?.split("\\").pop() ?? "";
+    if (plainPatterns.includes(basename7)) return true;
     for (const gp of globPatterns) {
       const regex = new RegExp(
         "^" + gp.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$"
       );
-      if (regex.test(basename6)) return true;
+      if (regex.test(basename7)) return true;
     }
     return false;
   }
@@ -12988,10 +12996,10 @@ var DirectorTaskRegistry = class _DirectorTaskRegistry {
         pending: taskIds.filter((id) => !done.has(id))
       });
     }
-    return new Promise((resolve16) => {
+    return new Promise((resolve17) => {
       const entry = {
         ids: new Set(taskIds),
-        resolve: (result) => resolve16({
+        resolve: (result) => resolve17({
           completed: [result],
           pending: taskIds.filter((id) => id !== result.taskId)
         })
@@ -12999,7 +13007,7 @@ var DirectorTaskRegistry = class _DirectorTaskRegistry {
       if (opts?.timeoutMs !== void 0) {
         entry.timer = setTimeout(() => {
           this.anyWaiters.delete(entry);
-          resolve16({ completed: [], pending: [...taskIds], timedOut: true });
+          resolve17({ completed: [], pending: [...taskIds], timedOut: true });
         }, opts.timeoutMs);
       }
       this.anyWaiters.add(entry);
@@ -13117,11 +13125,11 @@ ${JSON.stringify(result.result, null, 2)}
         this.makeStoppedResult(taskId, "director", `Unknown task id "${taskId}" \u2014 never assigned`)
       );
     }
-    let resolve16;
+    let resolve17;
     const promise = new Promise((done) => {
-      resolve16 = done;
+      resolve17 = done;
     });
-    this.taskWaiters.set(taskId, { promise, resolve: resolve16 });
+    this.taskWaiters.set(taskId, { promise, resolve: resolve17 });
     return promise;
   }
   recordAssignment(task) {
@@ -13182,16 +13190,21 @@ ${JSON.stringify(result.result, null, 2)}
 
 // src/coordination/director-tools.ts
 import { randomUUID as randomUUID12 } from "node:crypto";
-import {
-  completeKanbanDispatch,
-  failKanbanDispatch,
-  getBoard,
-  heartbeatTaskAssignment,
-  listReadyTasks,
-  reserveKanbanDispatch,
-  startKanbanDispatch,
-  updateTaskAssignment
-} from "@wrongstack/kanban";
+
+// src/coordination/kanban-dispatch-port.ts
+var notWired = () => {
+  throw new Error(
+    "Kanban dispatch port is not wired \u2014 register the implementation at the CLI composition root (see setKanbanDispatch)."
+  );
+};
+var port = void 0;
+function setKanbanDispatch(impl) {
+  port = impl;
+}
+function kanbanDispatch() {
+  if (!port) notWired();
+  return port;
+}
 
 // src/coordination/director-input-helpers.ts
 import { randomUUID as randomUUID8 } from "node:crypto";
@@ -13212,8 +13225,21 @@ function instantiateRosterConfig2(role, base) {
   };
 }
 
+// src/coordination/kanban-ops-port.ts
+var notWired2 = () => {
+  throw new Error(
+    "KanbanBoundaryOpsPort is not wired \u2014 register the implementation at the CLI composition root (see setKanbanBoundaryOps)."
+  );
+};
+var port2 = void 0;
+function setKanbanBoundaryOps(impl) {
+  port2 = impl;
+}
+function kanbanBoundaryOps() {
+  return port2 ?? notWired2();
+}
+
 // src/coordination/director-kanban-queue-helpers.ts
-import { describeKanbanBoundary } from "@wrongstack/kanban";
 function normalizeKanbanQueueInput(input) {
   const raw = input ?? {};
   return {
@@ -13297,8 +13323,8 @@ function buildKanbanFleetTaskPrompt(board, task, lease) {
     task.origin.taskId ? `sourceTaskId: ${task.origin.taskId}` : ""
   ].filter(Boolean).join("\n") : "";
   const boundaries = [
-    board.boundary?.enabled ? `board: ${describeKanbanBoundary(board.boundary)}` : "",
-    task.boundary?.enabled ? `task: ${describeKanbanBoundary(task.boundary)}` : "",
+    board.boundary?.enabled ? `board: ${kanbanBoundaryOps().describeKanbanBoundary(board.boundary)}` : "",
+    task.boundary?.enabled ? `task: ${kanbanBoundaryOps().describeKanbanBoundary(task.boundary)}` : "",
     ...(board.boundary?.allow ?? []).map(
       (selector) => `board allow ${selector.access} ${selector.kind}:${selector.path}`
     ),
@@ -15231,7 +15257,7 @@ function makeKanbanQueueTool(director, roster) {
         i.heartbeatIntervalMs ?? Math.floor(leaseTtlMs / 2)
       );
       const effectiveLeaseTtlMs = Math.max(leaseTtlMs, heartbeatIntervalMs * 2);
-      const candidateTaskIds = i.taskId !== void 0 ? [i.taskId] : i.query ? (await listReadyTasks(projectRoot, {
+      const candidateTaskIds = i.taskId !== void 0 ? [i.taskId] : i.query ? (await kanbanDispatch().listReadyTasks(projectRoot, {
         ...i.boardId !== void 0 ? { boardId: i.boardId } : {}
       })).filter((candidate) => matchesKanbanQueueQuery(candidate.task, i.query ?? "")).slice(0, maxTasks).map((candidate) => candidate.task.id) : void 0;
       const dispatches = [];
@@ -15242,7 +15268,7 @@ function makeKanbanQueueTool(director, roster) {
         const candidateTaskId = candidateTaskIds?.[index];
         if (candidateTaskIds && !candidateTaskId) break;
         if (candidateTaskId && budgetRejectedTaskIds.has(candidateTaskId)) continue;
-        const reserved = await reserveKanbanDispatch(projectRoot, {
+        const reserved = await kanbanDispatch().reserveKanbanDispatch(projectRoot, {
           ...i.boardId !== void 0 ? { boardId: i.boardId } : {},
           ...candidateTaskId !== void 0 ? { taskId: candidateTaskId } : {},
           routing: {
@@ -15272,7 +15298,7 @@ function makeKanbanQueueTool(director, roster) {
           if (remaining !== void 0 && remaining < costCeiling) {
             budgetRejectedTaskIds.add(claim.task.id);
             const budgetError = `Cost ceiling ${costCeiling} exceeds remaining budget ${remaining.toFixed(4)}`;
-            await updateTaskAssignment(
+            await kanbanDispatch().updateTaskAssignment(
               projectRoot,
               claim.board.id,
               claim.task.id,
@@ -15323,7 +15349,7 @@ function makeKanbanQueueTool(director, roster) {
               }
             }
           };
-          const started = await startKanbanDispatch(projectRoot, {
+          const started = await kanbanDispatch().startKanbanDispatch(projectRoot, {
             boardId: claim.board.id,
             taskId: claim.task.id,
             leaseId: ourLeaseId,
@@ -15368,7 +15394,7 @@ function makeKanbanQueueTool(director, roster) {
               message = `${message}; cleanup failed for spawned subagent ${subagentId}: ${toErrorMessage(cleanupErr)}`;
             }
           }
-          await failKanbanDispatch(projectRoot, {
+          await kanbanDispatch().failKanbanDispatch(projectRoot, {
             boardId: claim.board.id,
             taskId: claim.task.id,
             leaseId: ourLeaseId,
@@ -15431,7 +15457,7 @@ function makeKanbanQueueTool(director, roster) {
           for (const dispatch of dispatches) {
             if (!runTaskIds.has(dispatch.runTaskId)) continue;
             try {
-              const board = await getBoard(projectRoot, dispatch.boardId);
+              const board = await kanbanDispatch().getBoard(projectRoot, dispatch.boardId);
               const liveTask = board?.tasks.find((t) => t.id === dispatch.taskId);
               const liveLeaseId = liveTask?.assignment?.leaseId;
               if (liveLeaseId !== void 0 && liveLeaseId !== dispatch.leaseId) {
@@ -15443,10 +15469,15 @@ function makeKanbanQueueTool(director, roster) {
             } catch {
             }
             try {
-              await heartbeatTaskAssignment(projectRoot, dispatch.boardId, dispatch.taskId, {
-                leaseExpiresAt: refreshedExpiry,
-                expectedLeaseId: dispatch.leaseId
-              });
+              await kanbanDispatch().heartbeatTaskAssignment(
+                projectRoot,
+                dispatch.boardId,
+                dispatch.taskId,
+                {
+                  leaseExpiresAt: refreshedExpiry,
+                  expectedLeaseId: dispatch.leaseId
+                }
+              );
             } catch {
             }
           }
@@ -15469,7 +15500,7 @@ function makeKanbanQueueTool(director, roster) {
           if (!dispatch) continue;
           runTaskIds.delete(dispatch.runTaskId);
           if (result.status === "success") {
-            const completed = await completeKanbanDispatch(projectRoot, {
+            const completed = await kanbanDispatch().completeKanbanDispatch(projectRoot, {
               boardId: dispatch.boardId,
               taskId: dispatch.taskId,
               leaseId: dispatch.leaseId,
@@ -15485,7 +15516,7 @@ function makeKanbanQueueTool(director, roster) {
               });
             }
           } else {
-            const failed = await failKanbanDispatch(projectRoot, {
+            const failed = await kanbanDispatch().failKanbanDispatch(projectRoot, {
               boardId: dispatch.boardId,
               taskId: dispatch.taskId,
               leaseId: dispatch.leaseId,
@@ -15537,7 +15568,7 @@ async function renewAndRevokeLease(opts) {
   } = opts;
   let revoked = false;
   try {
-    const board = await getBoard(projectRoot, boardId);
+    const board = await kanbanDispatch().getBoard(projectRoot, boardId);
     const liveTask = board?.tasks.find((t) => t.id === taskId);
     const liveLeaseId = liveTask?.assignment?.leaseId;
     if (liveLeaseId !== void 0 && liveLeaseId !== ourLeaseId) {
@@ -15550,7 +15581,7 @@ async function renewAndRevokeLease(opts) {
   } catch {
   }
   if (!revoked) {
-    await heartbeatTaskAssignment(projectRoot, boardId, taskId, {
+    await kanbanDispatch().heartbeatTaskAssignment(projectRoot, boardId, taskId, {
       leaseExpiresAt: refreshedExpiry,
       expectedLeaseId: ourLeaseId
     }).catch(() => {
@@ -15653,12 +15684,12 @@ function rosterSummaryFromConfigs(roster) {
 
 // src/coordination/director-session.ts
 import * as fsp24 from "node:fs/promises";
-import * as path32 from "node:path";
+import * as path33 from "node:path";
 
 // src/storage/session-store.ts
 import { randomUUID as randomUUID14 } from "node:crypto";
 import * as fsp23 from "node:fs/promises";
-import * as path31 from "node:path";
+import * as path32 from "node:path";
 
 // src/session-catalog/client.ts
 import { spawn as spawn2 } from "node:child_process";
@@ -15736,7 +15767,7 @@ function normalize2(value) {
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function delay(ms) {
-  return new Promise((resolve16) => setTimeout(resolve16, ms));
+  return new Promise((resolve17) => setTimeout(resolve17, ms));
 }
 var SessionCatalogProjectClient = class {
   constructor(options) {
@@ -15826,8 +15857,8 @@ var SessionCatalogProjectClient = class {
     this.socket = null;
     this.info = null;
     if (socket && !socket.destroyed)
-      await new Promise((resolve16) => {
-        socket.once("close", resolve16);
+      await new Promise((resolve17) => {
+        socket.once("close", resolve17);
         socket.end();
       });
   }
@@ -15865,7 +15896,7 @@ var SessionCatalogProjectClient = class {
     this.info = null;
     this.authToken = void 0;
     this.buffer = "";
-    return new Promise((resolve16, reject) => {
+    return new Promise((resolve17, reject) => {
       const socket = net.createConnection(this.endpoint);
       this.socket = socket;
       socket.setEncoding("utf8");
@@ -15878,7 +15909,7 @@ var SessionCatalogProjectClient = class {
         clearTimeout(timer);
         this.connectResolve = null;
         this.connectReject = null;
-        resolve16();
+        resolve17();
       };
       this.connectReject = (error) => {
         clearTimeout(timer);
@@ -15923,7 +15954,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((resolve16, reject) => {
+    return new Promise((resolve17, reject) => {
       const timer = setTimeout(() => {
         const pending = this.pending.get(id);
         if (!pending) return;
@@ -15935,7 +15966,7 @@ var SessionCatalogProjectClient = class {
         );
       }, timeoutMs);
       timer.unref?.();
-      this.pending.set(id, { resolve: resolve16, reject, timer });
+      this.pending.set(id, { resolve: resolve17, reject, timer });
       socket.write(encoded);
     });
   }
@@ -16349,6 +16380,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);
   }
@@ -16541,6 +16595,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;
   }
@@ -16581,14 +16641,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 fsp7.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;
       }
@@ -16613,17 +16679,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;
@@ -16631,12 +16709,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;
@@ -16674,6 +16761,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() {
@@ -16682,18 +16770,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 {
@@ -16861,6 +16987,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;
@@ -16876,6 +17013,8 @@ var FileSessionWriter = class _FileSessionWriter {
     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,
@@ -16943,6 +17082,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;
   /**
@@ -16974,18 +17122,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);
@@ -17056,23 +17217,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);
@@ -17089,20 +17339,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);
@@ -17110,8 +17373,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
@@ -17120,7 +17385,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();
@@ -17136,23 +17401,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]);
@@ -17160,8 +17437,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();
@@ -17276,10 +17558,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();
@@ -17290,6 +17585,7 @@ var FileSessionWriter = class _FileSessionWriter {
       this.handle = await fsp9.open(this.filePath, "a", 384);
     } catch (err) {
       this.handle = await fsp9.open(this.filePath, "a", 384).catch(() => this.handle);
+      this.scheduleMetadataCheckpoint();
       throw err;
     }
     await this.summaryTracker.recomputeFromDisk(this.filePath);
@@ -17315,6 +17611,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",
@@ -17325,8 +17626,10 @@ var FileSessionWriter = class _FileSessionWriter {
     })}
 `;
     await this.handle.close();
-    await fsp9.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;
@@ -17717,7 +18020,7 @@ var SessionCheckpointCas = class {
   }
 };
 function defaultRunGit(args, cwd) {
-  return new Promise((resolve16) => {
+  return new Promise((resolve17) => {
     const stdoutChunks = [];
     const stderrChunks = [];
     let stdoutBytes = 0;
@@ -17760,8 +18063,8 @@ function defaultRunGit(args, cwd) {
       stdoutTruncated,
       stderrTruncated
     });
-    child.on("error", (err) => resolve16(result(1, err.message)));
-    child.on("close", (code) => resolve16(result(code ?? 1)));
+    child.on("error", (err) => resolve17(result(1, err.message)));
+    child.on("close", (code) => resolve17(result(code ?? 1)));
   });
 }
 
@@ -18575,7 +18878,7 @@ async function executeRenameSession(params) {
 
 // src/storage/session-store/resume-session.ts
 import * as fsp16 from "node:fs/promises";
-import * as path30 from "node:path";
+import * as path31 from "node:path";
 
 // src/storage/session-resume-validation.ts
 import { createHash as createHash5 } from "node:crypto";
@@ -18671,8 +18974,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}
@@ -18705,9 +19022,345 @@ function formatInterruptedToolNotice(pendingToolUseCount) {
   ].join("\n");
 }
 
-// src/storage/session-store/summary-builder.ts
+// src/storage/session-recovery.ts
 import { createReadStream as createReadStream4 } from "node:fs";
+import * as fs4 from "node:fs/promises";
+import * as path30 from "node:path";
 import { createInterface as createInterface4 } from "node:readline";
+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 rawId = ev.id;
+      const callId = rawId ?? toolName;
+      openCalls.set(callId, {
+        id: rawId,
+        name: toolName,
+        args: ev.input ?? ev.args,
+        ts: ev.ts
+      });
+    } else if (ev.type === "tool_result" || ev.type === "tool_call_end") {
+      const callId = ev.id ?? ev.toolUseId ?? ev.name;
+      if (callId) openCalls.delete(callId);
+    } 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 rawId = block.id;
+          const callId = rawId ?? `${block.name}#${++anonymousSeq}`;
+          openCalls.set(callId, {
+            id: rawId,
+            name: block.name,
+            args: block.input,
+            ts: ev.ts
+          });
+        }
+      }
+    } else if (ev.type === "message_appended" && ev.message) {
+      const msg = ev.message;
+      if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block && block.type === "tool_use" && typeof block.name === "string") {
+            const rawId = block.id;
+            const callId = rawId ?? `${block.name}#${++anonymousSeq}`;
+            openCalls.set(callId, {
+              id: rawId,
+              name: block.name,
+              args: block.input,
+              ts: ev.ts
+            });
+          } else if (block && block.type === "tool_result") {
+            const callId = block.tool_use_id ?? block.id;
+            if (callId) openCalls.delete(callId);
+          }
+        }
+      }
+    }
+  }
+  for (const call of openCalls.values()) {
+    let argsSummary;
+    if (call.args && typeof call.args === "object") {
+      try {
+        const str = JSON.stringify(call.args);
+        argsSummary = str.length > 80 ? `${str.slice(0, 77)}...` : str;
+      } catch {
+      }
+    }
+    tools.push({
+      id: call.id,
+      name: call.name,
+      argsSummary,
+      ts: call.ts
+    });
+  }
+  return tools;
+}
+var SessionRecovery = class _SessionRecovery {
+  constructor(dir) {
+    this.dir = dir;
+  }
+  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
+   * `in_flight_end`/`session_end`. Ordinary provider/tool events after the
+   * marker do not make the session clean. Returns `null` when:
+   *   - the log does not exist;
+   *   - the log is empty;
+   *   - the latest lifecycle boundary is `in_flight_end` or `session_end`;
+   *   - there is no lifecycle boundary (legacy/pre-marker log).
+   *
+   * The reverse scanner is chunked and line-aware. It can cross arbitrarily
+   * large JSONL records (for example a large tool result) without imposing a
+   * fixed tail-size correctness limit. Clean logs normally return after the
+   * first chunk; stale logs continue counting lines so `eventCount` remains
+   * the documented total rather than a tail-only approximation.
+   */
+  async resolveId(query) {
+    const resolution = resolveSessionId(query, await collectSessionIds(this.dir));
+    if (resolution.status === "resolved") return resolution.id;
+    if (resolution.status === "missing") return resolution.query;
+    throw sessionIdResolutionError(resolution);
+  }
+  async detectStale(sessionId) {
+    const canonicalId = await this.resolveId(sessionId);
+    return this.detectStaleExact(canonicalId);
+  }
+  async detectStaleExact(sessionId) {
+    const fp = this.filePath(sessionId);
+    let stat13;
+    try {
+      stat13 = await fs4.stat(fp);
+    } catch {
+      return null;
+    }
+    if (stat13.size === 0) return null;
+    try {
+      const scan = await scanLatestLifecycleBoundary(fp, stat13.size);
+      if (scan?.boundary.type !== "in_flight_start") return null;
+      return {
+        sessionId,
+        path: fp,
+        lastEventTs: scan.boundary.ts,
+        context: scan.boundary.context,
+        eventCount: scan.eventCount
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Generate a recovery plan for a session. The plan describes
+   * the persisted tail after the last checkpoint, plus the dangling in-flight
+   * marker if present. SessionStore.resume() independently reconstructs state
+   * from the journal and does not re-run these events as commands.
+   *
+   * Returns a non-null plan for ANY session that has at least
+   * one event after a checkpoint (or, for legacy sessions, at
+   * least one event). Pure read; no mutation.
+   */
+  async recover(sessionId) {
+    const canonicalId = await this.resolveId(sessionId);
+    const fp = this.filePath(canonicalId);
+    const pendingEvents = [];
+    const pendingSizes = [];
+    let pendingBytes = 0;
+    let lastCheckpoint = null;
+    let latestBoundary = null;
+    let sawEvent = false;
+    const stream = createReadStream4(fp, { encoding: "utf8" });
+    const lines = createInterface4({ input: stream, crlfDelay: Infinity });
+    try {
+      for await (const line of lines) {
+        if (!line.trim()) continue;
+        let event;
+        try {
+          event = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (!event || typeof event !== "object" || typeof event.type !== "string") continue;
+        sawEvent = true;
+        if (event.type === "checkpoint") {
+          lastCheckpoint = event;
+          pendingEvents.length = 0;
+          pendingSizes.length = 0;
+          pendingBytes = 0;
+        } else {
+          const bytes = Buffer.byteLength(line, "utf8");
+          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());
+            }
+            pendingEvents.push(event);
+            pendingSizes.push(bytes);
+            pendingBytes += bytes;
+          }
+        }
+        if (isLifecycleBoundary(event)) latestBoundary = event;
+      }
+    } catch {
+      return null;
+    } finally {
+      lines.close();
+      stream.close();
+    }
+    if (!sawEvent) return null;
+    const inFlightStart = latestBoundary?.type === "in_flight_start" ? latestBoundary : null;
+    const context = inFlightStart && inFlightStart.type === "in_flight_start" ? inFlightStart.context : null;
+    return {
+      sessionId: canonicalId,
+      stale: inFlightStart !== null,
+      lastCheckpoint,
+      pendingEvents,
+      inFlightStart,
+      context
+    };
+  }
+  /**
+   * List every stale session in a directory. Returns an array
+   * (possibly empty) sorted by `lastEventTs` descending — most
+   * recent crash first.
+   */
+  async listResumable() {
+    const out = [];
+    const collect = async (dir, prefix, depth) => {
+      let entries;
+      try {
+        entries = await fs4.readdir(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (entry.name.startsWith(".")) continue;
+        if (entry.name === "shared" || entry.name === "subagents" || entry.name === "attachments")
+          continue;
+        if (entry.isDirectory()) {
+          if (depth === 0) {
+            await collect(path30.join(dir, entry.name), entry.name, depth + 1);
+          }
+          continue;
+        }
+        if (!entry.isFile() || !isSessionTranscriptFileName(entry.name)) continue;
+        const base = entry.name.slice(0, -".jsonl".length);
+        const sessionId = prefix ? `${prefix}/${base}` : base;
+        const stale = await this.detectStaleExact(sessionId);
+        if (stale) out.push(stale);
+      }
+    };
+    await collect(this.dir, "", 0);
+    return out.sort((a, b) => b.lastEventTs.localeCompare(a.lastEventTs));
+  }
+  // ── Internals ──────────────────────────────────────────────────────────
+  filePath(sessionId) {
+    return sessionScopedPath(this.dir, sessionId, ".jsonl");
+  }
+};
+function isLifecycleBoundary(event) {
+  return event.type === "in_flight_start" || event.type === "in_flight_end" || event.type === "session_end";
+}
+function parseLifecycleBoundary(line) {
+  try {
+    const parsed = JSON.parse(line.toString("utf8"));
+    return isLifecycleBoundary(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function hasNonWhitespace(line) {
+  for (const byte of line) {
+    if (byte !== 9 && byte !== 10 && byte !== 13 && byte !== 32) return true;
+  }
+  return false;
+}
+async function scanLatestLifecycleBoundary(filePath, size) {
+  const CHUNK_SIZE2 = 64 * 1024;
+  const handle = await fs4.open(filePath, "r");
+  let position = size;
+  let laterLineFragment = Buffer.alloc(0);
+  let latestBoundary = null;
+  let eventCount = 0;
+  const observeLine = (line) => {
+    if (!hasNonWhitespace(line)) return null;
+    eventCount++;
+    return parseLifecycleBoundary(line);
+  };
+  try {
+    while (position > 0) {
+      const length = Math.min(CHUNK_SIZE2, position);
+      position -= length;
+      const chunk = Buffer.allocUnsafe(length);
+      const { bytesRead } = await handle.read(chunk, 0, length, position);
+      const data = Buffer.concat([chunk.subarray(0, bytesRead), laterLineFragment]);
+      let lineEnd = data.length;
+      for (let i = data.length - 1; i >= 0; i--) {
+        if (data[i] !== 10) continue;
+        const boundary2 = observeLine(data.subarray(i + 1, lineEnd));
+        if (!latestBoundary && boundary2) latestBoundary = boundary2;
+        lineEnd = i;
+      }
+      laterLineFragment = data.subarray(0, lineEnd);
+      if (latestBoundary && latestBoundary.type !== "in_flight_start") {
+        return { boundary: latestBoundary, eventCount };
+      }
+    }
+    const boundary = observeLine(laterLineFragment);
+    if (!latestBoundary && boundary) latestBoundary = boundary;
+    return latestBoundary ? { boundary: latestBoundary, eventCount } : null;
+  } finally {
+    await handle.close();
+  }
+}
+
+// src/storage/session-store/summary-builder.ts
+import { createReadStream as createReadStream5 } from "node:fs";
+import { createInterface as createInterface5 } from "node:readline";
 async function summarizeSessionFile(opts) {
   return summarizeSessionEventSequence({
     id: opts.id,
@@ -18841,8 +19494,8 @@ async function summarizeSessionEventSequence(opts) {
   }
 }
 async function* iterateSessionEvents(file, secretScrubber) {
-  const stream = createReadStream4(file, { encoding: "utf8" });
-  const lines = createInterface4({ input: stream, crlfDelay: Infinity });
+  const stream = createReadStream5(file, { encoding: "utf8" });
+  const lines = createInterface5({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of lines) {
       if (!line.trim()) continue;
@@ -18875,7 +19528,8 @@ async function executeResumeSession(params) {
     readSummaryManifest,
     searchEvents,
     persistCatalogSummary,
-    logWarn
+    logWarn,
+    sessionsDir
   } = params;
   const t0 = Date.now();
   const data = await load(canonicalId);
@@ -18896,6 +19550,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) {
@@ -18924,7 +19596,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",
@@ -18932,6 +19604,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,
@@ -18962,7 +19642,7 @@ async function executeResumeSession(params) {
       {
         resumed: true,
         initialSummary,
-        dir: path30.dirname(file),
+        dir: path31.dirname(file),
         filePath: file,
         secretScrubber,
         checkpointCas,
@@ -18973,9 +19653,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) {
@@ -19194,6 +19886,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);
       }
@@ -19238,6 +19935,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, summary, invalidateShard, onAppended, compactInner) {
   await ensureDir(dir);
   let shouldCompact = false;
@@ -19270,10 +19968,14 @@ async function readIndexFile(indexFile, currentCache) {
     const s = await fsp20.stat(indexFile);
     stat13 = { 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 === stat13.mtimeMs && currentCache.size === stat13.size && currentCache.ino === stat13.ino && currentCache.birthtimeMs === stat13.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 === stat13.ino && cached.birthtimeMs === stat13.birthtimeMs;
@@ -19289,14 +19991,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 fsp20.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();
@@ -19304,7 +20006,18 @@ async function readIndexFile(indexFile, currentCache) {
   const summaries = Array.from(byId.values());
   summaries.sort(compareSessionSummaries);
   const nextCache = { ...stat13, 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
@@ -19342,12 +20055,12 @@ async function readOrBuildShardManifestEntry(opts) {
 }
 
 // src/storage/session-store/strict-empty-check.ts
-import { createReadStream as createReadStream5 } from "node:fs";
-import { createInterface as createInterface5 } from "node:readline";
+import { createReadStream as createReadStream6 } from "node:fs";
+import { createInterface as createInterface6 } from "node:readline";
 var EMPTY_SESSION_EVENT_TYPES = /* @__PURE__ */ new Set(["session_start", "session_resumed", "session_end"]);
 async function isStrictlyEmptySessionFile(file) {
-  const input = createReadStream5(file, { encoding: "utf8" });
-  const lines = createInterface5({ input, crlfDelay: Infinity });
+  const input = createReadStream6(file, { encoding: "utf8" });
+  const lines = createInterface6({ input, crlfDelay: Infinity });
   let sawSessionStart = false;
   try {
     for await (const line of lines) {
@@ -19423,6 +20136,7 @@ function damagedSummary(id, startedAt) {
 }
 
 // src/storage/session-store.ts
+var SESSION_FILTER_POOL_LIMIT = 1e4;
 var DefaultSessionStore = class _DefaultSessionStore {
   dir;
   events;
@@ -19438,14 +20152,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 ? path31.resolve(opts.projectRoot) : void 0;
+    this.projectRoot = opts.projectRoot ? path32.resolve(opts.projectRoot) : void 0;
     this.checkpointCas = this.projectRoot ? new SessionCheckpointCas({
-      rootDir: path31.join(this.dir, "_cas"),
+      rootDir: path32.join(this.dir, "_cas"),
       projectRoot: this.projectRoot
     }) : void 0;
     this.events = opts.events;
@@ -19456,7 +20192,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: path31.dirname(this.dir),
+      projectDir: path32.dirname(this.dir),
       projectRoot: this.projectRoot
     }) : void 0;
   }
@@ -19478,7 +20214,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     this.clearLoadCache();
   }
   get indexFile() {
-    return path31.join(this.dir, "_index.jsonl");
+    return path32.join(this.dir, "_index.jsonl");
   }
   sessionPath(id, ext) {
     return sessionPath(this.dir, id, ext);
@@ -19504,19 +20240,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 = path32.join(shardDir, `${path32.basename(id)}.summary.json`);
+    try {
+      await fsp23.rm(sidecar, { force: true });
+    } catch (cause) {
+      emitSessionStoreError(this.events, id, sidecar, "create", toErrorMessage(cause), true);
+      try {
+        await fsp23.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 fsp23.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 fsp23.open(file, "a", 384);
+      handle = await fsp23.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,
@@ -19530,23 +20341,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) {
@@ -19608,7 +20407,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) {
@@ -19682,11 +20482,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 [];
     }
@@ -19701,15 +20504,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 [];
     }
@@ -19751,6 +20553,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
       id,
       (sid) => this.invalidateShardManifestBySessionId(sid),
       () => {
+        this._manualTombstones.add(id);
+        this._indexDeletedIds.add(id);
         this._indexCache = null;
         this.indexAppendCount++;
       }
@@ -19778,34 +20582,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();
@@ -19887,7 +20749,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     return void 0;
   }
   async collectSessionFilesInShard(shardKey) {
-    const dir = shardKey ? path31.join(this.dir, shardKey) : this.dir;
+    const dir = shardKey ? path32.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("/"));
   }
@@ -20063,9 +20925,9 @@ function makeDirectorSessionFactory(opts) {
   let dir;
   if (opts.store) {
     store = opts.store;
-    dir = opts.sessionsRoot ? path32.join(opts.sessionsRoot, runId) : "(caller-managed)";
+    dir = opts.sessionsRoot ? path33.join(opts.sessionsRoot, runId) : "(caller-managed)";
   } else if (opts.sessionsRoot) {
-    dir = path32.join(opts.sessionsRoot, runId);
+    dir = path33.join(opts.sessionsRoot, runId);
     store = new DefaultSessionStore({ dir });
   } else {
     throw new Error("makeDirectorSessionFactory requires either `store` or `sessionsRoot`");
@@ -20089,7 +20951,7 @@ function makeDirectorSessionFactory(opts) {
 }
 async function readDirectorSubagentSession(args) {
   if (!args.sessionsRoot) return null;
-  const filePath = path32.join(args.sessionsRoot, args.directorRunId, `${args.subagentId}.jsonl`);
+  const filePath = path33.join(args.sessionsRoot, args.directorRunId, `${args.subagentId}.jsonl`);
   let raw;
   try {
     raw = await fsp24.readFile(filePath, "utf8");
@@ -21789,12 +22651,12 @@ async function executeSubagentWithTimeout({
           }
           return new Promise((resolveDecision) => {
             let settled = false;
-            const resolve16 = (d) => {
+            const resolve17 = (d) => {
               if (settled) return;
               settled = true;
               resolveDecision(d);
             };
-            const fallback = setTimeout(() => resolve16("stop"), DECISION_TIMEOUT_MS);
+            const fallback = setTimeout(() => resolve17("stop"), DECISION_TIMEOUT_MS);
             const sessionId = currentSessionId();
             budget._events?.emit("budget.threshold_reached", {
               ...sessionId ? { sessionId } : {},
@@ -21804,11 +22666,11 @@ async function executeSubagentWithTimeout({
               timeoutMs: DECISION_TIMEOUT_MS,
               extend: (extra) => {
                 clearTimeout(fallback);
-                queueMicrotask(() => resolve16({ extend: extra }));
+                queueMicrotask(() => resolve17({ extend: extra }));
               },
               deny: () => {
                 clearTimeout(fallback);
-                resolve16("stop");
+                resolve17("stop");
               }
             });
           });
@@ -22215,7 +23077,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       taskIds.map((id) => {
         const cached = this.completedResults.find((r) => r.taskId === id);
         if (cached) return cached;
-        return new Promise((resolve16, reject) => {
+        return new Promise((resolve17, reject) => {
           const timeout = setTimeout(() => {
             this.off("task.completed", handler);
             reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
@@ -22224,7 +23086,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             if (result.taskId === id) {
               clearTimeout(timeout);
               this.off("task.completed", handler);
-              resolve16(result);
+              resolve17(result);
             }
           };
           this.on("task.completed", handler);
@@ -22249,13 +23111,13 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       const done = new Set(completed.map((r) => r.taskId));
       return { completed, pending: taskIds.filter((id) => !done.has(id)) };
     }
-    return new Promise((resolve16) => {
+    return new Promise((resolve17) => {
       let timer;
       const handler = ({ result }) => {
         if (!ids.has(result.taskId)) return;
         if (timer) clearTimeout(timer);
         this.off("task.completed", handler);
-        resolve16({
+        resolve17({
           completed: [result],
           pending: taskIds.filter((id) => id !== result.taskId)
         });
@@ -22263,7 +23125,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       if (opts?.timeoutMs !== void 0) {
         timer = setTimeout(() => {
           this.off("task.completed", handler);
-          resolve16({ completed: [], pending: [...taskIds], timedOut: true });
+          resolve17({ completed: [], pending: [...taskIds], timedOut: true });
         }, opts.timeoutMs);
       }
       this.on("task.completed", handler);
@@ -23531,7 +24393,7 @@ var Director = class _Director {
 // src/coordination/fleet-manager.ts
 import { randomUUID as randomUUID17 } from "node:crypto";
 import * as fsp26 from "node:fs/promises";
-import * as path33 from "node:path";
+import * as path34 from "node:path";
 var FleetManager = class {
   /** The fleet-wide event bus. */
   fleet;
@@ -23865,7 +24727,7 @@ var FleetManager = class {
       })),
       usage: this.usage.snapshot()
     };
-    await fsp26.mkdir(path33.dirname(this.manifestPath), { recursive: true });
+    await fsp26.mkdir(path34.dirname(this.manifestPath), { recursive: true });
     await atomicWrite(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
     return this.manifestPath;
   }
@@ -24028,7 +24890,7 @@ var FleetManager = class {
 };
 
 // src/coordination/remote-mailbox.ts
-import * as path37 from "node:path";
+import * as path38 from "node:path";
 
 // src/coordination/mailbox-constants.ts
 var HQ_MAILBOX_SNAPSHOT_MIN_INTERVAL_MS = 1e4;
@@ -24038,15 +24900,15 @@ var MAILBOX_MAX_ACK_BATCH = 500;
 
 // src/coordination/mailbox-project-server-client.ts
 import { spawn as spawn5 } from "node:child_process";
-import * as fs4 from "node:fs";
+import * as fs5 from "node:fs";
 import * as net2 from "node:net";
-import * as path35 from "node:path";
+import * as path36 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // src/coordination/mailbox-project-server-endpoint.ts
 import { createHash as createHash6 } from "node:crypto";
 import * as os3 from "node:os";
-import * as path34 from "node:path";
+import * as path35 from "node:path";
 
 // src/coordination/mailbox-project-server-protocol.ts
 var MAILBOX_PROJECT_SERVER_PROTOCOL_VERSION = 4;
@@ -24079,7 +24941,7 @@ function encodeMailboxProjectServerMessage(message) {
 // src/coordination/mailbox-project-server-endpoint.ts
 var MAILBOX_PROJECT_SERVER_METADATA_FILE = ".mailbox-server.json";
 function normalizeLocalPath(value) {
-  const resolved = path34.resolve(value);
+  const resolved = path35.resolve(value);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function mailboxProjectServerKey(projectDir) {
@@ -24090,14 +24952,14 @@ function mailboxProjectServerEndpoint(projectDir) {
   if (process.platform === "win32") {
     return `\\\\.\\pipe\\wrongstack-mailbox-v${MAILBOX_PROJECT_SERVER_PROTOCOL_VERSION}-${key}`;
   }
-  return path34.join(
+  return path35.join(
     os3.tmpdir(),
     `wsmb-v${MAILBOX_PROJECT_SERVER_PROTOCOL_VERSION}`,
     `${key}.sock`
   );
 }
 function mailboxProjectServerMetadataPath(projectDir) {
-  return path34.join(path34.resolve(projectDir), MAILBOX_PROJECT_SERVER_METADATA_FILE);
+  return path35.join(path35.resolve(projectDir), MAILBOX_PROJECT_SERVER_METADATA_FILE);
 }
 
 // src/coordination/mailbox-project-server-client.ts
@@ -24108,7 +24970,7 @@ var DEFAULT_HEARTBEAT_INTERVAL_MS = 1e4;
 var AUTH_RETRY_DELAY_MS = 150;
 var AUTH_RETRY_MAX_ATTEMPTS = 13;
 function normalizePath(value) {
-  const resolved = path35.resolve(value);
+  const resolved = path36.resolve(value);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function resolveProjectServerUrl() {
@@ -24118,7 +24980,7 @@ function resolveProjectServerUrl() {
   ]) {
     try {
       const url = new URL(relative4, import.meta.url);
-      if (url.protocol === "file:" && fs4.existsSync(fileURLToPath4(url))) return url;
+      if (url.protocol === "file:" && fs5.existsSync(fileURLToPath4(url))) return url;
     } catch {
     }
   }
@@ -24128,7 +24990,7 @@ function isMailboxProjectServerAvailable() {
   return resolveProjectServerUrl() !== null;
 }
 function delay2(ms) {
-  return new Promise((resolve16) => setTimeout(resolve16, ms));
+  return new Promise((resolve17) => setTimeout(resolve17, ms));
 }
 function isUnauthorizedMailboxError(error) {
   return error instanceof Error && error.name === "UnauthorizedMailboxRequest";
@@ -24136,7 +24998,7 @@ function isUnauthorizedMailboxError(error) {
 var MailboxProjectServerConnection = class {
   constructor(projectDir) {
     this.projectDir = projectDir;
-    this.projectDir = path35.resolve(projectDir);
+    this.projectDir = path36.resolve(projectDir);
     this.endpoint = mailboxProjectServerEndpoint(this.projectDir);
     this.state = {
       status: isMailboxProjectServerAvailable() ? "offline" : "unavailable",
@@ -24301,7 +25163,7 @@ var MailboxProjectServerConnection = class {
     this.info = null;
     this.buffer = "";
     this.authToken = void 0;
-    return new Promise((resolve16, reject) => {
+    return new Promise((resolve17, reject) => {
       const socket = net2.createConnection(this.endpoint);
       this.socket = socket;
       socket.setEncoding("utf8");
@@ -24316,7 +25178,7 @@ var MailboxProjectServerConnection = class {
         this.connectReject = null;
         this.startHeartbeat();
         this.transition("connected");
-        resolve16();
+        resolve17();
         void this.request({ type: "request", op: "ping", args: {} }, 3e3).catch(
           () => void 0
         );
@@ -24345,7 +25207,7 @@ var MailboxProjectServerConnection = class {
   currentAuthToken() {
     if (this.authToken === void 0) {
       try {
-        const raw = fs4.readFileSync(mailboxProjectServerMetadataPath(this.projectDir), "utf8");
+        const raw = fs5.readFileSync(mailboxProjectServerMetadataPath(this.projectDir), "utf8");
         const parsed = JSON.parse(raw);
         if (typeof parsed.authToken === "string" && parsed.authToken.length > 0) {
           this.authToken = parsed.authToken;
@@ -24369,7 +25231,7 @@ var MailboxProjectServerConnection = class {
     if (encoded.length > MAILBOX_PROJECT_SERVER_MAX_FRAME_CHARS) {
       return Promise.reject(new Error("Mailbox project server request exceeded frame limit"));
     }
-    return new Promise((resolve16, reject) => {
+    return new Promise((resolve17, reject) => {
       const timer = setTimeout(() => {
         const pending = this.pending.get(id);
         if (!pending) return;
@@ -24377,7 +25239,7 @@ var MailboxProjectServerConnection = class {
         pending.reject(new Error(`Mailbox ${message.type} exceeded its ${timeoutMs}ms timeout`));
       }, timeoutMs);
       timer.unref?.();
-      this.pending.set(id, { resolve: resolve16, reject, timer });
+      this.pending.set(id, { resolve: resolve17, reject, timer });
       socket.write(encoded);
     });
   }
@@ -24492,7 +25354,7 @@ var MailboxProjectServerConnection = class {
   spawnDetachedServer() {
     const url = resolveProjectServerUrl();
     if (!url) throw new Error("Mailbox project server entrypoint is unavailable");
-    fs4.mkdirSync(this.projectDir, { recursive: true });
+    fs5.mkdirSync(this.projectDir, { recursive: true });
     const child = spawn5(process.execPath, [fileURLToPath4(url), "--project-dir", this.projectDir], {
       cwd: this.projectDir,
       detached: process.platform !== "win32",
@@ -24593,9 +25455,9 @@ var CredentialVerifyThrottle = class {
 var credentialVerifyThrottle = new CredentialVerifyThrottle();
 
 // src/coordination/global-mailbox-paths.ts
-import * as path36 from "node:path";
+import * as path37 from "node:path";
 function resolveProjectDir(projectRoot, globalRoot) {
-  return path36.join(globalRoot, "projects", projectSlug(projectRoot));
+  return path37.join(globalRoot, "projects", projectSlug(projectRoot));
 }
 
 // src/coordination/sqlite-mailbox.ts
@@ -24645,8 +25507,8 @@ var RemoteMailbox = class {
       hqPublisher,
       eventEmitter
     } : optionsOrProjectDir;
-    this.projectDir = path37.resolve(options.projectDir);
-    this.messagePath = path37.join(this.projectDir, SQLITE_MAILBOX_FILE);
+    this.projectDir = path38.resolve(options.projectDir);
+    this.messagePath = path38.join(this.projectDir, SQLITE_MAILBOX_FILE);
     this.registryPath = this.messagePath;
     this.clientRegistryPath = this.messagePath;
     this.events = options.events;
@@ -24892,7 +25754,7 @@ var RemoteMailbox = class {
       this.hqEventPending.clear();
       return;
     }
-    const mailboxId = `${path37.basename(this.projectDir)}:mailbox`;
+    const mailboxId = `${path38.basename(this.projectDir)}:mailbox`;
     const inFlight = this.query({ includeDeleted: true, limit: 100 }).then((messages) => {
       const message = messages.find((candidate) => candidate.id === event.messageId);
       const action = event.type === "message.sent" ? "message.sent" : "message.updated";
@@ -24915,7 +25777,7 @@ var RemoteMailbox = class {
     if (!publisher || this.closed || !event.startsWith("mailbox.agent_") && !event.startsWith("mailbox.client_")) {
       return;
     }
-    const mailboxId = `${path37.basename(this.projectDir)}:mailbox`;
+    const mailboxId = `${path38.basename(this.projectDir)}:mailbox`;
     const record = typeof payload === "object" && payload !== null ? payload : {};
     const agentId = typeof record["agentId"] === "string" ? record["agentId"] : void 0;
     const action = event === "mailbox.agent_registered" ? "agent.registered" : event === "mailbox.agent_heartbeat" ? "agent.heartbeat" : event === "mailbox.agent_deregistered" ? "agent.deregistered" : void 0;
@@ -24948,7 +25810,7 @@ function createProjectMailbox(options) {
   return new RemoteMailbox(options);
 }
 function getSharedProjectMailbox(projectDir, events, hqPublisher) {
-  const key = path37.resolve(projectDir);
+  const key = path38.resolve(projectDir);
   let projectCache = sharedRemoteMailboxes.get(key);
   if (!projectCache) {
     projectCache = {
@@ -27298,25 +28160,25 @@ function requiredSendCapability(type) {
   }
   return "mail.send.informational";
 }
-function requiredCredentialCapability(method, path42) {
-  if (method === "POST" && path42 === "/mailbox/send") return "mail.send.informational";
-  if (method === "POST" && (path42 === "/mailbox/query" || path42 === "/mailbox/check")) {
+function requiredCredentialCapability(method, path44) {
+  if (method === "POST" && path44 === "/mailbox/send") return "mail.send.informational";
+  if (method === "POST" && (path44 === "/mailbox/query" || path44 === "/mailbox/check")) {
     return "mail.read.self";
   }
-  if (method === "POST" && (path42 === "/mailbox/ack" || path42 === "/mailbox/ack-many")) {
+  if (method === "POST" && (path44 === "/mailbox/ack" || path44 === "/mailbox/ack-many")) {
     return "mail.ack.self";
   }
-  if (method === "POST" && path42 === "/mailbox/unread-count") return "mail.read.self";
-  if (method === "POST" && path42 === "/mailbox/agents/register") {
+  if (method === "POST" && path44 === "/mailbox/unread-count") return "mail.read.self";
+  if (method === "POST" && path44 === "/mailbox/agents/register") {
     return "mail.presence.register.self";
   }
-  if (method === "POST" && path42 === "/mailbox/agents/heartbeat") {
+  if (method === "POST" && path44 === "/mailbox/agents/heartbeat") {
     return "mail.presence.heartbeat.self";
   }
-  if (method === "GET" && (path42 === "/mailbox/agents" || path42 === "/mailbox/agents/online")) {
+  if (method === "GET" && (path44 === "/mailbox/agents" || path44 === "/mailbox/agents/online")) {
     return "mail.presence.read";
   }
-  if (method === "GET" && path42 === "/mailbox/events") return "mail.events.self";
+  if (method === "GET" && path44 === "/mailbox/events") return "mail.events.self";
   return void 0;
 }
 async function checkMailbox(mailbox, input, minTimestampIso, includeReceiptState = false, eligibleRecipients, readerRole) {
@@ -27536,7 +28398,7 @@ function createMailboxHttpRouter(options) {
           return;
         }
         const customAccess = options.authorize ? await options.authorize(request) : void 0;
-        let access5 = customAccess ?? { allowed: true };
+        let access6 = customAccess ?? { allowed: true };
         const presentedCredential = parseCredentialAuthorization(request);
         if (options.credentialStore !== void 0 && presentedCredential !== void 0) {
           const persistedAccess = await authorizePersistedMailboxCredential(
@@ -27544,30 +28406,30 @@ function createMailboxHttpRouter(options) {
             options.credentialStore
           );
           if (!persistedAccess.allowed) {
-            access5 = persistedAccess;
+            access6 = persistedAccess;
           } else if (persistedAccess.actor === void 0) {
-            access5 = { allowed: false };
-          } else if (access5.allowed) {
-            if (access5.actor !== void 0 && (access5.actor.actorId !== persistedAccess.actor.actorId || access5.actor.projectId !== persistedAccess.actor.projectId)) {
-              access5 = { allowed: false };
+            access6 = { allowed: false };
+          } else if (access6.allowed) {
+            if (access6.actor !== void 0 && (access6.actor.actorId !== persistedAccess.actor.actorId || access6.actor.projectId !== persistedAccess.actor.projectId)) {
+              access6 = { allowed: false };
             } else {
-              access5 = {
-                ...access5,
+              access6 = {
+                ...access6,
                 actor: persistedAccess.actor,
-                ...access5.rateLimitKey ?? persistedAccess.rateLimitKey ? { rateLimitKey: access5.rateLimitKey ?? persistedAccess.rateLimitKey } : {}
+                ...access6.rateLimitKey ?? persistedAccess.rateLimitKey ? { rateLimitKey: access6.rateLimitKey ?? persistedAccess.rateLimitKey } : {}
               };
             }
           }
         } else if (customAccess === void 0 && options.credentialStore !== void 0) {
-          access5 = { allowed: false };
+          access6 = { allowed: false };
         }
-        if (access5.allowed && access5.actor !== void 0 && options.projectId !== void 0 && access5.actor.projectId !== options.projectId) {
+        if (access6.allowed && access6.actor !== void 0 && options.projectId !== void 0 && access6.actor.projectId !== options.projectId) {
           writeJson(response, 403, {
             error: { code: "FORBIDDEN", message: "credential is scoped to a different project" }
           });
           return;
         }
-        if (!access5.allowed) {
+        if (!access6.allowed) {
           const forwardedFor = request.headers["x-forwarded-for"];
           const clientIp = (Array.isArray(forwardedFor) ? forwardedFor[0] : forwardedFor)?.split(",")[0]?.trim() ?? request.socket?.remoteAddress ?? "unknown";
           console.warn(
@@ -27583,14 +28445,14 @@ function createMailboxHttpRouter(options) {
           );
           writeJson(
             response,
-            access5.status ?? 401,
-            access5.body ?? {
+            access6.status ?? 401,
+            access6.body ?? {
               error: { code: "UNAUTHORIZED", message: "invalid or missing authorization credential" }
             }
           );
           return;
         }
-        if (options.rateLimiter && access5.rateLimitKey !== void 0 && !options.rateLimiter.allow(access5.rateLimitKey)) {
+        if (options.rateLimiter && access6.rateLimitKey !== void 0 && !options.rateLimiter.allow(access6.rateLimitKey)) {
           writeJson(response, 429, {
             error: {
               code: "RATE_LIMITED",
@@ -27610,7 +28472,7 @@ function createMailboxHttpRouter(options) {
           defaultMaxAgeMs,
           closeSseStreams,
           routePath,
-          access5.actor,
+          access6.actor,
           options.credentialStore
         );
       } catch (error) {
@@ -27638,16 +28500,16 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
     throw validationError(`routePath must not start with '?' (got ${JSON.stringify(routePath)})`);
   }
   const queryIndex = url.indexOf("?");
-  const path42 = queryIndex === -1 ? url : url.slice(0, queryIndex);
+  const path44 = queryIndex === -1 ? url : url.slice(0, queryIndex);
   if (actor !== void 0) {
-    const requiredCapability = requiredCredentialCapability(method, path42);
+    const requiredCapability = requiredCredentialCapability(method, path44);
     if (requiredCapability === void 0) {
       writeJson(response, 403, {
-        error: { code: "FORBIDDEN", message: `credential access is not permitted for ${method} ${path42}` }
+        error: { code: "FORBIDDEN", message: `credential access is not permitted for ${method} ${path44}` }
       });
       return;
     }
-    if (path42 !== "/mailbox/send" && !hasMailboxCapability(actor, requiredCapability)) {
+    if (path44 !== "/mailbox/send" && !hasMailboxCapability(actor, requiredCapability)) {
       writeJson(response, 403, {
         error: {
           code: "FORBIDDEN",
@@ -27657,7 +28519,7 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
       return;
     }
   }
-  if (method === "POST" && path42 === "/mailbox/send") {
+  if (method === "POST" && path44 === "/mailbox/send") {
     const input = validateSend(
       await readJsonBody(request, maxBodyBytes),
       actor?.actorId,
@@ -27679,7 +28541,7 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
     writeJson(response, 201, await mailbox.send(input));
     return;
   }
-  if (method === "POST" && path42 === "/mailbox/query") {
+  if (method === "POST" && path44 === "/mailbox/query") {
     const queryContext = parseSinceMs(url, defaultMaxAgeMs);
     if ("error" in queryContext) {
       writeJson(response, 400, { error: queryContext.error });
@@ -27699,7 +28561,7 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
     writeJson(response, 200, { data: projected, count: projected.length });
     return;
   }
-  if (method === "POST" && path42 === "/mailbox/check") {
+  if (method === "POST" && path44 === "/mailbox/check") {
     const queryContext = parseSinceMs(url, defaultMaxAgeMs);
     if ("error" in queryContext) {
       writeJson(response, 400, { error: queryContext.error });
@@ -27733,7 +28595,7 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
     writeJson(response, 200, { data: projected, count: projected.length });
     return;
   }
-  if (method === "POST" && path42 === "/mailbox/ack") {
+  if (method === "POST" && path44 === "/mailbox/ack") {
     const input = validateAck(await readJsonBody(request, maxBodyBytes), actor?.actorId);
     if (actor !== void 0) {
       input.readerId = actor.actorId;
@@ -27747,7 +28609,7 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
     writeJson(response, 200, { updated: projectedAck });
     return;
   }
-  if (method === "POST" && path42 === "/mailbox/ack-many") {
+  if (method === "POST" && path44 === "/mailbox/ack-many") {
     const input = validateAckMany(await readJsonBody(request, maxBodyBytes), actor?.actorId);
     if (actor !== void 0) {
       const requestedIds = new Set(input.acks.map((ack) => ack.messageId));
@@ -27763,54 +28625,54 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
     writeJson(response, 200, { updated: projectedMany, count: projectedMany.length });
     return;
   }
-  if (method === "POST" && path42 === "/mailbox/unread-count") {
+  if (method === "POST" && path44 === "/mailbox/unread-count") {
     const body = await readJsonBody(request, maxBodyBytes);
     const count = actor === void 0 ? await mailbox.unreadCount(requireString2(body, "forAgentId")) : await unreadCountForActor(mailbox, actor);
     writeJson(response, 200, { count });
     return;
   }
-  if (method === "POST" && path42 === "/mailbox/agents/register") {
+  if (method === "POST" && path44 === "/mailbox/agents/register") {
     const input = validateAgentRegistration(await readJsonBody(request, maxBodyBytes), actor);
     await mailbox.registerAgent(input);
     writeJson(response, 200, { ok: true });
     return;
   }
-  if (method === "POST" && path42 === "/mailbox/agents/heartbeat") {
+  if (method === "POST" && path44 === "/mailbox/agents/heartbeat") {
     const input = validateAgentHeartbeat(await readJsonBody(request, maxBodyBytes), actor?.actorId);
     if (actor !== void 0) input.agentId = actor.actorId;
     await mailbox.heartbeat(input);
     writeJson(response, 200, { ok: true });
     return;
   }
-  if (method === "POST" && path42 === "/mailbox/register-client") {
+  if (method === "POST" && path44 === "/mailbox/register-client") {
     await mailbox.registerClient(
       validateClientRegistration(await readJsonBody(request, maxBodyBytes))
     );
     writeJson(response, 200, { ok: true });
     return;
   }
-  if (method === "POST" && path42 === "/mailbox/heartbeat") {
+  if (method === "POST" && path44 === "/mailbox/heartbeat") {
     await mailbox.clientHeartbeat(
       validateClientHeartbeat(await readJsonBody(request, maxBodyBytes))
     );
     writeJson(response, 200, { ok: true });
     return;
   }
-  if (method === "POST" && path42 === "/mailbox/purge-clients") {
+  if (method === "POST" && path44 === "/mailbox/purge-clients") {
     writeJson(response, 200, { ok: true, purged: await mailbox.purgeClients() });
     return;
   }
-  if (method === "GET" && path42 === "/mailbox/agents") {
+  if (method === "GET" && path44 === "/mailbox/agents") {
     const agents = await mailbox.getAgentStatuses();
     writeJson(response, 200, { data: agents, count: agents.length });
     return;
   }
-  if (method === "GET" && path42 === "/mailbox/agents/online") {
+  if (method === "GET" && path44 === "/mailbox/agents/online") {
     const agents = await mailbox.getOnlineAgents();
     writeJson(response, 200, { data: agents, count: agents.length });
     return;
   }
-  if (method === "GET" && path42 === "/mailbox/events" && eventEmitter) {
+  if (method === "GET" && path44 === "/mailbox/events" && eventEmitter) {
     const queryContext = parseSinceMs(url, defaultMaxAgeMs);
     if ("error" in queryContext) {
       writeJson(response, 400, { error: queryContext.error });
@@ -27870,16 +28732,16 @@ function writeJson(response, status, body) {
 var NULL_FLEET_BUS = new FleetBus();
 
 // src/coordination/package-author-tracker.ts
-import * as fs5 from "node:fs/promises";
-import * as path38 from "node:path";
+import * as fs6 from "node:fs/promises";
+import * as path39 from "node:path";
 var DEFAULT_MAX_ENTRIES2 = 1e4;
 var LOG_FILENAME2 = "package-authors.json";
 function logPath2(storageDir) {
-  return path38.join(storageDir, LOG_FILENAME2);
+  return path39.join(storageDir, LOG_FILENAME2);
 }
 async function loadLog2(storageDir, projectRoot) {
   try {
-    const raw = await fs5.readFile(logPath2(storageDir), "utf-8");
+    const raw = await fs6.readFile(logPath2(storageDir), "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed.entries || !Array.isArray(parsed.entries)) {
       return { projectRoot, entries: [] };
@@ -27897,7 +28759,7 @@ async function saveLog2(storageDir, log) {
 `);
 }
 function detectEcosystem(manifestPath) {
-  const name = path38.win32.basename(manifestPath).toLowerCase();
+  const name = path39.win32.basename(manifestPath).toLowerCase();
   if (name === "package.json") return "npm";
   if (name === "go.mod") return "go";
   if (name === "cargo.toml") return "cargo";
@@ -28787,12 +29649,12 @@ import { randomBytes as randomBytes2 } from "node:crypto";
 import * as fsp27 from "node:fs/promises";
 import { execFile } from "node:child_process";
 import * as os4 from "node:os";
-import * as path39 from "node:path";
+import * as path40 from "node:path";
 var MAILBOX_BRIDGE_LOCK_FILENAME = ".mailbox-bridge.lock";
 var MAILBOX_BRIDGE_TOKEN_FILENAME = ".mailbox.token";
 async function acquireOrJoin(opts) {
-  const lockPath = path39.join(opts.projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
-  const tokenPath = path39.join(opts.projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
+  const lockPath = path40.join(opts.projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
+  const tokenPath = path40.join(opts.projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
   const inspected = await readLockForInspection(lockPath);
   if (inspected.kind === "live") {
     const existing = inspected.lock;
@@ -28820,8 +29682,8 @@ async function acquireOrJoin(opts) {
   return { kind: "acquired", lock: tentative, tokenPath };
 }
 async function finalize(projectDir, tentative, boundPort) {
-  const lockPath = path39.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
-  const tokenPath = path39.join(projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
+  const lockPath = path40.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
+  const tokenPath = path40.join(projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
   const finalized = {
     ...tentative,
     port: boundPort,
@@ -28832,8 +29694,8 @@ async function finalize(projectDir, tentative, boundPort) {
   return finalized;
 }
 async function release(projectDir, generation) {
-  const lockPath = path39.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
-  const tokenPath = path39.join(projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
+  const lockPath = path40.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
+  const tokenPath = path40.join(projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
   try {
     const raw = await fsp27.readFile(lockPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -28867,7 +29729,7 @@ async function readLockForInspection(lockPath) {
   return { kind: "live", lock: parsed };
 }
 async function readLiveLock(projectDir) {
-  const lockPath = path39.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
+  const lockPath = path40.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
   const result = await readLockForInspection(lockPath);
   if (result.kind === "live") {
     return { kind: "live", lock: result.lock };
@@ -28878,7 +29740,7 @@ async function readLiveLock(projectDir) {
   return { kind: "absent" };
 }
 async function atomicWriteJson(targetPath, value) {
-  const dir = path39.dirname(targetPath);
+  const dir = path40.dirname(targetPath);
   await fsp27.mkdir(dir, { recursive: true });
   const tmp = `${targetPath}.tmp.${process.pid}.${randomBytes2(4).toString("hex")}`;
   const body = JSON.stringify(value, null, 2) + "\n";
@@ -28894,7 +29756,7 @@ async function isProcessAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   if (pid === process.pid) return true;
   if (os4.platform() === "win32") {
-    return new Promise((resolve16) => {
+    return new Promise((resolve17) => {
       execFile(
         "tasklist",
         ["/FI", `PID eq ${pid}`, "/NH", "/FO", "CSV"],
@@ -28906,11 +29768,11 @@ async function isProcessAlive(pid) {
         },
         (error, out) => {
           if (error) {
-            resolve16(false);
+            resolve17(false);
             return;
           }
           const match = /(?:^|\n)"[^"]*","(\d+)"/.exec(out);
-          resolve16(match !== null && match[1] === String(pid));
+          resolve17(match !== null && match[1] === String(pid));
         }
       );
     });
@@ -29061,8 +29923,8 @@ function acceptManifestCandidate(candidate) {
   if (normalized.split("/").includes("..")) return false;
   return isManifestFile(normalized);
 }
-function isManifestFile(path42) {
-  const name = pathBasename(path42).toLowerCase();
+function isManifestFile(path44) {
+  const name = pathBasename(path44).toLowerCase();
   const manifests = [
     "package.json",
     "package-lock.json",
@@ -29142,7 +30004,7 @@ function buildTechStackTask(msg, manifestPath) {
   ].join("\n");
 }
 
-// src/middleware/collab-pause.ts
+// src/coordination/collab-pause.ts
 function collabPauseMiddleware(bus, opts = {}) {
   const timeoutMs = opts.defaultTimeoutMs ?? 6e4;
   const logger = opts.logger;
@@ -29373,10 +30235,10 @@ var AdaptiveConcurrencyController = class {
 };
 
 // src/coordination/agent-monitor.ts
-import { createReadStream as createReadStream6 } from "node:fs";
-import * as fs6 from "node:fs/promises";
-import * as path40 from "node:path";
-import { createInterface as createInterface6 } from "node:readline";
+import { createReadStream as createReadStream7 } from "node:fs";
+import * as fs7 from "node:fs/promises";
+import * as path41 from "node:path";
+import { createInterface as createInterface7 } from "node:readline";
 var AgentMonitorService = class _AgentMonitorService {
   _fleetBus;
   _events;
@@ -29455,7 +30317,7 @@ var AgentMonitorService = class _AgentMonitorService {
   async loadSessionsFromDisk() {
     let subagentIds;
     try {
-      const dirents = await fs6.readdir(this._transcriptsDir, { withFileTypes: true });
+      const dirents = await fs7.readdir(this._transcriptsDir, { withFileTypes: true });
       subagentIds = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
     } catch {
       return this.getAllSessions();
@@ -29479,12 +30341,12 @@ var AgentMonitorService = class _AgentMonitorService {
     return this.getAllSessions();
   }
   async _readTranscriptFile(subagentId) {
-    const file = path40.join(this._transcriptsDir, subagentId, "transcript.jsonl");
-    const accessible = await fs6.access(file).then(() => true).catch(() => false);
+    const file = path41.join(this._transcriptsDir, subagentId, "transcript.jsonl");
+    const accessible = await fs7.access(file).then(() => true).catch(() => false);
     if (!accessible) return [];
     const out = [];
-    const input = createReadStream6(file, { encoding: "utf8" });
-    const lines = createInterface6({ input, crlfDelay: Number.POSITIVE_INFINITY });
+    const input = createReadStream7(file, { encoding: "utf8" });
+    const lines = createInterface7({ input, crlfDelay: Number.POSITIVE_INFINITY });
     try {
       for await (const line of lines) {
         const trimmed = line.trim();
@@ -29725,9 +30587,9 @@ var AgentMonitorService = class _AgentMonitorService {
    * firehose (or, worse, only the first word).
    */
   _appendStreamDelta(subagentId, session, kind, text, iteration) {
-    const open9 = this._openStreams.get(subagentId);
-    if (open9 && open9.entry.kind === kind && open9.entry.iteration === iteration && open9.entry.content.length + text.length <= _AgentMonitorService._MAX_SEGMENT_CHARS) {
-      open9.entry.content += text;
+    const open10 = this._openStreams.get(subagentId);
+    if (open10 && open10.entry.kind === kind && open10.entry.iteration === iteration && open10.entry.content.length + text.length <= _AgentMonitorService._MAX_SEGMENT_CHARS) {
+      open10.entry.content += text;
       return;
     }
     this._closeStream(subagentId);
@@ -29751,11 +30613,11 @@ var AgentMonitorService = class _AgentMonitorService {
    * announce the completed entry on the local bus + HQ callback.
    */
   _closeStream(subagentId) {
-    const open9 = this._openStreams.get(subagentId);
-    if (!open9) return;
+    const open10 = this._openStreams.get(subagentId);
+    if (!open10) return;
     this._openStreams.delete(subagentId);
-    this._enqueueWrite(subagentId, open9.entry);
-    this._emitEntry(open9.entry);
+    this._enqueueWrite(subagentId, open10.entry);
+    this._emitEntry(open10.entry);
   }
   _addEntry(subagentId, entry) {
     const session = this._sessions.get(subagentId);
@@ -29820,14 +30682,14 @@ var AgentMonitorService = class _AgentMonitorService {
     this._writeDrain = drain;
   }
   async _appendToFile(subagentId, line) {
-    const dir = path40.join(this._transcriptsDir, subagentId);
+    const dir = path41.join(this._transcriptsDir, subagentId);
     if (!this._ensuredDirs.has(dir)) {
-      await fs6.mkdir(dir, { recursive: true });
+      await fs7.mkdir(dir, { recursive: true });
       this._ensuredDirs.add(dir);
     }
-    const filePath = path40.join(dir, "transcript.jsonl");
+    const filePath = path41.join(dir, "transcript.jsonl");
     try {
-      await fs6.appendFile(filePath, line, { encoding: "utf8", mode: SECRET_FILE_MODE });
+      await fs7.appendFile(filePath, line, { encoding: "utf8", mode: SECRET_FILE_MODE });
     } catch (error) {
       this._ensuredDirs.delete(dir);
       throw error;
@@ -30218,7 +31080,7 @@ import { randomUUID as randomUUID22 } from "node:crypto";
 // src/coordination/knowledge-graph.ts
 import { randomUUID as randomUUID20 } from "node:crypto";
 import * as fsp28 from "node:fs/promises";
-import * as path41 from "node:path";
+import * as path42 from "node:path";
 var DEFAULT_MAX_NODES = 2e3;
 var MAX_SUBSCRIPTIONS = 1e3;
 var MAX_PENDING_DELIVERIES_PER_SUBSCRIPTION = 1e3;
@@ -30253,8 +31115,8 @@ var KnowledgeGraph = class _KnowledgeGraph {
     return this.index;
   }
   constructor(sessionDir, maxNodes = DEFAULT_MAX_NODES, compactEveryWrites = Math.max(1e3, maxNodes * 4)) {
-    this.filePath = path41.join(sessionDir, "_knowledge_graph");
-    this.graphFilePath = path41.join(this.filePath, "graph.jsonl");
+    this.filePath = path42.join(sessionDir, "_knowledge_graph");
+    this.graphFilePath = path42.join(this.filePath, "graph.jsonl");
     this.maxNodes = maxNodes;
     this.compactEveryWrites = Math.max(1, Math.floor(compactEveryWrites));
   }
@@ -31358,6 +32220,11 @@ var ConsensusProtocol = class {
     if (change?.type !== "change") {
       throw new Error(`ConsensusProtocol: no change found with id "${changeId}"`);
     }
+    if (change.status === "approved" || change.status === "rejected") {
+      throw new Error(
+        `ConsensusProtocol: cannot initiate vote on already resolved change "${changeId}" (status: "${change.status}")`
+      );
+    }
     await this.graph.update(changeId, { status: "proposed", votes: [] });
     const eligible = this._eligibleVoters(change);
     this._notifyVoters(change, eligible, "vote_initiated");
@@ -31371,6 +32238,11 @@ var ConsensusProtocol = class {
     if (change?.type !== "change") {
       throw new Error(`ConsensusProtocol: no change found for "${changeId}"`);
     }
+    if (change.status !== "proposed") {
+      throw new Error(
+        `ConsensusProtocol: cannot cast vote on change "${changeId}" with status "${change.status}" (ballot is closed)`
+      );
+    }
     const voter = this.voters.get(voterId);
     if (!voter) {
       throw new Error(`ConsensusProtocol: unknown voter "${voterId}"`);
@@ -31445,8 +32317,8 @@ var ConsensusProtocol = class {
       (sum, v) => sum + (this.voters.get(v.agentId)?.weight ?? 1),
       0
     );
-    const totalWeight = Array.from(this.voters.values()).reduce(
-      (sum, v) => sum + v.weight,
+    const totalWeight = eligible.reduce(
+      (sum, id) => sum + (this.voters.get(id)?.weight ?? 1),
       0
     );
     const castCount = votes.length;
@@ -32166,17 +33038,17 @@ ${input.detail}`
   _waitForDagProgress(timeoutMs) {
     const before = this._dagProgressKey();
     if (this.dag.isDone()) return Promise.resolve();
-    return new Promise((resolve16) => {
+    return new Promise((resolve17) => {
       let off;
       const timer = setTimeout(() => {
         off?.();
-        resolve16();
+        resolve17();
       }, timeoutMs);
       off = this.dag.onEvent(() => {
         if (this._dagProgressKey() === before) return;
         clearTimeout(timer);
         off?.();
-        resolve16();
+        resolve17();
       });
     });
   }
@@ -32484,8 +33356,8 @@ var CollaborationBus = class _CollaborationBus {
     if (this.isPaused()) return false;
     this.pausedAtMs = Date.now();
     this.pausedBy = byParticipant;
-    this.pausePromise = new Promise((resolve16) => {
-      this.pauseResolve = resolve16;
+    this.pausePromise = new Promise((resolve17) => {
+      this.pauseResolve = resolve17;
     });
     return true;
   }
@@ -32521,8 +33393,8 @@ var CollaborationBus = class _CollaborationBus {
       return true;
     }
     let timer;
-    const timeoutPromise = new Promise((resolve16) => {
-      timer = setTimeout(() => resolve16("timeout"), timeoutMs);
+    const timeoutPromise = new Promise((resolve17) => {
+      timer = setTimeout(() => resolve17("timeout"), timeoutMs);
     });
     const resumedPromise = this.pausePromise.then(() => "resumed").catch(() => "resumed");
     const winner = await Promise.race([resumedPromise, timeoutPromise]);
@@ -32615,6 +33487,843 @@ var CollaborationBus = class _CollaborationBus {
     }
   }
 };
+
+// src/coordination/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"
+  );
+  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/coordination/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/coordination/fleet-notifier.ts
+import * as fs8 from "node:fs/promises";
+import * as path43 from "node:path";
+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 = path43.resolve(root);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+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 fs8.readFile(path43.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)
+  });
+}
 export {
   ACP_AGENTS,
   AGENTS_BY_PHASE,
@@ -32624,6 +34333,7 @@ export {
   AUDIT_LOG_AGENT,
   AdaptiveConcurrencyController,
   AgentMonitorService,
+  AgentStatusTracker,
   AutonomousBrain,
   AutonomousCoordinator,
   BUG_HUNTER_AGENT,
@@ -32677,6 +34387,7 @@ export {
   FleetBus,
   FleetCostCapError,
   FleetManager,
+  FleetNotifier,
   FleetSpawnBudgetError,
   FleetSupervisor,
   FleetTokenCapError,
@@ -32798,6 +34509,8 @@ export {
   isMailboxProjectServerAvailable,
   isProvenDirective,
   isValidMatrixKey,
+  kanbanBoundaryOps,
+  kanbanDispatch,
   listProjectAgentLearnedEntries,
   listProjectAgentRoles,
   listProjectSkillAugmentations,
@@ -32889,6 +34602,8 @@ export {
   scoreSkillAffinity,
   scrubRetiredLines,
   sessionRecipient,
+  setKanbanBoundaryOps,
+  setKanbanDispatch,
   setSkillPinned,
   slugifyProjectAgentRole,
   startPackageOutdatedWatcher,