@@ -13,6 +13,17 @@ parallel copies under `docs/` or `scripts/notes/`. At cut time: rename
 
 ## [Unreleased]
 
+### Fixed
+
+- Dry-fleet transcript and `/status` report the outcome tally only
+  (`2 done, 1 failed`). They no longer claim `nothing running` when the
+  parent may still continue.
+- The prompt-box lockup stays on while a fleet is live or a dry-fleet
+  continuation is pending, even if the parent turn has settled. The word
+  cycles through a closed live-activity set (`working`, `warping`,
+  `buzzing`, `grinding`, `thinking`, `doing`, `cooking`, `creating`,
+  `imagining`, `inventing`) instead of going blank.
+
 ## [0.3.19] - 2026-09-10
 
 ### Security
 
@@ -94,13 +94,17 @@ and `@mention` tokens anywhere paint `UI.action`. Bare skill or agent words
 (`implement`, `emil`, `brand review`) stay unstyled, as does a `/review`
 that appears mid-prose.
 
-While a turn is live the lockup slot swaps the wordmark for a semantic
-activity word — never the raw tool, MCP server, or plugin identifier that is
-actually executing. `resolveTurnLabel` (`src/tui/session-chrome.ts`)
-maps execution onto the closed set `ACTIVITY_STATES` exported from that
-module (`thinking`, `planning`, `researching`, `building`, `working`,
-`waiting`, `stalled`, `stopping`); that export is the source
-of truth for what the slot can say, not this list. It is led by a single density cell
+While a turn is live — or the session is still occupied by a live fleet
+or a pending dry-fleet continuation — the lockup slot swaps the wordmark
+for a semantic activity word — never the raw tool, MCP server, or plugin
+identifier that is actually executing. `resolveTurnLabel`
+(`src/tui/session-chrome.ts`) maps execution onto the closed set
+`ACTIVITY_STATES` exported from that module. Live occupation cycles
+`LIVE_ACTIVITY_WORDS` (`working`, `warping`, `buzzing`, `grinding`,
+`thinking`, `doing`, `cooking`, `creating`, `imagining`, `inventing`)
+on `LIVE_WORD_MS`; gated turns still read `waiting` or `stopping`.
+That export is the source of truth for what the slot can say, not this
+list. It is led by a single density cell
 (`rampPulse`, `src/tui/ramp.ts`). The cell, not the word,
 is what says whether the session is healthy, and it carries four states:
 
@@ -120,16 +124,16 @@ printed identically, so the only way to tell them apart was to wait.
 waiting on something outside itself — and are told apart by motion: `blocked`
 holds perfectly still, which is the signal that the session is waiting on _you_.
 
-While fleet agents are running, the slot reports the _fleet_, not the parent.
-`resolveTurnLabel` and `resolveRampPhase` take a `FleetProgress` roll-up and
-rank it above the parent's own stall clock: with live lanes the parent is
-idle by design, so its silence says nothing about whether the session is
-progressing, and reporting it was how a session with every lane wedged still
-read as `working`. A fleet with no stalled lane reads `working`; one
-stalled lane makes the whole indicator read `stalled`, which is the state that
-should pull an operator's eye to the panel. A blocked gate and a stopping turn
-still outrank the fleet. With zero running fleet agents the roll-up is empty and
-every path through both functions behaves exactly as it does for a plain
+While fleet agents are running, the slot stays live even when the parent
+turn has settled (idle-with-fleet). `resolveTurnLabel` and
+`resolveRampPhase` take a `FleetProgress` roll-up plus session occupancy:
+with live lanes the parent is idle by design, so its silence says nothing
+about whether the session is progressing, and blanking the lockup made a
+busy fleet look hung. Occupied sessions keep cycling a live-activity
+word; recovery stays silent rather than painting `stalled`. A blocked
+gate and a stopping turn still outrank the fleet. With zero running fleet
+agents and no pending continuation the roll-up is empty and every path
+through both functions behaves exactly as it does for a plain
 single-agent turn.
 
 The stall phase is driven by the watchdog's own silence clock
