fix(tui): keep occupancy and idle-with-fleet on live lanes

Interrupted workers are not live occupancy and are not a dry-fleet
done count. First assemble and new/clear resync idle-with-fleet from
the live count instead of only on count change.

Author: TheGreatAxios

docs/IMPLEMENTATION.md

@@ -210,7 +210,7 @@ Listings are list-free, dumps are dump-locked: a bounded `ls`/`tree` prints name
 
 - **Alt+Enter** queues a follow-up (kind `"queue"`) delivered only on **session-idle** — parent-idle **and** no live fleet lanes (`run` goes idle). Session-idle Alt+Enter is a no-op. **Ctrl+C** stops the run.
 
-Idle-with-fleet is shipped: after a non-blocking `spawn_agent` dispatch the parent turn can settle while workers keep running. The runner emits a `fleet` event carrying the live-lane count; the bridge holds the run busy on that count, so mid-hold Enter upgrades to a new primary turn (sent immediately) instead of queueing a steer, follow-ups keep waiting for true session-idle, and any steer left pending at the hold's engagement delivers immediately — the parent it was steering has already stopped. While the hold is up and the parent is not processing, occupancy flushes mailbox mail (`driveMailboxMail` + `buildMailboxMailMessage`) on store subscribe and idle-with-fleet settle — one child done while siblings run is enough. Skip that shot when a fleet-dry open-task continuation is latched. Exec-primary `wait_agents` mounts with no yield predicate (`createWaitAgentsTool({ sessions, fleetRecords })`) and blocks to ready/timeout/abort; `shouldYieldWait` remains a supported-but-unwired tool option (no production mount passes it).
+Idle-with-fleet is shipped: after a non-blocking `spawn_agent` dispatch the parent turn can settle while workers keep running. The runner emits a `fleet` event carrying the live-lane count (same liveness rule as the progress strip: interrupted leftovers are not live); the bridge holds the run busy on that count, so mid-hold Enter upgrades to a new primary turn (sent immediately) instead of queueing a steer, follow-ups keep waiting for true session-idle, and any steer left pending at the hold's engagement delivers immediately — the parent it was steering has already stopped. While the hold is up and the parent is not processing, occupancy flushes mailbox mail (`driveMailboxMail` + `buildMailboxMailMessage`) on store subscribe and idle-with-fleet settle — one child done while siblings run is enough. Skip that shot when a fleet-dry open-task continuation is latched. Exec-primary `wait_agents` mounts with no yield predicate (`createWaitAgentsTool({ sessions, fleetRecords })`) and blocks to ready/timeout/abort; `shouldYieldWait` remains a supported-but-unwired tool option (no production mount passes it).
 
 `src/tui/stream-event-map.ts` maps reactor events onto the bridge's inbound events, and `src/tui/turn-state.ts` tracks the turn's status. `src/tui/turns-to-blocks.ts` hydrates a resumed session's stored turns into the same content blocks.
 

docs/TUI.md

@@ -317,6 +317,8 @@ while other work is still running, and **one** dry-fleet line when the last
 lane finishes
 (`N done`; failed and cancelled counts appear only
 when non-zero, e.g. `N done, M failed, K cancelled`).
+Interrupted leftovers use the same liveness rule as occupancy: they are
+not a finished outcome, so interrupt-all does not print `0 done`.
 The line does not claim the run is idle — the parent often continues.
 The prompt-box lockup is what names that occupation, not this tally.
 Per-lane `done — summary` walls and live `dispatched` re-announcements
@@ -690,7 +692,8 @@ unchanged.
 
 **Idle-with-fleet** is shipped. After a non-blocking `spawn_agent` dispatch
 the parent turn settles while workers keep running; the runner emits `fleet`
-events carrying the live-lane count and the bridge holds the run busy on it.
+events carrying the live-lane count (interrupted leftovers are not live)
+and the bridge holds the run busy on it.
 During the hold, Enter upgrades to a new primary turn sent immediately —
 there is no parent tool left to steer — while Alt+Enter follow-ups keep
 waiting for true session-idle. A child done or fail while siblings still run

src/subagent/fleet-report.test.ts

@@ -34,6 +34,23 @@ describe("liveFleetCount", () => {
     expect(liveFleetCount(lanes)).toBe(2);
   });
 
