Drop interrupted workers from live agents

Author: TheGreatAxios

CHANGELOG.md

@@ -13,6 +13,11 @@ parallel copies under `docs/` or `scripts/notes/`. At cut time: rename
 
 ## [Unreleased]
 
+### Fixed
+
+- Interrupted workers linger on the agents strip for 4s then drop, instead of
+  staying in the live list while leftover tools finish.
+
 ## [0.3.7] - 2026-08-27
 
 ### Fixed

docs/TUI.md

@@ -220,9 +220,10 @@ status / current tool) — Amp/Codex-style lanes without a FLEET header board:
 
 `formatChromeZones` → `formatAgentsPanel` owns that paint. Geometry stays
 stack-only (`layoutMode: "stack"`, `railWidth: 0`); the zone max is
-`AGENTS_PANEL_MAX_VISIBLE + 1` (lanes plus a trailing `+N more`). Terminal
-lanes (done / failed / cancelled) linger for `AGENTS_PANEL_LINGER_MS` (4s)
-after `finishedAt`, then drop. Product-host sticky poll uses
+`AGENTS_PANEL_MAX_VISIBLE + 1` (lanes plus a trailing `+N more`). Finished
+lanes (done / failed / cancelled / interrupted) linger for
+`AGENTS_PANEL_LINGER_MS` (4s) after `finishedAt`, then drop. Product-host sticky
+poll uses
 `agentsChromeNeedsSticky` so clocks and linger stay fresh; while sticky is
 needed it **does not** call `bridge.syncAgentProgress` — chrome owns the live
 clocks.

src/subagent/agent-fleet.test.ts

@@ -921,6 +921,51 @@ describe("list_agents", () => {
     expect(parsed.agents[0]!.lifecycle).toBe("pending_init");
     gate.resolve({ report: "done" });
   });
+
+  test("after interrupt_agent wait-status is not running", async () => {
+    const gate = deferred<RunSubAgentResult>();
+    const deps = makeDeps(async (params) => {
+      params.onAgentReady?.({
+        close: async () => {},
+        interrupt: () => {},
+        followup: async () => "",
+        deliver: () => {},
+      });
+      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,
+    });
+    const spawned = await callTool(spawn, {
+      description: "looping",
+      prompt: "do it",
+      intent: "explore",
+    });
+    const id = spawned.agent_id as string;
+    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: {} },
+      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");
+    gate.resolve({ report: "done", interrupted: true });
+  });
 });
 
 describe("spawn_agent parity with task", () => {

src/subagent/session-store.test.ts

@@ -519,3 +519,68 @@ describe("CL-6943 reusable worker sessions", () => {
     expect(store.get(retained.id)).toBeUndefined();
   });
 });
+
+describe("interrupt stamps finishedAt once", () => {
+  test("interruptOne sets finishedAt, keeps status running, and preserves tools", () => {
+    let t = 1000;
+    const store = createSubAgentSessionStore({
+      now: () => t,
+      createId: () => "s-int",
+    });
+    const session = store.start({
+      description: "looping",
+      agentId: "explorer",
+      brief: "b",
+      retained: true,
+    });
+    store.markRunning(session.id);
+    store.appendEvent(session.id, startCall(1, "call-1", "run_shell"));
+    store.registerInterrupt(session.id, () => {});
+
+    t = 2000;
+    expect(store.interruptOne(session.id).ok).toBe(true);
+    const after = store.get(session.id);
+    expect(after?.status).toBe("running");
+    expect(after?.lifecycleStatus).toBe("interrupted");
+    expect(after?.finishedAt).toBe(2000);
+    expect(after?.outstandingTools).toHaveLength(1);
+    expect(after?.currentToolName).toBe("run_shell");
+
+    t = 3500;
+    expect(store.interruptOne(session.id).ok).toBe(true);
+    expect(store.get(session.id)?.finishedAt).toBe(2000);
+    expect(store.get(session.id)?.status).toBe("running");
+    expect(store.get(session.id)?.outstandingTools).toHaveLength(1);
+  });
+
+  test("sendInputOne interrupt sets finishedAt once and keeps tools", () => {
+    let t = 1000;
+    const store = createSubAgentSessionStore({
+      now: () => t,
+      createId: () => "s-send",
+    });
+    const session = store.start({
+      description: "looping",
+      agentId: "explorer",
+      brief: "b",
+      retained: true,
+    });
+    store.markRunning(session.id);
+    store.appendEvent(session.id, startCall(1, "call-1", "run_shell"));
+    store.registerInterrupt(session.id, () => {});
+    store.registerFollowup(session.id, async () => "later");
+
+    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?.outstandingTools).toHaveLength(1);
+
+    t = 4000;
+    expect(store.interruptOne(session.id).ok).toBe(true);
+    expect(store.get(session.id)?.finishedAt).toBe(2500);
+  });
+});

