fix(tui): count cancelled lanes with interrupted lifecycle

projectLifecycleStatus maps cancelled to interrupted, so outcomeCounts
skipped cancelAll workers. Skip only live occupancy leftovers, not
cancelled terminals.

Author: TheGreatAxios

docs/TUI.md

@@ -317,8 +317,11 @@ 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`.
+Interrupted leftovers (TUI status still `running`, lifecycle interrupted)
+are occupancy leftovers, not a finished outcome, so interrupt-all does not
+print `0 done`. Operator cancel (`status: cancelled`, lifecycle still
+projected as interrupted) is a finished outcome and is counted
+(`0 done, K cancelled` on idle; digest names `K cancelled`).
 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

src/subagent/fleet-report.test.ts

@@ -241,8 +241,16 @@ describe("observeFleet", () => {
     const { watch, updates } = observeFleet(
       seeded,
       [
-        lane({ id: "api", lifecycleStatus: "interrupted" }),
-        lane({ id: "docs", lifecycleStatus: "interrupted" }),
+        lane({
+          id: "api",
+          status: "running",
+          lifecycleStatus: "interrupted",
+        }),
+        lane({
+          id: "docs",
+          status: "running",
+          lifecycleStatus: "interrupted",
+        }),
       ],
       T0 + 1000,
     );
@@ -251,6 +259,58 @@ describe("observeFleet", () => {
     expect(updates).toEqual([]);
   });
 
+  test("cancel-all counts cancelled even when lifecycleStatus is interrupted", () => {
+    const seeded = observeFleet(
+      createFleetWatch(),
+      [lane({ id: "api" }), lane({ id: "docs" })],
+      T0,
+    ).watch;
+    const { watch, updates } = observeFleet(
+      seeded,
+      [
+        lane({
+          id: "api",
+          status: "cancelled",
+          lifecycleStatus: "interrupted",
+        }),
+        lane({
+          id: "docs",
+          status: "cancelled",
+          lifecycleStatus: "interrupted",
+        }),
+      ],
+      T0 + 1000,
+    );
+    expect(watch.running).toBe(0);
+    expect(updates).toEqual(["0 done, 2 cancelled"]);
+  });
+
+  test("a mixed dry fleet counts done and cancelled with interrupted lifecycle", () => {
+    const seeded = observeFleet(
+      createFleetWatch(),
+      [lane({ id: "api" }), lane({ id: "docs" })],
+      T0,
+    ).watch;
+    const { updates } = observeFleet(
+      seeded,
+      [
+        lane({
+          id: "api",
+          status: "done",
+          lifecycleStatus: "completed",
+          report: "ok",
+        }),
+        lane({
+          id: "docs",
+          status: "cancelled",
+          lifecycleStatus: "interrupted",
+        }),
+      ],
+      T0 + 1000,
+    );
+    expect(updates).toEqual(["1 done, 1 cancelled"]);
+  });
+
   test("a mixed dry fleet does not count interrupted leftovers as done", () => {
     const seeded = observeFleet(
       createFleetWatch(),
@@ -260,8 +320,17 @@ describe("observeFleet", () => {
     const { updates } = observeFleet(
       seeded,
       [
-        lane({ id: "api", status: "done", report: "ok" }),
-        lane({ id: "docs", lifecycleStatus: "interrupted" }),
+        lane({
+          id: "api",
+          status: "done",
+          lifecycleStatus: "completed",
+          report: "ok",
+        }),
+        lane({
+          id: "docs",
+          status: "running",
+          lifecycleStatus: "interrupted",
+        }),
       ],
       T0 + 1000,
     );
@@ -295,8 +364,16 @@ describe("fleetDigest", () => {
     expect(
       fleetDigest(
         [
-          lane({ id: "api", lifecycleStatus: "interrupted" }),
-          lane({ id: "docs", lifecycleStatus: "interrupted" }),
+          lane({
+            id: "api",
+            status: "running",
+            lifecycleStatus: "interrupted",
+          }),
+          lane({
+            id: "docs",
+            status: "running",
+            lifecycleStatus: "interrupted",
+          }),
         ],
         T0,
       ),
@@ -307,13 +384,61 @@ describe("fleetDigest", () => {
     expect(
       fleetDigest(
         [
-          lane({ id: "api", status: "cancelled" }),
-          lane({ id: "cli", status: "failed" }),
+          lane({
+            id: "api",
+            status: "cancelled",
+            lifecycleStatus: "interrupted",
+          }),
+          lane({
+            id: "cli",
+            status: "failed",
+            lifecycleStatus: "shutdown",
+          }),
         ],
         T0,
       ),
     ).toBe("1 failed · 1 cancelled");
   });
+
+  test("a cancelled-only fleet names cancelled even when lifecycle is interrupted", () => {
+    expect(
+      fleetDigest(
+        [
+          lane({
+            id: "api",
+            status: "cancelled",
+            lifecycleStatus: "interrupted",
+          }),
+          lane({
+            id: "docs",
+            status: "cancelled",
+            lifecycleStatus: "interrupted",
+          }),
+        ],
+        T0,
+      ),
+    ).toBe("2 cancelled");
+  });
+
+  test("mixed done and cancelled-with-interrupted lifecycle counts both", () => {
+    expect(
+      fleetDigest(
+        [
+          lane({
+            id: "api",
+            status: "done",
+            lifecycleStatus: "completed",
+          }),
+          lane({
+            id: "docs",
+            status: "cancelled",
+            lifecycleStatus: "interrupted",
+          }),
+        ],
+        T0,
+      ),
+    ).toBe("1 done · 1 cancelled");
+  });
 });
 
 describe("forced-stop reasons", () => {

src/subagent/fleet-report.ts

@@ -323,11 +323,10 @@ 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;
-    }
+    // Occupancy leftovers (still TUI-running, including interrupted leftovers)
+    // are not finished outcomes. Cancelled workers project lifecycleStatus
+    // interrupted too — skip on live/running, not on interrupted alone.
+    if (agentLaneIsLive(lane) || lane.status === "running") continue;
     switch (lane.status) {
       case "done":
         done += 1;
@@ -338,8 +337,6 @@ function outcomeCounts(lanes: readonly FleetLane[]): OutcomeCounts {
       case "cancelled":
         cancelled += 1;
         break;
-      case "running":
-        break;
     }
   }
   return { done, failed, cancelled };