+  test("interrupted leftovers are not live occupancy", () => {
+    const lanes = [
+      lane({ id: "a", lifecycleStatus: "interrupted" }),
+      lane({ id: "b", status: "done", report: "x" }),
+      lane({ id: "c" }),
+    ];
+    expect(liveFleetCount(lanes)).toBe(1);
+  });
+
+  test("interrupt-all with no running workers is live count 0", () => {
+    const lanes = [
+      lane({ id: "a", lifecycleStatus: "interrupted" }),
+      lane({ id: "b", lifecycleStatus: "interrupted" }),
+    ];
+    expect(liveFleetCount(lanes)).toBe(0);
+  });
+
   test("an empty or fully-terminal fleet counts zero", () => {
     expect(liveFleetCount([])).toBe(0);
     expect(
@@ -214,6 +231,42 @@ describe("observeFleet", () => {
     const { updates } = observeFleet(seeded, after, T0 + 1000);
     expect(updates).toEqual(["2 failed, 2 cancelled"]);
   });
+
+  test("interrupt-all does not tally interrupted leftovers as 0 done", () => {
+    const seeded = observeFleet(
+      createFleetWatch(),
+      [lane({ id: "api" }), lane({ id: "docs" })],
+      T0,
+    ).watch;
+    const { watch, updates } = observeFleet(
+      seeded,
+      [
+        lane({ id: "api", lifecycleStatus: "interrupted" }),
+        lane({ id: "docs", lifecycleStatus: "interrupted" }),
+      ],
+      T0 + 1000,
+    );
+    expect(watch.running).toBe(0);
+    expect(updates.join(" ")).not.toContain("0 done");
+    expect(updates).toEqual([]);
+  });
+
+  test("a mixed dry fleet does not count interrupted leftovers as done", () => {
+    const seeded = observeFleet(
+      createFleetWatch(),
+      [lane({ id: "api" }), lane({ id: "docs" })],
+      T0,
+    ).watch;
+    const { updates } = observeFleet(
+      seeded,
+      [
+        lane({ id: "api", status: "done", report: "ok" }),
+        lane({ id: "docs", lifecycleStatus: "interrupted" }),
+      ],
+      T0 + 1000,
+    );
+    expect(updates).toEqual(["1 done"]);
+  });
 });
 
 describe("fleetDigest", () => {
@@ -239,6 +292,15 @@ describe("fleetDigest", () => {
       "1 done",
     );
     expect(fleetDigest([], T0)).toBe("");
+    expect(
+      fleetDigest(
+        [
+          lane({ id: "api", lifecycleStatus: "interrupted" }),
+          lane({ id: "docs", lifecycleStatus: "interrupted" }),
+        ],
+        T0,
+      ),
+    ).toBe("");
   });
 
   test("cancelled lanes are named separately from failed", () => {

src/subagent/fleet-report.ts

@@ -13,17 +13,23 @@
  */
 
 import {
+  agentLaneIsLive,
   agentProgress,
   clockLabel,
   DEFAULT_STALL_MS,
 } from "../tui/agent-progress.js";
-import type { SubAgentSessionStatus } from "./session-store.js";
+import type {
+  AgentLifecycleStatus,
+  SubAgentSessionStatus,
+} from "./session-store.js";
 
 /** The lane fields a report is written from. `SubAgentSession` satisfies it. */
 export interface FleetLane {
   readonly id: string;
   readonly description: string;
   readonly status: SubAgentSessionStatus;
+  /** Same projection the progress strip uses; interrupted leftovers are not live. */
+  readonly lifecycleStatus?: AgentLifecycleStatus;
   readonly startedAt: number;
   readonly lastActivityAt: number;
   readonly currentToolName: string | null;
@@ -117,12 +123,12 @@ function isStalled(lane: FleetLane, nowMs: number, stallMs: number): boolean {
 }
 
 /**
- * Lanes still running — the count the idle-with-fleet hold reads (CL-7057).
- * One definition lives here so the bridge feed and any other liveness reader
- * cannot drift from what the strip and digest call a running lane.
+ * Lanes still live — the count the idle-with-fleet hold reads (CL-7057).
+ * Same rule as the progress strip (`agentLaneIsLive`): interrupted leftovers
+ * keep TUI status "running" but are not occupancy.
  */
 export function liveFleetCount(lanes: readonly FleetLane[]): number {
-  return lanes.filter((lane) => lane.status === "running").length;
+  return lanes.filter((lane) => agentLaneIsLive(lane)).length;
 }
 
 /**
@@ -207,10 +213,10 @@ export function observeFleet(
   let running = 0;
 
   for (const lane of lanes) {
-    if (lane.status === "running") running += 1;
+    if (agentLaneIsLive(lane)) running += 1;
     const before = previous.lanes.get(lane.id);
     const stalled =
-      lane.status === "running" &&
+      agentLaneIsLive(lane) &&
       (before?.stallReported === true || isStalled(lane, nowMs, stallMs));
     marks.set(lane.id, { status: lane.status, stallReported: stalled });
 
@@ -265,9 +271,10 @@ export function observeFleet(
   // only: fail/cancel/stall while work is still running, or one dry-fleet tally.
   // Never per-lane "done — summary" walls.
   if (wentDry) {
+    const summary = idleSummary(lanes);
     return {
       watch,
-      updates: [clip(idleSummary(lanes), MAX_UPDATE_CHARS)],
+      updates: summary.length === 0 ? [] : [clip(summary, MAX_UPDATE_CHARS)],
     };
   }
 
@@ -316,6 +323,11 @@ function outcomeCounts(lanes: readonly FleetLane[]): OutcomeCounts {
   let failed = 0;
   let cancelled = 0;
   for (const lane of lanes) {
+    // Same liveness as liveFleetCount: interrupted leftovers are not occupancy
+    // and are not a finished outcome, even if TUI status is still "running".
+    if (agentLaneIsLive(lane) || lane.lifecycleStatus === "interrupted") {
+      continue;
+    }
     switch (lane.status) {
       case "done":
         done += 1;
@@ -346,8 +358,9 @@ function formatOutcomeParts(
 }
 
 function idleSummary(lanes: readonly FleetLane[]): string {
-  return formatOutcomeParts(outcomeCounts(lanes), {
-    includeZeroDone: true,
+  const counts = outcomeCounts(lanes);
+  return formatOutcomeParts(counts, {
+    includeZeroDone: counts.failed > 0 || counts.cancelled > 0,
   }).join(", ");
 }
 
@@ -361,7 +374,7 @@ export function fleetDigest(
   options: FleetReportOptions = {},
 ): string {
   const stallMs = options.stallMs ?? DEFAULT_STALL_MS;
-  const running = lanes.filter((l) => l.status === "running");
+  const running = lanes.filter((l) => agentLaneIsLive(l));
   const parts: string[] = [];
   if (running.length > 0) {
     const named = running

src/tui/runner/exit.test.ts

@@ -6,6 +6,7 @@ import type { InferenceSource } from "@intx/types/runtime";
 
 import * as codexSession from "../../auth/codex/session.js";
 import { createChatDirector } from "../../agent/director.js";
+import * as sessionIndex from "../../session/index.js";
 import { createSubAgentSessionStore } from "../../subagent/session-store.js";
 import type {
   ReactorAction,
@@ -23,6 +24,7 @@ import {
   createRunLifecycle,
   finalizeTUIRun,
   resetSessionForRotation,
+  resyncIdleWithFleetFlag,
 } from "./exit.js";
 import type { RunnerServices, RunnerState } from "./state.js";
 
@@ -201,7 +203,8 @@ function stubSendLifecycle(agent: Agent): {
     sessionOps: createSessionOperationQueue(),
     deliveryGeneration: createDeliveryGeneration(),
     toolset: { setToolPromoter: () => undefined },
-    subAgentSessions: { cancelAll: async () => [] },
+    directorHolder: {},
+    subAgentSessions: { cancelAll: async () => [], list: () => [] },
     activeRunHandle: { task: "", startedAt: 0, model: "" },
   } as unknown as RunnerServices;
   return { state, services };
@@ -326,6 +329,71 @@ function rebuildTextTurn(): ReactorInboundEvent {
 }
 
 describe("rebuild re-syncs idle-with-fleet while drained", () => {
+  test("seed then fleet-0 does not leave idle-with-fleet stuck true", async () => {
+    const store = createSubAgentSessionStore();
+    const director = createChatDirector("base", [], {
+      allowIdleWithFleet: true,
+    });
+    resyncIdleWithFleetFlag({
+      directorHolder: { instance: director },
+      subAgentSessions: store,
+    });
+    await director.decide(
+      rebuildManageTasksEvent(),
+      rebuildMockState,
+      rebuildMockCapabilities,
+    );
+    const actions = await director.decide(
+      rebuildTextTurn(),
+      rebuildMockState,
+      rebuildMockCapabilities,
+    );
+    const list = Array.isArray(actions) ? actions : [actions];
+    expect(list.some((action) => action.type === "infer")).toBe(true);
+  });
+
+  test("first assemble with a drained fleet does not leave idle-with-fleet stuck true", async () => {
+    const store = createSubAgentSessionStore();
+    const directorHolder: RunnerServices["directorHolder"] = {};
+    const agent = recordingAgent([]);
+    const { state, services } = stubSendLifecycle(agent);
+    services.directorHolder =
+      directorHolder as unknown as RunnerServices["directorHolder"];
+    services.subAgentSessions =
+      store as unknown as RunnerServices["subAgentSessions"];
+    services.workflowHost = {
+      reattach: () => undefined,
+    } as unknown as RunnerServices["workflowHost"];
+    services.cycleRecorder = {
+      dispose: async () => "",
+      reset: () => undefined,
+      handleEvent: () => undefined,
+    } as unknown as RunnerServices["cycleRecorder"];
+    services.buildAgent = (async () => {
+      directorHolder.instance = createChatDirector("base", [], {
+        allowIdleWithFleet: true,
+      });
+      return agent;
+    }) as unknown as RunnerServices["buildAgent"];
+    await createRunLifecycle(state, services);
+    const director = defined(
+      directorHolder.instance,
+      "directorHolder.instance",
+    );
+    await director.decide(
+      rebuildManageTasksEvent(),
+      rebuildMockState,
+      rebuildMockCapabilities,
+    );
+    const actions = await director.decide(
+      rebuildTextTurn(),
+      rebuildMockState,
+      rebuildMockCapabilities,
+    );
+    const list = Array.isArray(actions) ? actions : [actions];
+    expect(list.some((action) => action.type === "infer")).toBe(true);
+  });
+
   test("reload-if-idle and interrupt rebuilds resume the open-task nudge with no fleet transition", async () => {
     const store = createSubAgentSessionStore();
     const directorHolder: RunnerServices["directorHolder"] = {};
@@ -388,4 +456,84 @@ describe("rebuild re-syncs idle-with-fleet while drained", () => {
     expect(store.list()).toEqual([]);
     expect(fleetEvents).toEqual([]);
   });
+
+  test("newSession/clear with a drained fleet still nudges open tasks after rotation", async () => {
+    const store = createSubAgentSessionStore();
+    const directorHolder: RunnerServices["directorHolder"] = {};
+    const agent = recordingAgent([]);
+    const { state, services } = stubSendLifecycle(agent);
+    services.directorHolder =
+      directorHolder as unknown as RunnerServices["directorHolder"];
+    services.subAgentSessions =
+      store as unknown as RunnerServices["subAgentSessions"];
+    services.workflowHost = {
+      reattach: () => undefined,
+      reset: () => undefined,
+    } as unknown as RunnerServices["workflowHost"];
+    services.cycleRecorder = {
+      dispose: async () => "",
+      reset: () => undefined,
+      handleEvent: () => undefined,
+    } as unknown as RunnerServices["cycleRecorder"];
+    services.buildSessionSources = () => ({
+      sources: [liveSource],
+      defaultSource: liveSource.id,
+      selected: liveSource,
+    });
+    services.permissionGate = {
+      reset: () => undefined,
+    } as unknown as RunnerServices["permissionGate"];
+    services.runSink = {
+      sink: () => undefined,
+      reset: () => undefined,
+    } as unknown as RunnerServices["runSink"];
+    services.sessionCost = {
+      addTurn: () => undefined,
+      reset: () => undefined,
+    } as unknown as RunnerServices["sessionCost"];
+    services.activatedToolNames = {
+      clear: () => undefined,
+      activate: () => false,
+      list: () => [],
+    } as unknown as RunnerServices["activatedToolNames"];
+    services.hostHolder = {} as unknown as RunnerServices["hostHolder"];
+    services.buildAgent = (async () => {
+      directorHolder.instance = createChatDirector("base", [], {
+        allowIdleWithFleet: true,
+      });
+      return agent;
+    }) as unknown as RunnerServices["buildAgent"];
+    const initDir = spyOn(sessionIndex, "initSessionDir").mockImplementation(
+      async () => "/tmp/rotated-session",
+    );
+    const contextDir = spyOn(
+      sessionIndex,
+      "sessionContextDir",
+    ).mockImplementation(() => "/tmp/rotated-session/context");
+    try {
+      await createRunLifecycle(state, services);
+      defined(state.newSession, "newSession")();
+      await services.sessionOps.awaitTail();
+      expect(state.fatalBuildError).toBeNull();
+      const director = defined(
+        directorHolder.instance,
+        "directorHolder.instance",
+      );
+      await director.decide(
+        rebuildManageTasksEvent(),
+        rebuildMockState,
+        rebuildMockCapabilities,
+      );
+      const actions = await director.decide(
+        rebuildTextTurn(),
+        rebuildMockState,
+        rebuildMockCapabilities,
+      );
+      const list = Array.isArray(actions) ? actions : [actions];
+      expect(list.some((action) => action.type === "infer")).toBe(true);
+    } finally {
+      initDir.mockRestore();
+      contextDir.mockRestore();
+    }
+  });
 });