@@ -257,10 +261,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`).
-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.
+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
 are never printed. That dry-fleet line stays operator-facing. If tasks
 are still todo/doing, the runtime re-enters the parent with collected
 
@@ -214,46 +214,6 @@ 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", () => {
@@ -274,10 +234,8 @@ describe("fleetDigest", () => {
     expect(digest).toBe("2 running (api 1:20, docs 0:20) · 1 done · 1 failed");
   });
 
-  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(
-      "1 done",
-    );
+  test("a dry fleet is the outcome tally, not an idle claim", () => {
+    expect(fleetDigest([lane({ id: "api", status: "done" })], T0)).toBe("1 done");
     expect(fleetDigest([], T0)).toBe("");
   });
 
@@ -292,31 +250,6 @@ describe("fleetDigest", () => {
       ),
     ).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");
-  });
 });
 
 describe("forced-stop reasons", () => {
 
@@ -185,25 +185,23 @@ type Change =
   | { readonly kind: "cancelled"; readonly line: string }
   | { readonly kind: "stalled"; readonly line: string };
 
+export interface FleetReportOptions {
+  readonly stallMs?: number;
+}
+
 export interface FleetObservation {
   readonly watch: FleetWatch;
   /** Ready-to-print lines, already coalesced. Usually empty. */
   readonly updates: readonly string[];
 }
 
-export interface FleetReportOpts {
-  readonly stallMs?: number;
-  readonly orchestratorContinuing?: boolean;
-}
-
 export function observeFleet(
   previous: FleetWatch,
   lanes: readonly FleetLane[],
   nowMs: number,
-  opts: FleetReportOpts = {},
+  options: FleetReportOptions = {},
 ): FleetObservation {
-  const stallMs = opts.stallMs ?? DEFAULT_STALL_MS;
-  const orchestratorContinuing = opts.orchestratorContinuing === true;
+  const stallMs = options.stallMs ?? DEFAULT_STALL_MS;
   const marks = new Map<string, LaneMark>();
   const changes: Change[] = [];
   let running = 0;
@@ -269,9 +267,7 @@ export function observeFleet(
   if (wentDry) {
     return {
       watch,
-      updates: [
-        clip(dryFleetLine(lanes, orchestratorContinuing), MAX_UPDATE_CHARS),
-      ],
+      updates: [clip(idleSummary(lanes), MAX_UPDATE_CHARS)],
     };
   }
 
@@ -355,34 +351,16 @@ 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,
-  opts: FleetReportOpts = {},
+  options: FleetReportOptions = {},
 ): string {
-  const stallMs = opts.stallMs ?? DEFAULT_STALL_MS;
-  const orchestratorContinuing = opts.orchestratorContinuing === true;
-  if (lanes.length === 0) {
-    return orchestratorContinuing ? "orchestrator continuing" : "";
-  }
+  const stallMs = options.stallMs ?? DEFAULT_STALL_MS;
   const running = lanes.filter((l) => l.status === "running");
   const parts: string[] = [];
   if (running.length > 0) {
@@ -402,8 +380,5 @@ export function fleetDigest(
   parts.push(
     ...formatOutcomeParts(outcomeCounts(lanes), { includeZeroDone: false }),
   );
-  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);
+  return parts.join(" · ");
 }
@@ -22,6 +22,7 @@ export {
   pendingAskWakeText,
   type FleetLane,
   type FleetObservation,
+  type FleetReportOptions,
   type FleetWatch,
   type PendingAskWake,
 } from "./fleet-report.js";
 
@@ -35,7 +35,6 @@ 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";
@@ -167,11 +166,7 @@ export function createCommandLayer(
     },
     startWorkflow: (name) => services.workflowHost.start(name),
     getFleetStatus: () =>
-      fleetDigest(services.subAgentSessions.list(), Date.now(), {
-        orchestratorContinuing:
-          hostOf(state).bridge.turn.isProcessing ||
-          hasActiveTasks(services.directorHolder.instance?.getTasks() ?? []),
-      }),
+      fleetDigest(services.subAgentSessions.list(), Date.now()),
     renameSession: (name) => {
       const trimmed = name.trim();
       if (trimmed.length === 0) return "Session name cannot be empty";
 
@@ -31,7 +31,6 @@ 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";
@@ -182,11 +181,6 @@ 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)
 
@@ -14,6 +14,7 @@ import { streamRowCount } from "./shell/transcript";
 import { STEER_WAIT_NOTICE_MS } from "./notice-line";
 import { withTestRenderer } from "./harness";
 import { badgeCount } from "./session-queue";
+import { LIVE_ACTIVITY_WORDS } from "./session-chrome";
 
 describe("mapReactorLike", () => {
   test("message.received → user", () => {
@@ -1377,6 +1378,10 @@ describe("idle-with-fleet (CL-7057)", () => {
           // The parent turn settled but the fleet is live: the run stays
           // busy and the follow-up does not drain at mere parent-idle.
           expect(shell.session.run).toBe("busy");
+          expect(shell.lockupPhase).not.toBeNull();
+          expect((LIVE_ACTIVITY_WORDS as readonly string[]).includes(shell.lockupPhase ?? "")).toBe(
+            true,
+          );
           expect(badgeCount(shell.session)).toBe(1);
           expect(port.calls).toEqual([]);
           await h.renderOnce();
 
@@ -1286,15 +1286,18 @@ export function attachSessionBridge(
       status: turn.status,
       currentToolName: turn.currentToolName,
       streamingType: turn.streamingType,
+      nowMs,
+      sessionActive: bag.liveFleet > 0,
     };
     const fleet = fleetProgress(bag.agentSessions, nowMs);
     const label = resolveTurnLabel(input, isStalled, fleet);
+    const sessionLive = label !== undefined;
     if (label === undefined) {
       // The bottom-left status slot rides the same re-entry as the landing
       // mark, so it crossfades between phases without a timer of its own.
       setLockupFrame(shell, {
         nowMs,
-        animating: turn.isProcessing,
+        animating: false,
         phase: null,
         rampPhase: null,
         stalledForMs: null,
@@ -1309,7 +1312,7 @@ export function attachSessionBridge(
     const stalledFor = stalledForMs(nowMs, rampPhase === "stalled");
     setLockupFrame(shell, {
       nowMs,
-      animating: turn.isProcessing,
+      animating: sessionLive,
       phase: label,
       rampPhase,
       stalledForMs: stalledFor,