Freeze pruned mailbox wait status at last known result

A completed worker pruned from the session store was wait-reported as
interrupted because snapshot hard-froze missing sessions. Capture the
live wait projection and retention tombstone so wait keeps done/failed,
and only unknown missing sessions stay interrupted.

Author: TheGreatAxios

src/subagent/agent-fleet.test.ts

@@ -62,6 +62,33 @@ function makeDeps(
   };
 }
 
+function waitUntilMailboxTerminal(
+  mailbox: ReturnType<typeof createFleetMailbox>,
+  sessions: ReturnType<typeof createSubAgentSessionStore>,
+  id: string,
+): Promise<void> {
+  return new Promise((resolve) => {
+    const done = (): boolean => {
+      const snap = mailbox.peek(id);
+      return snap !== undefined && snap.status !== "running";
+    };
+    if (done()) {
+      resolve();
+      return;
+    }
+    const unsub = sessions.subscribe(() => {
+      if (done()) {
+        unsub();
+        resolve();
+      }
+    });
+    if (done()) {
+      unsub();
+      resolve();
+    }
+  });
+}
+
 async function callToolRaw(
   tool: ReturnType<typeof createSpawnAgentTool> | ReturnType<typeof createWaitAgentsTool>,
   args: Record<string, unknown>,
@@ -422,17 +449,29 @@ describe("wait mailbox session tombstone and pin", () => {
       maxCompleted: 1,
       now: () => ++t,
     });
-    const deps = makeDeps(async () => ({ report: "ok" }), { sessions });
+    const firstRun = deferred<RunSubAgentResult>();
+    const secondRun = deferred<RunSubAgentResult>();
+    let calls = 0;
+    const deps = makeDeps(
+      async () => {
+        calls += 1;
+        return (calls === 1 ? firstRun : secondRun).promise;
+      },
+      { sessions },
+    );
     const spawn = createSpawnAgentTool(deps);
     const wait = createWaitAgentsTool({ sessions, fleetRecords: deps.fleetRecords });
     if (spawn.kind !== "full") throw new Error("expected full tool");
     const args = { description: "job", prompt: "do it", intent: "explore" };
     const signal = new AbortController().signal;
 
     await spawn.handler({ id: "reuse-id", name: "spawn_agent", arguments: args }, signal);
-    await new Promise((resolve) => setTimeout(resolve, 20));
+    firstRun.resolve({ report: "ok" });
+    await callTool(wait, { targets: ["reuse-id"], timeout_ms: 5000 });
+
     await spawn.handler({ id: "reuse-id", name: "spawn_agent", arguments: args }, signal);
-    await new Promise((resolve) => setTimeout(resolve, 20));
+    secondRun.resolve({ report: "ok" });
+    await waitUntilMailboxTerminal(deps.fleetRecords, sessions, "reuse-id");
 
     const extra1 = sessions.start({ description: "flood-1", agentId: "a", brief: "b" });
     sessions.complete(extra1.id, "flood-1");
@@ -464,10 +503,19 @@ describe("wait mailbox session tombstone and pin", () => {
     sessions.complete(extra2.id, "prune");
     expect(sessions.get("reuse")).toBeUndefined();
     const snap = mailbox.peek("reuse");
-    expect(snap?.status).not.toBe("running");
+    expect(snap?.status).toBe("done");
     expect(snap?.tombstoned).toBe(true);
     expect(snap?.hint).toContain("read_agent_trace");
   });
+
+  test("wait on a mailbox member with no session history is interrupted", () => {
+    const sessions = createSubAgentSessionStore();
+    const mailbox = createFleetMailbox(sessions);
+    mailbox.register("ghost");
+    const snap = mailbox.peek("ghost");
+    expect(snap?.status).toBe("interrupted");
+    expect(snap?.tombstoned).toBe(true);
+  });
 });
 
 describe("spawn_agent parentage", () => {

src/subagent/agent-fleet.ts

@@ -59,7 +59,11 @@ import type { Settings } from "../config/settings.js";
 import { resolveEffortForRole } from "../provider/reasoning-effort.js";
 import { isCodexProviderName } from "../config/codex-providers.js";
 import { buildDispatchBrief, type TaskIntent } from "./report.js";
-import { DEFAULT_CANCEL_REASON, type SubAgentSessionStore } from "./session-store.js";
+import {
+  DEFAULT_CANCEL_REASON,
+  type AgentLifecycleStatus,
+  type SubAgentSessionStore,
+} from "./session-store.js";
 import { projectWaitStatus, type WaitJSONStatus } from "./lifecycle.js";
 import type {
   NestedDispatchDeps,
@@ -103,13 +107,23 @@ interface FleetOverlay {
   forceInterrupted?: boolean;
   /** Frozen wait status after collect. Later session completed must not resurrect this mailbox. */
   frozenStatus?: WaitJSONStatus;
+  /** Last wait projection seen while the session still existed. */
+  lastWaitStatus?: WaitJSONStatus;
   tombstoned?: boolean;
   hint?: string;
 }
 
 const RECOVERY_HINT =
   "Report evicted to bound fleet memory; recover full detail via read_agent_trace(agent_id).";
 
+function waitStatusFromVerbLifecycle(
+  status: AgentLifecycleStatus | undefined,
+): WaitJSONStatus | undefined {
+  if (status === "completed") return "done";
+  if (status === "interrupted" || status === "shutdown") return "interrupted";
+  return undefined;
+}
+
 /** Payload cap: uncollected pinned terminal records still holding a report. */
 export const MAX_FLEET_RECORDS = 200;
 
@@ -124,15 +138,22 @@ class FleetMailbox {
 
   constructor(sessions: SubAgentSessionStore) {
     this.sessions = sessions;
-    sessions?.subscribe(() => this.enforceCap());
+    sessions?.subscribe(() => {
+      this.rememberLiveWaitStatuses();
+      this.enforceCap();
+    });
   }
 
   register(id: string): void {
     const existing = this.records.get(id);
     // start() drops pinCounts on call-id reuse. Re-pin whenever the overlay
     // thought it still held a pin, so wait cannot desync against an empty map.
     if (existing?.pinHeld === true) this.sessions.unpin(id);
-    this.records.set(id, { pinHeld: true });
+    const wait = this.sessionWaitStatus(id);
+    this.records.set(id, {
+      pinHeld: true,
+      ...(wait !== undefined ? { lastWaitStatus: wait } : {}),
+    });
     this.sessions.pin(id);
     this.enforceCap();
   }
@@ -204,6 +225,17 @@ class FleetMailbox {
     return this.snapshot(id);
   }
 
+  private rememberLiveWaitStatuses(): void {
+    for (const [id, overlay] of this.records) {
+      const wait = this.sessionWaitStatus(id);
+      if (wait !== undefined) overlay.lastWaitStatus = wait;
+    }
+  }
+
+  private waitStatusFromEvicted(id: string): WaitJSONStatus | undefined {
+    return waitStatusFromVerbLifecycle(this.sessions.evictedLifecycle(id));
+  }
+
   private sessionWaitStatus(id: string): WaitJSONStatus | undefined {
     const session = this.sessions?.get(id);
     if (session === undefined) return undefined;
@@ -213,7 +245,16 @@ class FleetMailbox {
   private projectedStatus(id: string, overlay: FleetOverlay): WaitJSONStatus {
     if (overlay.frozenStatus !== undefined) return overlay.frozenStatus;
     if (overlay.forceInterrupted === true) return "interrupted";
-    return this.sessionWaitStatus(id) ?? "interrupted";
+    const live = this.sessionWaitStatus(id);
+    if (live !== undefined) {
+      overlay.lastWaitStatus = live;
+      return live;
+    }
+    const last = overlay.lastWaitStatus;
+    if (last !== undefined && last !== "running") return last;
+    const evicted = this.waitStatusFromEvicted(id);
+    if (evicted !== undefined && evicted !== "running") return evicted;
+    return "interrupted";
   }
 
   snapshot(id: string): FleetRecord {
@@ -229,7 +270,7 @@ class FleetMailbox {
     ) {
       overlay.tombstoned = true;
       overlay.hint = RECOVERY_HINT;
-      overlay.frozenStatus = "interrupted";
+      overlay.frozenStatus = this.projectedStatus(id, overlay);
       if (overlay.pinHeld === true) {
         overlay.pinHeld = false;
         this.sessions.unpin(id);

src/subagent/session-store.ts

@@ -158,6 +158,12 @@ export interface SubAgentSessionStoreOptions {
 export interface SubAgentSessionStore {
   list(): readonly SubAgentSession[];
   get(id: string): SubAgentSession | undefined;
+  /**
+   * Verb lifecycle of a session dropped by pruneRetained, if a tombstone remains.
+   * `get` does not surface these — they exist so wait/resume can recover a
+   * terminal status instead of treating the id as never-seen.
+   */
+  evictedLifecycle(id: string): AgentLifecycleStatus | undefined;
   // Running + recent completed, newest first — surface for the Agents strip.
   listForStrip(): readonly SubAgentSession[];
   start(input: StartSessionInput): SubAgentSession;
@@ -738,6 +744,10 @@ export function createSubAgentSessionStore(
       return session === undefined ? undefined : snapshotOf(session);
     },
 
+    evictedLifecycle(id: string): AgentLifecycleStatus | undefined {
+      return evicted.get(id)?.lifecycleStatus;
+    },
+
     listForStrip(): readonly SubAgentSession[] {
       return [...sessions.values()].map(snapshotOf).sort((a, b) => {
         // Running first, then by startedAt descending.