Restore strip status when a followup turn is rejected

A rejected resume_agent followup left status running, so interrupt_agent succeeded with no turn in flight. Restore done or interrupted linger, and keep interruptOne's stamp if the followup then aborts. Shipped 0.3.0 and 0.3.1 notes keep followup_task.

Author: TheGreatAxios

CHANGELOG.md

@@ -202,12 +202,12 @@ parallel copies under `docs/` or `scripts/notes/`. At cut time: rename
 
 ### Fixed
 
-- Retained worker sessions (`spawn_agent`, resumable via `resume_agent`) now have
+- Retained worker sessions (`spawn_agent`, resumable via `resume_agent`/`followup_task`) now have
   their own retention cap, separate from the TUI's finished-session display cap. Previously they
   shared that 20-item cap, so `resume_agent` on an early worker failed with a bare `not_found` once
   a fan-out of more than 20 workers had finished. A session dropped by the retention cap still
   releases its sidecars/reactor/lock entry, always evicts least-recently-used first, and never
-  evicts a running session. `resume_agent` against an evicted session now reports
+  evicts a running session. `resume_agent`/`followup_task` against an evicted session now report
   its terminal status plus a pointer to `read_agent_trace`, instead of `not_found`.
 
 ## [0.3.0] - 2026-08-24
@@ -249,17 +249,19 @@ parallel copies under `docs/` or `scripts/notes/`. At cut time: rename
   operator interrupts it (`interrupt_agent`) rather than the harness enforcing
   a count.
 
-- Added `interrupt_agent({ target })`, the second half of reusable worker
-  sessions: `interrupt_agent` stops a retained worker's current turn while
-  keeping it and its context alive (distinct from the permanent `close_agent`).
-  Starting the next turn on that retained session is `resume_agent`. Both are
-  gated to orchestrator tiers via the existing fleet-verb mechanism, denied to
-  leaves. `interrupt_agent` fires a signal scoped only to the in-flight
-  `agent.send()` call, never `close()`, so it cannot hit the close()-ordering
-  workdir-lock issue tracked separately — the underlying reactor cycle keeps
-  running in the background (there is no lower-level stop primitive for that in
-  the vendored agent), so this is an approximation: it stops the caller from
-  waiting, not the worker's compute.
+- Added `interrupt_agent({ target })` and `followup_task({ target, message })`,
+  the second half of reusable worker sessions: `interrupt_agent` stops a
+  retained worker's current turn while keeping it and its context alive
+  (distinct from the permanent `close_agent`), and `followup_task` sends new
+  work into a retained worker's existing session, reusing its prior context
+  and tool outputs rather than starting fresh. Both are gated to orchestrator
+  tiers via the existing fleet-verb mechanism, denied to leaves. `interrupt_agent`
+  fires a signal scoped only to the in-flight `agent.send()` call, never
+  `close()`, so it cannot hit the close()-ordering workdir-lock issue tracked
+  separately — the underlying reactor cycle keeps running in the background
+  (there is no lower-level stop primitive for that in the vendored agent), so
+  this is an approximation: it stops the caller from waiting, not the
+  worker's compute.
 - `evaluateSubAgentStop` now always requires the final assistant text; the
   omitted-text branch that unconditionally completed a tool-less turn is
   removed, so every call path gets the `incomplete-report` nudge and salvage

src/subagent/session-store.test.ts

@@ -369,6 +369,55 @@ describe("CL-6943 reusable worker sessions", () => {
     expect(store.get(session.id)?.lifecycleStatus).toBe("completed");
   });
 
+  test("rejected followup restores strip status so interrupt_agent fails closed", async () => {
+    const store = createSubAgentSessionStore();
+    const session = store.start({ description: "d", agentId: "a", brief: "b", retained: true });
+    store.markRunning(session.id);
+    store.registerInterrupt(session.id, () => {});
+    store.registerFollowup(session.id, async () => {
+      throw new Error("send failed");
+    });
+    store.complete(session.id, "## Summary\nDone.");
+    expect(store.get(session.id)?.status).toBe("done");
+    expect(store.get(session.id)?.lifecycleStatus).toBe("completed");
+
+    expect(store.resumeOne(session.id, "continue")).toEqual({ ok: true, status: "running" });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    const after = store.get(session.id);
+    expect(after?.status).toBe("done");
+    expect(after?.lifecycleStatus).toBe("completed");
+    expect(store.interruptOne(session.id)).toEqual({ ok: false, status: "completed" });
+  });
+
+  test("interrupt then abort does not overwrite interrupted stamp to completed", async () => {
+    let rejectFollowup: (err: unknown) => void = () => {};
+    const store = createSubAgentSessionStore();
+    const session = store.start({ description: "d", agentId: "a", brief: "b", retained: true });
+    store.markRunning(session.id);
+    store.registerInterrupt(session.id, () => {});
+    store.registerFollowup(
+      session.id,
+      () =>
+        new Promise<string>((_resolve, reject) => {
+          rejectFollowup = reject;
+        }),
+    );
+    store.complete(session.id, "## Summary\nDone.");
+
+    expect(store.resumeOne(session.id, "continue")).toEqual({ ok: true, status: "running" });
+    expect(store.interruptOne(session.id).ok).toBe(true);
+    expect(store.get(session.id)?.status).toBe("running");
+    expect(store.get(session.id)?.lifecycleStatus).toBe("interrupted");
+
+    rejectFollowup(new Error("aborted"));
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    const after = store.get(session.id);
+    expect(after?.status).toBe("running");
+    expect(after?.lifecycleStatus).toBe("interrupted");
+  });
+
   test("resume_agent fails on a session that was never retained", () => {
     const store = createSubAgentSessionStore();
     const session = store.start({ description: "d", agentId: "a", brief: "b" });

src/subagent/session-store.ts

@@ -600,7 +600,9 @@ export function createSubAgentSessionStore(
   // 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 resume_agent can retry.
+  // addressable strip state it started from (done, or interrupted linger) so
+  // resume_agent can retry. interrupt_agent's stamp on this turn wins over
+  // that restore — do not rewrite interrupted back to completed.
   const beginFollowupTurn = (id: string): void => {
     mutate(id, (s) => {
       s.status = "running";
@@ -610,8 +612,13 @@ export function createSubAgentSessionStore(
   };
   const endFollowupTurn = (id: string, lifecycleStatus: AgentLifecycleStatus): void => {
     mutate(id, (s) => {
+      if (s.lifecycleStatus === "interrupted") {
+        s.finishedAt = s.finishedAt ?? now();
+        return;
+      }
       s.lifecycleStatus = lifecycleStatus;
       s.finishedAt = now();
+      s.status = lifecycleStatus === "interrupted" ? "running" : "done";
     });
   };
   const queueFollowupTurn = (