Keep wait live after interrupt-with-follow-up

An interrupt overlay freezes wait as interrupted, so a queued follow-up
never surfaces even after it completes. Mark the follow-up lane instead
and leave wait running until that turn settles.

Author: TheGreatAxios

src/subagent/agent-fleet.test.ts

@@ -16,6 +16,7 @@ import { isLiveWaitStatus } from "./lifecycle.js";
 import {
   createInterruptAgentTool,
   createCloseAgentTool,
+  createResumeAgentTool,
   createSendInputTool,
 } from "./lifecycle-tools.js";
 import { createSubAgentSessionStore } from "./session-store.js";
@@ -984,7 +985,7 @@ describe("interrupt_agent unblocks wait_agents", () => {
     gate.resolve({ report: "done" });
   });
 
-  test("send_input interrupt:true unblocks wait_agents as interrupted", async () => {
+  test("send_input interrupt:true keeps wait_agents live until the followup completes", async () => {
     const gate = deferred<RunSubAgentResult>();
     const followupGate = deferred<string>();
     const deps = makeDeps(async (params) => {
@@ -1013,11 +1014,92 @@ describe("interrupt_agent unblocks wait_agents", () => {
     const id = spawned.agent_id as string;
     const waiting = callTool(wait, { targets: [id], timeout_ms: 5000 });
     await callTool(sendInput, { target: id, message: "stop that", interrupt: true });
+    followupGate.resolve("later");
+    gate.resolve({ report: "original interrupted", interrupted: true } as RunSubAgentResult);
     const waited = await waiting;
     expect(waited.timed_out).toBe(false);
-    const results = waited.results as { status: string }[];
-    expect(results[0]!.status).toBe("interrupted");
-    followupGate.resolve("later");
+    const results = waited.results as { status: string; report?: string }[];
+    expect(results[0]!.status).toBe("done");
+    expect(results[0]!.report).toBe("later");
+  });
+
+  test("CL-7331: send_input interrupt keeps wait live until the queued followup completes", async () => {
+    const gate = deferred<RunSubAgentResult>();
+    const followupGate = deferred<string>();
+    const deps = makeDeps(async (params) => {
+      params.onAgentReady?.({
+        close: async () => {},
+        interrupt: () => {},
+        followup: async () => followupGate.promise,
+        deliver: () => {},
+      });
+      return gate.promise;
+    });
+    const spawn = createSpawnAgentTool(deps);
+    const wait = createWaitAgentsTool({
+      sessions: deps.sessions,
+      fleetRecords: deps.fleetRecords,
+    });
+    const list = createListAgentsTool({
+      sessions: deps.sessions,
+      fleetRecords: deps.fleetRecords,
+    });
+    const sendInput = createSendInputTool({
+      sessions: deps.sessions,
+      fleetRecords: deps.fleetRecords,
+    });
+    const resume = createResumeAgentTool({
+      sessions: deps.sessions,
+      fleetRecords: deps.fleetRecords,
+    });
+    const spawned = await callTool(spawn, {
+      description: "looping",
+      prompt: "do it",
+      intent: "explore",
+    });
+    const id = spawned.agent_id as string;
+
+    const sent = await callTool(sendInput, {
+      target: id,
+      message: "return a concise report",
+      interrupt: true,
+    });
+    expect(sent.status).toBe("interrupted");
+
+    // The queued followup is still running: wait must stay live (not an
+    // immediate terminal interrupted), and list must agree with lifecycle.
+    const pending = await callTool(wait, { targets: [id], timeout_ms: 50 });
+    expect(pending.timed_out).toBe(true);
+    expect((pending.results as { status: string }[])[0]!.status).toBe("running");
+
+    const listed = await callTool(list, {});
+    const entry = (listed.agents as { agent_id: string; status: string; lifecycle: string }[]).find(
+      (a) => a.agent_id === id,
+    );
+    expect(entry?.status).toBe("running");
+    expect(entry?.lifecycle).toBe("running");
+
+    // A resume while the followup is in flight must agree with wait/list.
+    if (resume.kind !== "full") throw new Error("expected full tool");
+    const resumed = await resume.handler(
+      {
+        id: "resume-while-followup",
+        name: "resume_agent",
+        arguments: { target: id, message: "x" },
+      },
+      new AbortController().signal,
+    );
+    expect(resumed.isError).toBe(true);
+    expect(String(resumed.content)).toContain("status: running");
+
+    // When the queued followup finishes, its report must surface via wait.
+    followupGate.resolve("followup report");
+    gate.resolve({ report: "original interrupted", interrupted: true } as RunSubAgentResult);
+    const done = await callTool(wait, { targets: [id], timeout_ms: 5000 });
+    expect(done.timed_out).toBe(false);
+    const doneResults = done.results as { status: string; report?: string }[];
+    expect(doneResults[0]!.status).toBe("done");
+    expect(doneResults[0]!.report).toBe("followup report");
   });
 
   test("soft-interrupt wait path collects so omitted re-wait does not re-deliver", async () => {

src/subagent/agent-fleet.ts

@@ -118,8 +118,11 @@ interface FleetRecord {
 interface FleetOverlay {
   collected?: boolean;
   pinHeld?: boolean;
-  /** send_input interrupt:true / close_agent — wait interrupted while session may still be running. */
+  /** interrupt_agent / close_agent — wait interrupted while session may still be running. */
   forceInterrupted?: boolean;
+  /** A send_input interrupt:true followup owns this lane; suppresses any
+   * terminal overlay so wait stays live until the followup settles. */
+  followupLive?: boolean;
   /** Admission overlay: wait JSON `queued` while run() has not been admitted. */
   forceQueued?: boolean;
   /** Frozen wait status after collect. Later session completed must not resurrect this mailbox. */
@@ -203,8 +206,8 @@ class FleetMailbox {
 
   /**
    * Overlay wait-status override so wait unblocks while the session may still
-   * be running (send_input interrupt:true followup, close_agent teardown).
-   * No-op on an already-collected mailbox — frozen status stays interrupted.
+   * be running (interrupt_agent teardown, close_agent teardown). No-op on an
+   * already-collected mailbox — frozen status stays interrupted.
    */
   interrupt(id: string, _report?: string): void {
     const existing = this.records.get(id);
@@ -220,18 +223,47 @@ class FleetMailbox {
   }
 
   /**
-   * send_input interrupt:true followup finished. Clear an uncollected
-   * interrupted overlay so wait projects session completed → done. No-op if
-   * wait_agents already collected the interrupt.
+   * CL-7331: mark that a send_input interrupt:true followup owns this lane.
+   * Suppresses any interrupt overlay so wait stays live (running/queued)
+   * until the followup settles, and tells the spawn settlement to swallow
+   * the original run's interrupted result instead of attaching salvage over
+   * the live followup. No-op on an unknown id; safe to call on a collected
+   * mailbox (frozen status still wins for projection, but the settlement
+   * swallow still applies).
    */
-  completeAfterInterrupt(id: string, _report?: string): void {
+  noteFollowup(id: string): void {
     const existing = this.records.get(id);
-    if (existing === undefined || existing.collected === true) return;
-    if (existing.forceInterrupted !== true) return;
+    if (existing === undefined) return;
+    existing.followupLive = true;
     delete existing.forceInterrupted;
     this.sessions?.wake();
   }
 
+  /** True while a send_input interrupt:true followup owns this lane. */
+  hasLiveFollowup(id: string): boolean {
+    return this.records.get(id)?.followupLive === true;
+  }
+
+  /**
+   * send_input interrupt:true followup finished. Clear the followup lane flag
+   * (and any uncollected interrupted overlay) so wait projects session
+   * completed → done. No-op if wait_agents already collected the interrupt.
+   */
+  completeAfterInterrupt(id: string, _report?: string): void {
+    const existing = this.records.get(id);
+    if (existing === undefined || existing.collected === true) return;
+    let changed = false;
+    if (existing.followupLive === true) {
+      delete existing.followupLive;
+      changed = true;
+    }
+    if (existing.forceInterrupted === true) {
+      delete existing.forceInterrupted;
+      changed = true;
+    }
+    if (changed) this.sessions?.wake();
+  }
+
   ids(): string[] {
     return [...this.records.keys()];
   }
@@ -1192,11 +1224,13 @@ export function createSpawnAgentTool(deps: AgentFleetDeps): AgentTool {
               if (result.interrupted === true) {
                 keepWorktreeAlive = true;
                 runInterrupted = true;
-                const now = deps.sessions.get(session.id);
-                const overlay = deps.fleetRecords.peek(session.id);
-                const followupLive =
-                  now?.lifecycle.state === "running" && overlay?.status === "interrupted";
-                if (!followupLive) {
+                // CL-7331: a followup started via send_input interrupt owns
+                // this lane now — the settling original turn must not attach
+                // salvage over it. The mailbox flag (set by send_input, not
+                // by interrupt_agent or a bare settle) identifies that lane;
+                // lifecycle alone cannot, since a never-started run and a
+                // queued followup both read pending_init.
+                if (!deps.fleetRecords.hasLiveFollowup(session.id)) {
                   deps.sessions.attachReport(session.id, result.report);
                 }
                 return;

src/subagent/lifecycle-tools.ts

@@ -331,8 +331,9 @@ export const sendInputToolDefinition: ToolDefinition = {
     "worker has a pending ask_director, the message resolves that question (it does not deliver a " +
     "steer inbound). Otherwise deliver `message` into the live session and return immediately " +
     "without awaiting a reply and without completing wait_agents. " +
-    "With interrupt:true: stop the current turn (same wait-mailbox flip as interrupt_agent) " +
-    "then queue `message` as the next-turn followup without awaiting that reply. Fails on a " +
+    "With interrupt:true: stop the current turn then queue `message` as the next-turn followup " +
+    "without awaiting that reply — wait_agents stays live (running/queued) and collects the " +
+    "followup reply when it finishes. Fails on a " +
     "session that is not currently running an active turn, or when the message is empty / oversize. Nested " +
     "orchestrators may only target their own descendants.",
   inputSchema: {
@@ -393,7 +394,16 @@ export function createSendInputTool(deps: LifecycleToolDeps): AgentTool {
           `Error: cannot send_input to "${target}" (status: ${outcome.status}).`,
         );
       }
-      if (interrupt) deps.fleetRecords?.interrupt(target);
+      // CL-7331: an interrupt-with-followup is transitional, not terminal.
+      // interrupt_agent/close_agent flip the wait mailbox so an in-flight
+      // wait_agents unblocks as interrupted; a queued followup must instead
+      // stay wait-live (running/queued) so the followup reply surfaces via
+      // wait_agents instead of freezing as an already-collected interrupt.
+      if (interrupt && deps.fleetRecords !== undefined) {
+        deps.fleetRecords.noteFollowup(target);
+        const after = deps.sessions.get(target);
+        if (after?.lifecycle.state === "pending_init") deps.fleetRecords.markQueued(target);
+      }
       return lifecycleResult(call.id, JSON.stringify({ agent_id: target, status: outcome.status }));
     },
   });