Keep the lockup cycling while the session is occupied

Author: TheGreatAxios

docs/TUI.md

@@ -97,14 +97,13 @@ that appears mid-prose.
 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
+identifier that is actually executing. 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
+`ACTIVITY_STATES` exported from the session chrome module 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:
 

src/subagent/fleet-report.test.ts

@@ -235,7 +235,9 @@ describe("fleetDigest", () => {
   });
 
   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([lane({ id: "api", status: "done" })], T0)).toBe(
+      "1 done",
+    );
     expect(fleetDigest([], T0)).toBe("");
   });
 

src/tui/runtime-bridge.test.ts

@@ -1379,9 +1379,11 @@ describe("idle-with-fleet (CL-7057)", () => {
           // 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(
+            (LIVE_ACTIVITY_WORDS as readonly string[]).includes(
+              shell.lockupPhase ?? "",
+            ),
+          ).toBe(true);
           expect(badgeCount(shell.session)).toBe(1);
           expect(port.calls).toEqual([]);
           await h.renderOnce();
@@ -1621,9 +1623,11 @@ describe("fleet-dry open-task drive (CL-7540)", () => {
           bridge.handle({ type: "fleet", running: 0 });
           expect(drives).toBe(0);
           expect(shell.session.run).toBe("busy");
+          expect(shell.lockupPhase).not.toBeNull();
           settleToollessTurn(bridge);
           expect(drives).toBe(1);
           expect(shell.session.run).toBe("busy");
+          expect(shell.lockupPhase).not.toBeNull();
           bridge.submit("when it finishes, summarize", "queue");
           expect(badgeCount(shell.session)).toBe(1);
           port.clear();

src/tui/runtime-bridge.ts

@@ -1011,6 +1011,11 @@ function drainLiveSteersAtBoundary(shell: AppShell, bag: BridgeBag): void {
   }
 }
 
+function occupancyHold(bag: BridgeBag, runBusy: boolean): boolean {
+  if (bag.liveFleet > 0 || bag.awaitingContinuationInference) return true;
+  return runBusy && bag.pendingDryOpenDrive;
+}
+
 /**
  * Release the run to idle and drain everything queued — but only at true
  * session-idle. A live fleet holds the run busy after the parent turn settles
@@ -1287,7 +1292,7 @@ export function attachSessionBridge(
       currentToolName: turn.currentToolName,
       streamingType: turn.streamingType,
       nowMs,
-      sessionActive: bag.liveFleet > 0,
+      sessionActive: occupancyHold(bag, shell.session.run === "busy"),
     };
     const fleet = fleetProgress(bag.agentSessions, nowMs);
     const label = resolveTurnLabel(input, isStalled, fleet);
@@ -1386,13 +1391,19 @@ export function attachSessionBridge(
       if (onTurnBoundary(event) && bag.turn.activeToolCalls.length > 0) {
         drainLiveSteersAtBoundary(shell, bag);
       }
-      if (settled) settleRun();
+      if (settled) {
+        settleRun();
+        paintPhase();
+      }
       return;
     }
     if (isBridgeInbound(event)) {
       applyInbound(shell, bag, event);
     }
-    if (settled) settleRun();
+    if (settled) {
+      settleRun();
+      paintPhase();
+    }
   };
 
   const recordLastSent = (

src/tui/session-chrome.test.ts

@@ -68,7 +68,7 @@ describe("resolveTurnLabel closed-set guarantee", () => {
       null,
     );
     // Recovery is silent — never paint "stalled" in the ticker.
-    expect(label).toBe("creating");
+    expect(label).toBe("working");
     expect(ACTIVITY_STATES).toContain(defined(label));
   });
 
@@ -150,30 +150,50 @@ describe("resolveTurnLabel", () => {
     ).toBeUndefined();
   });
 
-  test("tool phase maps to its semantic activity, never the raw name", () => {
+  test("occupied lockup cycles live-activity words, never the raw tool name", () => {
+    expect(
+      resolveTurnLabel(
+        {
+          isProcessing: true,
+          status: "running",
+          currentToolName: "grep",
+          streamingType: "tool",
+        },
+        false,
+        null,
+      ),
+    ).toBe("working");
     expect(
       resolveTurnLabel(
         {
           isProcessing: true,
           status: "running",
           currentToolName: "grep",
           streamingType: "tool",
+          nowMs: LIVE_WORD_MS,
         },
         false,
         null,
       ),
-    ).toBe("grinding");
+    ).toBe("warping");
   });
 
-  test("thinking and text phases", () => {
+  test("thinking and text phases cycle the same live-activity words", () => {
     const base = {
       isProcessing: true,
       status: "running" as const,
       currentToolName: null,
     };
     expect(
       resolveTurnLabel({ ...base, streamingType: "thinking" }, false, null),
-    ).toBe("thinking");
+    ).toBe("working");
+    expect(
+      resolveTurnLabel(
+        { ...base, streamingType: "thinking", nowMs: LIVE_WORD_MS },
+        false,
+        null,
+      ),
+    ).toBe("warping");
     expect(
       resolveTurnLabel({ ...base, streamingType: "text" }, false, null),
     ).toBe("working");
@@ -367,7 +387,7 @@ describe("fleet state in the top-level indicator", () => {
       resolveTurnLabel(parentAwaitingChildren, false, null),
     );
     expect(resolveTurnLabel(parentAwaitingChildren, true, none)).toBe(
-      "imagining",
+      "working",
     );
     expect(resolveRampPhase(parentAwaitingChildren, true, none)).toBe(
       "working",
@@ -401,6 +421,20 @@ describe("fleet state in the top-level indicator", () => {
     };
     expect(resolveTurnLabel(idleParent, false, fleet(2, 0))).toBe("working");
     expect(resolveRampPhase(idleParent, false, fleet(2, 0))).toBe("working");
+    expect(
+      resolveTurnLabel(
+        { ...idleParent, nowMs: LIVE_WORD_MS },
+        false,
+        fleet(2, 0),
+      ),
+    ).toBe("warping");
+    expect(
+      resolveTurnLabel(
+        { ...idleParent, sessionActive: true, nowMs: LIVE_WORD_MS },
+        false,
+        fleet(0, 0),
+      ),
+    ).toBe("warping");
   });
 
   test("live-activity words cycle while the session is occupied", () => {

src/tui/session-chrome.ts

@@ -76,42 +76,15 @@ export const LIVE_ACTIVITY_WORDS = [
 /** How long each live-activity word holds before the next. */
 export const LIVE_WORD_MS = 4_000;
 
-/**
- * Execution → activity-state mapping, kept in this one place with an
- * explicit fallback so a newly added tool (built-in, MCP, or plugin) renders
- * a generic "working" state instead of leaking its identifier — no ticker
- * change is required to add a tool correctly.
- */
-const TOOL_ACTIVITY_STATES: Readonly<Record<string, ActivityState>> = {
-  read_file: "grinding",
-  search_files: "grinding",
-  grep: "grinding",
-  list_dir: "grinding",
-  web_search: "grinding",
-  web_fetch: "grinding",
-  write_file: "creating",
-  edit_file: "creating",
-  run_shell: "creating",
-  delete_file: "creating",
-  manage_tasks: "imagining",
-  task: "imagining",
-  tool_search: "grinding",
-  search_agents: "grinding",
-  ask_operator: "waiting",
-  submit_output: "doing",
-};
-
-function activityStateForTool(name: string | null): ActivityState {
-  if (name === null) return "working";
-  return TOOL_ACTIVITY_STATES[name] ?? "working";
-}
-
 function liveActivityWord(nowMs: number): ActivityState {
   const index = Math.floor(nowMs / LIVE_WORD_MS) % LIVE_ACTIVITY_WORDS.length;
   return LIVE_ACTIVITY_WORDS[index] ?? "working";
 }
 
-function sessionIsLive(input: TurnLabelInput, fleet: FleetProgress | null): boolean {
+function sessionIsLive(
+  input: TurnLabelInput,
+  fleet: FleetProgress | null,
+): boolean {
   if (input.isProcessing) return true;
   if (input.sessionActive === true) return true;
   return fleet !== null && fleet.running > 0;
@@ -141,20 +114,14 @@ export function resolveTurnLabel(
   // Stopping is this parent turn aborting. A settled parent with live
   // lanes is still occupied — don't let a leftover stopping status blank
   // the lockup or freeze it on "stopping".
-  if (input.isProcessing && (input.status === "stopping" || input.status === "stopped")) {
+  if (
+    input.isProcessing &&
+    (input.status === "stopping" || input.status === "stopped")
+  ) {
     return "stopping";
   }
   if (!occupied) return undefined;
-  // Live fleet / parent continuation means the session is working — recovery
-  // is silent. Never paint "stalled" for the operator.
-  const fleetLive = fleet !== null && fleet.running > 0;
-  if (fleetLive || input.sessionActive === true) {
-    return liveActivityWord(input.nowMs ?? 0);
-  }
   void isStalled;
-  if (input.currentToolName !== null)
-    return activityStateForTool(input.currentToolName);
-  if (input.streamingType === "thinking") return "thinking";
   return liveActivityWord(input.nowMs ?? 0);
 }
 

src/tui/turn-monitor.test.ts

@@ -10,6 +10,7 @@ import { noticeText } from "./shell/chrome.js";
 import { createAppShell } from "./shell/index.js";
 import { withTestRenderer } from "./harness.js";
 import { RUNTIME_FLASH_MS } from "./runtime-notices.js";
+import { LIVE_WORD_MS } from "./session-chrome.js";
 import {
   STALL_NOTICE_MESSAGE,
   STALL_RECOVERY_MESSAGE,
@@ -71,7 +72,7 @@ describe("turn progress label", () => {
           type: "inference.thinking.delta",
           data: { token: "hm" },
         });
-        expect(t.shell.lockupPhase).toBe("thinking");
+        expect(t.shell.lockupPhase).toBe("working");
 
         t.bridge.handle({
           type: "inference.text.delta",
@@ -111,13 +112,13 @@ describe("turn progress label", () => {
         expect(t.shell.lockupPhase).toBe("working");
         const started = t.shell.lockupChangedMs;
 
-        t.advance(500);
+        t.advance(LIVE_WORD_MS);
         t.bridge.handle({
           type: "inference.thinking.delta",
           data: { token: "hm" },
         });
-        expect(t.shell.lockupPhase).toBe("thinking");
-        // A new phase restamps the fade so the crossfade starts over.
+        expect(t.shell.lockupPhase).toBe("warping");
+        // A new word restamps the fade so the crossfade starts over.
         expect(t.shell.lockupChangedMs).toBeGreaterThan(started);
 
         t.bridge.handle({ type: "reactor.done", data: {} });