Keep follow-up turns live after interrupt instead of re-stamping linger

send_input interrupt and followup_task clear finishedAt and set lifecycle
to running so the agents strip stays live through the new turn. Settling
an interrupted run no longer re-calls interruptOne, which would overwrite
a live follow-up's linger stamp.

Author: TheGreatAxios

src/subagent/agent-fleet.test.ts

@@ -15,6 +15,8 @@ import {
 } from "./lifecycle-tools.js";
 import { createSubAgentSessionStore } from "./session-store.js";
 import { createPermissionGate } from "../permission/gate.js";
+import { agentLaneIsLive, fleetProgress } from "../tui/agent-progress.js";
+import { AGENTS_PANEL_LINGER_MS, formatAgentsPanel } from "../tui/chrome-state.js";
 import { forcedStopReport } from "./stop-policy.js";
 import type { RunSubAgentParams, RunSubAgentResult } from "./types.js";
 
@@ -922,7 +924,7 @@ describe("list_agents", () => {
     gate.resolve({ report: "done" });
   });
 
-  test("after interrupt_agent wait-status is not running", async () => {
+  test("interrupt_agent leaves the strip after the linger window", async () => {
     const gate = deferred<RunSubAgentResult>();
     const deps = makeDeps(async (params) => {
       params.onAgentReady?.({
@@ -934,10 +936,6 @@ describe("list_agents", () => {
       return gate.promise;
     });
     const spawn = createSpawnAgentTool(deps);
-    const list = createListAgentsTool({
-      sessions: deps.sessions,
-      fleetRecords: deps.fleetRecords,
-    });
     const interrupt = createInterruptAgentTool({
       sessions: deps.sessions,
       fleetRecords: deps.fleetRecords,
@@ -951,19 +949,20 @@ describe("list_agents", () => {
     await new Promise((resolve) => setTimeout(resolve, 20));
     if (interrupt.kind !== "full") throw new Error("expected full tool");
     await interrupt.handler(
-      { id: "int-list", name: "interrupt_agent", arguments: { target: id } },
-      new AbortController().signal,
-    );
-    if (list.kind !== "full") throw new Error("expected full tool");
-    const raw = await list.handler(
-      { id: "list-int", name: "list_agents", arguments: {} },
+      { id: "int-strip", name: "interrupt_agent", arguments: { target: id } },
       new AbortController().signal,
     );
-    const content = typeof raw.content === "string" ? raw.content : JSON.stringify(raw.content);
-    const parsed = JSON.parse(content) as { agents: { agent_id: string; status: string }[] };
-    expect(parsed.agents).toHaveLength(1);
-    expect(parsed.agents[0]!.agent_id).toBe(id);
-    expect(parsed.agents[0]!.status).not.toBe("running");
+    const agents = deps.sessions.list();
+    const session = agents[0]!;
+    expect(session.status).toBe("running");
+    expect(session.lifecycleStatus).toBe("interrupted");
+    expect(agentLaneIsLive(session)).toBe(false);
+    const finishedAt = session.finishedAt!;
+    expect(finishedAt).toBeNumber();
+    const inside = finishedAt + 1_000;
+    expect(fleetProgress(agents, inside).running).toBe(0);
+    expect(formatAgentsPanel(agents, undefined, inside)?.[0]?.status).toBe("interrupted");
+    expect(formatAgentsPanel(agents, undefined, finishedAt + AGENTS_PANEL_LINGER_MS)).toBeNull();
     gate.resolve({ report: "done", interrupted: true });
   });
 });

src/subagent/agent-fleet.ts

@@ -546,14 +546,15 @@ export function createSpawnAgentTool(deps: AgentFleetDeps): AgentTool {
       const startedAt = Date.now();
       let settlement: Readonly<SubAgentRunSettlement> | undefined;
       let endFinalized = false;
+      let runInterrupted = false;
       const finalizeEnd = (setupFailed = false): void => {
         if (endFinalized) return;
         endFinalized = true;
         const terminalSession = deps.sessions.get(session.id);
         const status =
           terminalSession?.status === "cancelled"
             ? "cancelled"
-            : terminalSession?.lifecycleStatus === "interrupted"
+            : runInterrupted || terminalSession?.lifecycleStatus === "interrupted"
               ? "interrupted"
               : (terminalSession?.status ?? "completed");
         captureSubagentEnd(telemetry, {
@@ -731,14 +732,16 @@ export function createSpawnAgentTool(deps: AgentFleetDeps): AgentTool {
       deps
         .run(params)
         .then((result) => {
-          // interrupt_agent already flipped this session to "interrupted"
-          // synchronously (session-store.interruptOne) — do not let the
-          // settling promise's normal bookkeeping overwrite that with a
-          // "completed" status. Still terminalize fleetRecords so a waiter
-          // that never saw interrupt_agent (or raced it) cannot hang.
+          // interrupt_agent / send_input already flipped this session
+          // synchronously (session-store.interruptOne / sendInputOne) — do not
+          // let the settling promise's normal bookkeeping overwrite that with
+          // a "completed" status, and do not re-stamp the interrupt either: a
+          // follow-up turn may already be live on this lane. Still terminalize
+          // fleetRecords so a waiter that never saw interrupt_agent (or raced
+          // it) cannot hang.
           if (result.interrupted === true) {
             keepWorktreeAlive = true;
-            deps.sessions.interruptOne(session.id);
+            runInterrupted = true;
             deps.fleetRecords.interrupt(session.id, result.report);
             return;
           }

src/subagent/lifecycle-tools.test.ts

@@ -330,7 +330,8 @@ describe("send_input", () => {
     expect(result).toEqual({ agent_id: worker.id, status: "interrupted" });
     expect(interrupted).toBe(true);
     expect(followupStarted).toBe(true);
-    expect(sessions.get(worker.id)?.lifecycleStatus).toBe("interrupted");
+    expect(sessions.get(worker.id)?.lifecycleStatus).toBe("running");
+    expect(sessions.get(worker.id)?.finishedAt).toBeUndefined();
 
     const missing = sessions.start({
       description: "no-followup",

src/subagent/session-store.test.ts

@@ -2,6 +2,8 @@ import { describe, expect, test } from "bun:test";
 
 import { createSubAgentSessionStore } from "./session-store.js";
 import { forcedStopReport } from "./stop-policy.js";
+import { agentLaneIsLive, fleetProgress } from "../tui/agent-progress.js";
+import { formatAgentsPanel } from "../tui/chrome-state.js";
 
 import type { ReactorEmittedEvent } from "@intx/inference";
 
@@ -553,8 +555,9 @@ describe("interrupt stamps finishedAt once", () => {
     expect(store.get(session.id)?.outstandingTools).toHaveLength(1);
   });
 
-  test("sendInputOne interrupt sets finishedAt once and keeps tools", () => {
+  test("sendInputOne interrupt starts a live follow-up turn and keeps tools", async () => {
     let t = 1000;
+    let finish: (reply: string) => void = () => {};
     const store = createSubAgentSessionStore({
       now: () => t,
       createId: () => "s-send",
@@ -568,19 +571,82 @@ describe("interrupt stamps finishedAt once", () => {
     store.markRunning(session.id);
     store.appendEvent(session.id, startCall(1, "call-1", "run_shell"));
     store.registerInterrupt(session.id, () => {});
-    store.registerFollowup(session.id, async () => "later");
+    store.registerFollowup(
+      session.id,
+      () =>
+        new Promise<string>((resolve) => {
+          finish = resolve;
+        }),
+    );
 
     t = 2500;
     const outcome = store.sendInputOne(session.id, "stop that", { interrupt: true });
     expect(outcome).toEqual({ ok: true, status: "interrupted" });
     const after = store.get(session.id);
     expect(after?.status).toBe("running");
-    expect(after?.lifecycleStatus).toBe("interrupted");
-    expect(after?.finishedAt).toBe(2500);
+    expect(after?.lifecycleStatus).toBe("running");
+    expect(after?.finishedAt).toBeUndefined();
     expect(after?.outstandingTools).toHaveLength(1);
 
     t = 4000;
     expect(store.interruptOne(session.id).ok).toBe(true);
-    expect(store.get(session.id)?.finishedAt).toBe(2500);
+    expect(store.get(session.id)?.finishedAt).toBe(4000);
+
+    t = 5000;
+    finish("later");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(store.get(session.id)?.status).toBe("done");
+    expect(store.get(session.id)?.lifecycleStatus).toBe("completed");
+    expect(store.get(session.id)?.finishedAt).toBe(5000);
+  });
+
+  test("a follow-up turn keeps the lane live past the linger window until it completes", async () => {
+    let t = 1000;
+    let finish: (reply: string) => void = () => {};
+    const store = createSubAgentSessionStore({
+      now: () => t,
+      createId: () => "s-followup",
+    });
+    const session = store.start({
+      description: "looping",
+      agentId: "explorer",
+      brief: "b",
+      retained: true,
+    });
+    store.markRunning(session.id);
+    store.registerInterrupt(session.id, () => {});
+    store.registerFollowup(
+      session.id,
+      () =>
+        new Promise<string>((resolve) => {
+          finish = resolve;
+        }),
+    );
+
+    t = 2000;
+    expect(store.interruptOne(session.id).ok).toBe(true);
+    expect(store.get(session.id)?.finishedAt).toBe(2000);
+
+    t = 3000;
+    const pending = store.followupOne(session.id, "keep going");
+
+    t = 11_000;
+    store.appendEvent(session.id, startCall(1, "call-1", "run_shell"));
+    const live = store.list();
+    expect(live[0]?.lifecycleStatus).toBe("running");
+    expect(live[0]?.finishedAt).toBeUndefined();
+    expect(agentLaneIsLive(live[0]!)).toBe(true);
+    expect(formatAgentsPanel(live, undefined, t)?.[0]?.status).toBe("running");
+    expect(fleetProgress(live, t).running).toBe(1);
+
+    t = 12_000;
+    finish("done");
+    expect(await pending).toEqual({ ok: true, reply: "done" });
+    const terminal = store.list();
+    expect(terminal[0]?.status).toBe("done");
+    expect(terminal[0]?.lifecycleStatus).toBe("completed");
+    expect(terminal[0]?.finishedAt).toBe(12_000);
+    expect(agentLaneIsLive(terminal[0]!)).toBe(false);
+    expect(fleetProgress(terminal, t).running).toBe(0);
   });
 });

src/subagent/session-store.ts

@@ -597,6 +597,23 @@ export function createSubAgentSessionStore(
     notify();
   };
 
+  // A follow-up turn takes the lane back over: the worker is live again, so
+  // the interrupt's linger stamp must not outlive the new turn. Completion
+  // re-stamps through the caller's own mutate; a rejected turn restores the
+  // addressable state it started from so followup_task can retry.
+  const beginFollowupTurn = (id: string): void => {
+    mutate(id, (s) => {
+      s.lifecycleStatus = "running";
+      delete s.finishedAt;
+    });
+  };
+  const endFollowupTurn = (id: string, lifecycleStatus: AgentLifecycleStatus): void => {
+    mutate(id, (s) => {
+      s.lifecycleStatus = lifecycleStatus;
+      s.finishedAt = now();
+    });
+  };
+
   return {
     list(): readonly SubAgentSession[] {
       return [...sessions.values()].map(snapshotOf);
@@ -975,10 +992,7 @@ export function createSubAgentSessionStore(
           return { ok: false, status: session.lifecycleStatus };
         }
         interrupt();
-        mutate(id, (s) => {
-          s.lifecycleStatus = "interrupted";
-          s.finishedAt = s.finishedAt ?? now();
-        });
+        beginFollowupTurn(id);
         void followup(message)
           .then((reply) => {
             const still = sessions.get(id);
@@ -994,6 +1008,7 @@ export function createSubAgentSessionStore(
             pruneRetained();
           })
           .catch((err: unknown) => {
+            endFollowupTurn(id, "interrupted");
             log.error("send_input followup failed for {id}: {error}", {
               id,
               error: err instanceof Error ? err.message : String(err),
@@ -1046,7 +1061,15 @@ export function createSubAgentSessionStore(
       }
       const followup = followupHandles.get(id);
       if (followup === undefined) return { ok: false, status: session.lifecycleStatus };
-      const reply = await followup(message);
+      const priorLifecycle = session.lifecycleStatus;
+      beginFollowupTurn(id);
+      let reply: string;
+      try {
+        reply = await followup(message);
+      } catch (err) {
+        endFollowupTurn(id, priorLifecycle);
+        throw err;
+      }
       mutate(id, (s) => {
         s.status = "done";
         s.lifecycleStatus = "completed";

src/subagent/spawn-agent-worktree.test.ts

@@ -347,6 +347,8 @@ describe("spawn_agent worktree isolation", () => {
     const content = typeof spawned.content === "string" ? spawned.content : "";
     const agentId = (JSON.parse(content) as { agent_id: string }).agent_id;
 
+    await waitFor(() => sessions.get(agentId)?.lifecycleStatus === "running");
+    expect(sessions.interruptOne(agentId).ok).toBe(true);
     settle.resolve({
       report: "## Summary\nStopped.\n## Findings\npartial\n## Blockers\ninterrupted\n## Paths\n",
       stopReason: "cancelled",