Drop nothing running from dry fleet tallies

Author: TheGreatAxios

docs/TUI.md

@@ -255,8 +255,12 @@ Parent prose owns success narratives. Transcript fleet notices exist only for
 attention live spawn_agent rows cannot keep: a lane **failed** or **cancelled**
 while other work is still running, and **one** dry-fleet line when the last
 lane finishes
-(`N done · nothing running`; failed and cancelled counts appear only
-when non-zero, e.g. `N done, M failed, K cancelled · nothing running`).
+(`N done`; failed and cancelled counts appear only
+when non-zero, e.g. `N done, M failed, K cancelled`).
+When the parent is still in a turn or still has todo/doing work, that
+line appends `orchestrator continuing`. The suffix is omitted when the
+orchestrator is idle, and is not added while specialist lanes are still
+running. An empty fleet with no outcomes does not claim the job closed.
 Per-lane `done — summary` walls and live `dispatched` re-announcements
 are never printed. That dry-fleet line stays operator-facing. If tasks
 are still todo/doing, the runtime re-enters the parent with collected

src/subagent/fleet-report.test.ts

@@ -89,7 +89,7 @@ describe("observeFleet", () => {
       ],
       T0 + 1000,
     );
-    expect(updates).toEqual(["2 done · nothing running"]);
+    expect(updates).toEqual(["2 done"]);
   });
 
   test("a failure names what went wrong while the fleet is still live", () => {
@@ -155,7 +155,7 @@ describe("observeFleet", () => {
         : { ...l, status: "failed" as const, error: "boom" },
     );
     const { updates } = observeFleet(seeded, after, T0 + 1000);
-    expect(updates).toEqual(["9 done, 3 failed · nothing running"]);
+    expect(updates).toEqual(["9 done, 3 failed"]);
   });
 
   test("a cancelled-only dry fleet counts cancelled, not failed", () => {
@@ -172,7 +172,7 @@ describe("observeFleet", () => {
       ],
       T0 + 1000,
     );
-    expect(updates).toEqual(["0 done, 2 cancelled · nothing running"]);
+    expect(updates).toEqual(["0 done, 2 cancelled"]);
   });
 
   test("a mixed dry fleet names done, failed, and cancelled separately", () => {
@@ -190,9 +190,7 @@ describe("observeFleet", () => {
       ],
       T0 + 1000,
     );
-    expect(updates).toEqual([
-      "1 done, 1 failed, 1 cancelled · nothing running",
-    ]);
+    expect(updates).toEqual(["1 done, 1 failed, 1 cancelled"]);
   });
 
   test("a burst of live cancels coalesces as cancelled, not failed", () => {
@@ -216,6 +214,46 @@ describe("observeFleet", () => {
     const { updates } = observeFleet(seeded, after, T0 + 1000);
     expect(updates).toEqual(["2 failed, 2 cancelled"]);
   });
+
+  test("a dry fleet appends orchestrator continuing only when the parent is still working", () => {
+    const seeded = observeFleet(
+      createFleetWatch(),
+      [lane({ id: "api" }), lane({ id: "docs", status: "done" })],
+      T0,
+    ).watch;
+    const lanes = [
+      lane({ id: "api", status: "done" as const, report: "done" }),
+      lane({ id: "docs", status: "done" as const }),
+    ];
+    expect(observeFleet(seeded, lanes, T0 + 1000).updates).toEqual(["2 done"]);
+    expect(
+      observeFleet(seeded, lanes, T0 + 1000, {
+        orchestratorContinuing: true,
+      }).updates,
+    ).toEqual(["2 done · orchestrator continuing"]);
+  });
+
+  test("orchestrator continuing is not added while a specialist lane is still running", () => {
+    const seeded = observeFleet(
+      createFleetWatch(),
+      [lane({ id: "build" }), lane({ id: "docs" })],
+      T0,
+    ).watch;
+    const { updates } = observeFleet(
+      seeded,
+      [
+        lane({
+          id: "build",
+          status: "failed",
+          error: "typecheck exited 1",
+        }),
+        lane({ id: "docs" }),
+      ],
+      T0 + 1000,
+      { orchestratorContinuing: true },
+    );
+    expect(updates).toEqual(["build failed — typecheck exited 1"]);
+  });
 });
 
 describe("fleetDigest", () => {
@@ -236,11 +274,11 @@ describe("fleetDigest", () => {
     expect(digest).toBe("2 running (api 1:20, docs 0:20) · 1 done · 1 failed");
   });
 
-  test("a fleet with nothing left running says so rather than going blank", () => {
+  test("a dry fleet with outcomes is the tally only — idle does not claim the job closed", () => {
     expect(fleetDigest([lane({ id: "api", status: "done" })], T0)).toBe(
-      "nothing running · 1 done",
+      "1 done",
     );
-    expect(fleetDigest([], T0)).toBe("nothing running");
+    expect(fleetDigest([], T0)).toBe("");
   });
 
   test("cancelled lanes are named separately from failed", () => {
@@ -252,7 +290,32 @@ describe("fleetDigest", () => {
         ],
         T0,
       ),
-    ).toBe("nothing running · 1 failed · 1 cancelled");
+    ).toBe("1 failed · 1 cancelled");
+  });
+
+  test("orchestrator continuing is a dry-fleet suffix, never a live-lane claim", () => {
+    expect(
+      fleetDigest([lane({ id: "api", status: "done" })], T0, {
+        orchestratorContinuing: true,
+      }),
+    ).toBe("1 done · orchestrator continuing");
+    expect(fleetDigest([], T0, { orchestratorContinuing: true })).toBe(
+      "orchestrator continuing",
+    );
+    expect(
+      fleetDigest(
+        [
+          lane({
+            id: "api",
+            startedAt: T0 - 80_000,
+            lastActivityAt: T0 - 1000,
+          }),
+          lane({ id: "web", status: "done" }),
+        ],
+        T0,
+        { orchestratorContinuing: true },
+      ),
+    ).toBe("1 running (api 1:20) · 1 done");
   });
 });
 

src/subagent/fleet-report.ts

@@ -191,12 +191,19 @@ export interface FleetObservation {
   readonly updates: readonly string[];
 }
 
+export interface FleetReportOpts {
+  readonly stallMs?: number;
+  readonly orchestratorContinuing?: boolean;
+}
+
 export function observeFleet(
   previous: FleetWatch,
   lanes: readonly FleetLane[],
   nowMs: number,
-  stallMs: number = DEFAULT_STALL_MS,
+  opts: FleetReportOpts = {},
 ): FleetObservation {
+  const stallMs = opts.stallMs ?? DEFAULT_STALL_MS;
+  const orchestratorContinuing = opts.orchestratorContinuing === true;
   const marks = new Map<string, LaneMark>();
   const changes: Change[] = [];
   let running = 0;
@@ -263,7 +270,7 @@ export function observeFleet(
     return {
       watch,
       updates: [
-        clip(`${idleSummary(lanes)} · nothing running`, MAX_UPDATE_CHARS),
+        clip(dryFleetLine(lanes, orchestratorContinuing), MAX_UPDATE_CHARS),
       ],
     };
   }
@@ -348,21 +355,37 @@ function idleSummary(lanes: readonly FleetLane[]): string {
   }).join(", ");
 }
 