src/subagent/session-store.ts

@@ -79,6 +79,9 @@ export interface SubAgentSession {
   // start/end, a status change). Distinct from startedAt so the strip can
   // tell a worker mid-turn from one that has gone silent.
   lastActivityAt: number;
+  // Clock the live turn ended (complete/fail/cancel, and interrupt while TUI
+  // status may still be "running"). Drives chrome linger; leftover tools may
+  // still be outstanding after this stamp.
   finishedAt?: number;
   report?: string;
   error?: string;
@@ -974,6 +977,7 @@ export function createSubAgentSessionStore(
         interrupt();
         mutate(id, (s) => {
           s.lifecycleStatus = "interrupted";
+          s.finishedAt = s.finishedAt ?? now();
         });
         void followup(message)
           .then((reply) => {
@@ -1014,6 +1018,7 @@ export function createSubAgentSessionStore(
       interrupt();
       mutate(id, (s) => {
         s.lifecycleStatus = "interrupted";
+        s.finishedAt = s.finishedAt ?? now();
       });
       pruneRetained();
       return { ok: true };

src/tui/agent-progress.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import {
+  agentLaneIsLive,
   agentProgress,
   clockLabel,
   fleetLabel,
@@ -218,6 +219,32 @@ describe("fleetProgress", () => {
       stalled: 0,
     });
   });
+
+  test("does not count interrupted running leftover tools", () => {
+    const fleet = fleetProgress(
+      [
+        lane({ lastActivityAt: 59_000 }),
+        lane({
+          lifecycleStatus: "interrupted",
+          currentToolName: "run_shell",
+          currentToolStartedAt: 0,
+          lastActivityAt: 0,
+        }),
+      ],
+      60_000,
+      30_000,
+    );
+    expect(fleet).toEqual({ running: 1, working: 1, inTool: 0, stalled: 0 });
+  });
+});
+
+describe("agentLaneIsLive", () => {
+  test("running without lifecycleStatus stays live; interrupted is not", () => {
+    expect(agentLaneIsLive({ status: "running" })).toBe(true);
+    expect(agentLaneIsLive({ status: "running", lifecycleStatus: "running" })).toBe(true);
+    expect(agentLaneIsLive({ status: "running", lifecycleStatus: "interrupted" })).toBe(false);
+    expect(agentLaneIsLive({ status: "done" })).toBe(false);
+  });
 });
 
 describe("fleetLabel", () => {

src/tui/agent-progress.ts

@@ -120,6 +120,18 @@ export function laneState(
   return "stalled";
 }
 
+/**
+ * Live on the agents strip: TUI status is still "running" and the reusable
+ * lifecycle has not been interrupted. Missing lifecycleStatus stays live.
+ * Interrupted leftovers may still have in-flight tools; they are not live lanes.
+ */
+export function agentLaneIsLive(session: {
+  readonly status: AgentProgressSession["status"];
+  readonly lifecycleStatus?: AgentProgressSession["lifecycleStatus"] | undefined;
+}): boolean {
+  return session.status === "running" && session.lifecycleStatus !== "interrupted";
+}
+
 /**
  * Progress for a running session's pending row, or null once it has finished —
  * a terminal session resolves its row through the tool-result path instead.
@@ -200,7 +212,7 @@ export function fleetProgress(
   let inTool = 0;
   let stalled = 0;
   for (const session of sessions) {
-    if (session.status !== "running") continue;
+    if (!agentLaneIsLive(session)) continue;
     switch (laneState(session, nowMs, stallMs)) {
       case "working":
         working += 1;

src/tui/chrome-state.test.ts

@@ -173,6 +173,51 @@ describe("agentsChromeNeedsSticky / linger", () => {
     expect(agentsChromeNeedsSticky(undefined, NOW)).toBe(false);
     expect(agentsChromeNeedsSticky([], NOW)).toBe(false);
   });
+
+  test("interrupted running inside linger is sticky with interrupted tail, not cancelled or cream-live", () => {
+    const session = {
+      agentId: "a",
+      description: "looping",
+      status: "running" as const,
+      lifecycleStatus: "interrupted" as const,
+      currentToolName: "run_shell",
+      currentToolPreview: "bun test",
+      currentToolStartedAt: NOW - 2_000,
+      startedAt: NOW - 10_000,
+      lastActivityAt: NOW - 2_000,
+      finishedAt: NOW - 1_000,
+    };
+    expect(agentIsLingering(session, NOW)).toBe(true);
+    expect(agentsChromeNeedsSticky([session], NOW)).toBe(true);
+    const rows = formatAgentsPanel([session], undefined, NOW);
+    expect(rows).toEqual([
+      {
+        label: "● a  looping",
+        tail: " · interrupted · bun test still running",
+        stalled: false,
+        kind: "lane",
+        status: "interrupted",
+      },
+    ]);
+  });
+
+  test("interrupted running past linger drops even though status stays running", () => {
+    const session = {
+      agentId: "a",
+      description: "looping",
+      status: "running" as const,
+      lifecycleStatus: "interrupted" as const,
+      currentToolName: "run_shell",
+      currentToolPreview: "bun test",
+      currentToolStartedAt: NOW - 2_000,
+      startedAt: NOW - 10_000,
+      lastActivityAt: NOW - 2_000,
+      finishedAt: NOW - AGENTS_PANEL_LINGER_MS,
+    };
+    expect(agentIsLingering(session, NOW)).toBe(false);
+    expect(agentsChromeNeedsSticky([session], NOW)).toBe(false);
+    expect(formatAgentsPanel([session], undefined, NOW)).toBeNull();
+  });
 });
 
 describe("formatTasksPanel", () => {
@@ -325,6 +370,69 @@ describe("formatAgentsPanel", () => {
     ).toBeNull();
   });
 
+  test("interrupted linger ranks with terminals, newest finishedAt first", () => {
+    const rows = formatAgentsPanel(
+      [
+        {
+          agentId: "live",
+          description: "still going",
+          status: "running",
+          currentToolStartedAt: null,
+          startedAt: NOW - 1_000,
+          lastActivityAt: NOW,
+        },
+        {
+          agentId: "done",
+          description: "finished",
+          status: "done",
+          currentToolStartedAt: null,
+          finishedAt: NOW - 2_000,
+        },
+        {
+          agentId: "stopped",
+          description: "cut short",
+          status: "running",
+          lifecycleStatus: "interrupted",
+          currentToolStartedAt: null,
+          startedAt: NOW - 5_000,
+          lastActivityAt: NOW - 500,
+          finishedAt: NOW - 500,
+        },
+      ],
+      undefined,
+      NOW,
+    );
+    expect(rows?.map((r) => r.status)).toEqual(["running", "interrupted", "done"]);
+    expect(rows?.[1]?.tail).toBe(" · interrupted");
+  });
+
+  test("cancelled linger with lifecycle interrupted paints cancelled, not interrupted", () => {
+    const session = {
+      agentId: "a",
+      description: "cut short",
+      status: "cancelled" as const,
+      lifecycleStatus: "interrupted" as const,
+      currentToolName: "run_shell",
+      currentToolPreview: "bun test",
+      currentToolStartedAt: NOW - 2_000,
+      startedAt: NOW - 10_000,
+      lastActivityAt: NOW - 2_000,
+      finishedAt: NOW - 1_000,
+    };
+    expect(agentIsLingering(session, NOW)).toBe(true);
+    expect(agentsChromeNeedsSticky([session], NOW)).toBe(true);
+    const rows = formatAgentsPanel([session], undefined, NOW);
+    expect(rows).toEqual([
+      {
+        label: "● a  cut short",
+        tail: " · cancelled",
+        stalled: false,
+        kind: "lane",
+        status: "cancelled",
+      },
+    ]);
+  });
+
   test("a stalled lane uses ! marker and reports silence via the clock", () => {
     const rows = formatAgentsPanel(
       [