+function withOrchestratorContinuing(line: string, continuing: boolean): string {
+  if (!continuing) return line;
+  return line.length === 0
+    ? "orchestrator continuing"
+    : `${line} · orchestrator continuing`;
+}
+
+function dryFleetLine(
+  lanes: readonly FleetLane[],
+  orchestratorContinuing: boolean,
+): string {
+  return withOrchestratorContinuing(idleSummary(lanes), orchestratorContinuing);
+}
+
 /**
  * The answer to "where are we" on demand — the same picture the unprompted
  * lines build up to, in one row, so asking never costs an interrupt.
  */
 export function fleetDigest(
   lanes: readonly FleetLane[],
   nowMs: number,
-  stallMs: number = DEFAULT_STALL_MS,
+  opts: FleetReportOpts = {},
 ): string {
-  if (lanes.length === 0) return "nothing running";
+  const stallMs = opts.stallMs ?? DEFAULT_STALL_MS;
+  const orchestratorContinuing = opts.orchestratorContinuing === true;
+  if (lanes.length === 0) {
+    return orchestratorContinuing ? "orchestrator continuing" : "";
+  }
   const running = lanes.filter((l) => l.status === "running");
   const parts: string[] = [];
-  if (running.length === 0) {
-    parts.push("nothing running");
-  } else {
+  if (running.length > 0) {
     const named = running
       .slice(0, DIGEST_NAMED_LANES)
       .map((lane) => {
@@ -379,5 +402,8 @@ export function fleetDigest(
   parts.push(
     ...formatOutcomeParts(outcomeCounts(lanes), { includeZeroDone: false }),
   );
-  return parts.join(" · ");
+  const digest = parts.join(" · ");
+  // Live lanes already name themselves; the suffix is only for a dry fleet.
+  if (running.length > 0) return digest;
+  return withOrchestratorContinuing(digest, orchestratorContinuing);
 }

src/tui/runner/commands.ts

@@ -35,6 +35,7 @@ import {
 } from "../../cost/cost-summary.js";
 import { contextTokensFromUsage } from "../../provider/context-window.js";
 import { fleetDigest } from "../../subagent/index.js";
+import { hasActiveTasks } from "../../agent/tasks.js";
 import { renameSession } from "../../session/index.js";
 import { truncateSessionLabel } from "../../session/session-label.js";
 import { surfaceSystemNotice, attachClipboardImage } from "../shell/prompt.js";
@@ -166,7 +167,11 @@ export function createCommandLayer(
     },
     startWorkflow: (name) => services.workflowHost.start(name),
     getFleetStatus: () =>
-      fleetDigest(services.subAgentSessions.list(), Date.now()),
+      fleetDigest(services.subAgentSessions.list(), Date.now(), {
+        orchestratorContinuing:
+          hostOf(state).bridge.turn.isProcessing ||
+          hasActiveTasks(services.directorHolder.instance?.getTasks() ?? []),
+      }),
     renameSession: (name) => {
       const trimmed = name.trim();
       if (trimmed.length === 0) return "Session name cannot be empty";

src/tui/runner/wiring.ts

@@ -31,6 +31,7 @@ import {
 import { scheduleUpgradeNotice } from "../../upgrade/index.js";
 import pkg from "../../../package.json" with { type: "json" };
 import { hydrateTasksFromTurns } from "../../agent/director.js";
+import { hasActiveTasks } from "../../agent/tasks.js";
 import { cycleReasoningEffort } from "../../provider/reasoning-effort.js";
 import { isCodexProviderName } from "../../config/codex-providers.js";
 import { RUNTIME_FLASH_MS } from "../runtime-notices.js";
@@ -181,6 +182,11 @@ export function wirePostStartup(
       fleetWatch,
       services.subAgentSessions.list(),
       Date.now(),
+      {
+        orchestratorContinuing:
+          sessionBridge.turn.isProcessing ||
+          hasActiveTasks(services.directorHolder.instance?.getTasks() ?? []),
+      },
     );
     fleetWatch = observation.watch;
     for (const update of observation.updates)