Make the ticker's closed set compiler-enforced and fix review findings

- AppShell.lockupPhase and LockupFrame.phase in shell.ts are now typed
  ActivityState | null instead of string | null, so a raw tool identifier
  reaching the ticker is a type error at the setLockupFrame boundary, not
  only a test failure. lockup.ts's LockupInput.phase stays a generic string
  deliberately — its own tests exercise arbitrary CJK/astral text to check
  width math unrelated to the activity vocabulary, and the leak boundary is
  already closed one layer up.
- isStalled on resolveTurnLabel is now required, matching resolveRampPhase;
  a caller that forgets it is the exact bug this state exists to prevent.
- runtime-bridge.ts's second stall check site now calls isStalledForDisplay
  instead of re-deriving 'not quiet' from stallLevel's result, so the two
  call sites share one definition of stalled.
- Dropped unread TurnLabelInput.awaitingResponse.
- docs/TUI.md corrected: it described the phase slot as showing 'the running
  tool's name', which this change makes false; it now points at
  ACTIVITY_STATES as the source of truth.
- Added delete_file/advance_workflow/tool_search/search_agents to the
  tool-to-state table.
- Test fallback case swapped from the fictional 'bash' tool to a real MCP
  identifier, since 'bash' cannot occur at runtime.

Author: TheGreatAxios

docs/TUI.md

@@ -52,9 +52,14 @@ branch at its right (`AppShell.promptTopRule` / `promptBottomRule`,
 `src/tui-opentui/shell.ts`). Both rules cost zero transcript rows because they
 ride the prompt box's own border.
 
-While a turn is live the lockup slot swaps the wordmark for the phase word —
-`thinking`, `streaming 12 tok`, the running tool's name — led by a single
-density cell (`rampPulse`, `src/tui-opentui/ramp.ts`). The cell, not the word,
+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-opentui/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
+(`rampPulse`, `src/tui-opentui/ramp.ts`). The cell, not the word,
 is what says whether the session is healthy, and it carries four states:
 
 | State | Cell | Reads as |

src/tui-opentui/runtime-bridge.ts

@@ -802,7 +802,6 @@ export function attachSessionBridge(
     const input = {
       isProcessing: turn.isProcessing,
       status: turn.status,
-      awaitingResponse: turn.awaitingResponse,
       currentToolName: turn.currentToolName,
       streamingType: turn.streamingType,
     }
@@ -1036,7 +1035,10 @@ export function attachSessionBridge(
       setStatusFlash(shell, STALL_NOTICE_MESSAGE)
     }
 
-    paintPhaseAt(nowMs, level !== "quiet")
+    // Same "is this stalled at all" question `paintPhase` asks above — call
+    // the one definition (`isStalledForDisplay`) rather than re-deriving it
+    // from `stallLevel`'s result, so the two call sites can never disagree.
+    paintPhaseAt(nowMs, isStalledForDisplay(stallArgs))
   }
 
   setShellBridgeHooks(shell, {

src/tui-opentui/session-chrome.test.ts

@@ -39,13 +39,15 @@ describe("resolveTurnLabel closed-set guarantee", () => {
 
   for (const currentToolName of leakingIdentifiers) {
     test(`"${currentToolName}" resolves to a member of the closed set`, () => {
-      const label = resolveTurnLabel({
-        isProcessing: true,
-        status: "running",
-        awaitingResponse: false,
-        currentToolName,
-        streamingType: "tool",
-      })
+      const label = resolveTurnLabel(
+        {
+          isProcessing: true,
+          status: "running",
+          currentToolName,
+          streamingType: "tool",
+        },
+        false,
+      )
       expect(label).not.toBe(currentToolName)
       expect(ACTIVITY_STATES).toContain(label!)
     })
@@ -56,7 +58,6 @@ describe("resolveTurnLabel closed-set guarantee", () => {
       {
         isProcessing: true,
         status: "running",
-        awaitingResponse: false,
         currentToolName: "run_shell",
         streamingType: "tool",
       },
@@ -67,13 +68,15 @@ describe("resolveTurnLabel closed-set guarantee", () => {
   })
 
   test("waiting on the operator is distinguishable from working", () => {
-    const label = resolveTurnLabel({
-      isProcessing: true,
-      status: "blocked",
-      awaitingResponse: false,
-      currentToolName: "run_shell",
-      streamingType: "tool",
-    })
+    const label = resolveTurnLabel(
+      {
+        isProcessing: true,
+        status: "blocked",
+        currentToolName: "run_shell",
+        streamingType: "tool",
+      },
+      false,
+    )
     expect(label).toBe("waiting")
     expect(label).not.toBe("working")
     expect(ACTIVITY_STATES).toContain(label!)
@@ -83,79 +86,81 @@ describe("resolveTurnLabel closed-set guarantee", () => {
 describe("resolveTurnLabel", () => {
   test("idle processing off yields no label", () => {
     expect(
-      resolveTurnLabel({
-        isProcessing: false,
-        status: "idle",
-        awaitingResponse: false,
-        currentToolName: null,
-        streamingType: null,
-      }),
+      resolveTurnLabel(
+        {
+          isProcessing: false,
+          status: "idle",
+          currentToolName: null,
+          streamingType: null,
+        },
+        false,
+      ),
     ).toBeUndefined()
   })
 
   test("blocked gate shows a waiting-on-operator state", () => {
     expect(
-      resolveTurnLabel({
-        isProcessing: true,
-        status: "blocked",
-        awaitingResponse: false,
-        currentToolName: "run_shell",
-        streamingType: "tool",
-      }),
+      resolveTurnLabel(
+        {
+          isProcessing: true,
+          status: "blocked",
+          currentToolName: "run_shell",
+          streamingType: "tool",
+        },
+        false,
+      ),
     ).toBe("waiting")
   })
 
   test("stopping beats tool phase", () => {
     expect(
-      resolveTurnLabel({
-        isProcessing: true,
-        status: "stopping",
-        awaitingResponse: false,
-        currentToolName: "grep",
-        streamingType: "tool",
-      }),
+      resolveTurnLabel(
+        {
+          isProcessing: true,
+          status: "stopping",
+          currentToolName: "grep",
+          streamingType: "tool",
+        },
+        false,
+      ),
     ).toBe("stopping")
   })
 
   test("tool phase maps to its semantic activity, never the raw name", () => {
     expect(
-      resolveTurnLabel({
-        isProcessing: true,
-        status: "running",
-        awaitingResponse: true,
-        currentToolName: "grep",
-        streamingType: "tool",
-      }),
+      resolveTurnLabel(
+        {
+          isProcessing: true,
+          status: "running",
+          currentToolName: "grep",
+          streamingType: "tool",
+        },
+        false,
+      ),
     ).toBe("researching")
   })
 
   test("thinking and text phases", () => {
     const base = {
       isProcessing: true,
       status: "running" as const,
-      awaitingResponse: false,
       currentToolName: null,
     }
     expect(
-      resolveTurnLabel({ ...base, streamingType: "thinking" }),
+      resolveTurnLabel({ ...base, streamingType: "thinking" }, false),
     ).toBe("thinking")
     expect(
-      resolveTurnLabel({ ...base, streamingType: "text" }),
+      resolveTurnLabel({ ...base, streamingType: "text" }, false),
     ).toBe("working")
     expect(
-      resolveTurnLabel({
-        ...base,
-        awaitingResponse: true,
-        streamingType: null,
-      }),
+      resolveTurnLabel({ ...base, streamingType: null }, false),
     ).toBe("working")
   })
 })
 
 describe("resolveRampPhase", () => {
   const base = {
     isProcessing: true,
-    awaitingResponse: false,
     currentToolName: null,
     streamingType: null,
   }

src/tui-opentui/session-chrome.ts

@@ -20,7 +20,6 @@ export type TurnStatus =
 export type TurnLabelInput = {
   readonly isProcessing: boolean
   readonly status: TurnStatus
-  readonly awaitingResponse: boolean
   readonly currentToolName: string | null
   readonly streamingType: "text" | "thinking" | "tool" | null
 }
@@ -61,8 +60,12 @@ const TOOL_ACTIVITY_STATES: Readonly<Record<string, ActivityState>> = {
   write_file: "building",
   edit_file: "building",
   run_shell: "building",
+  delete_file: "building",
   manage_tasks: "planning",
   task: "planning",
+  advance_workflow: "planning",
+  tool_search: "researching",
+  search_agents: "researching",
   ask_operator: "waiting",
   submit_output: "working",
 }
@@ -77,14 +80,16 @@ function activityStateForTool(name: string | null): ActivityState {
  * unpunctuated — the ramp's color and motion carry the state, so the word only
  * has to name it. Returns undefined when idle so the phase segment disappears.
  *
- * `isStalled` is the caller's own `shouldNoticeStall`/`isStalledForDisplay`
- * result (see stall-watchdog.ts) — this function does not re-derive
- * staleness, it only ranks "stalled" against the other phases so the ticker
- * and the ramp never disagree about which runs look stuck.
+ * `isStalled` is the caller's own `isStalledForDisplay` result (see
+ * stall-watchdog.ts) — this function does not re-derive staleness, it only
+ * ranks "stalled" against the other phases so the ticker and the ramp never
+ * disagree about which runs look stuck. Required, not defaulted: a caller
+ * that forgets to pass it is exactly the bug this state exists to prevent —
+ * a wedged run silently painted as ordinary work.
  */
 export function resolveTurnLabel(
   input: TurnLabelInput,
-  isStalled: boolean = false,
+  isStalled: boolean,
 ): ActivityState | undefined {
   if (!input.isProcessing) return undefined
   if (input.status === "blocked") return "waiting"

src/tui-opentui/shell.ts

@@ -69,6 +69,7 @@ import {
   type LockupInput,
 } from "./lockup.js"
 import type { RampPhase, StallAge } from "./ramp.js"
+import type { ActivityState } from "./session-chrome.js"
 import {
   BORDER,
   composeCostContextMeter,
@@ -641,8 +642,12 @@ export type AppShell = {
    */
   lockupNowMs: number
   lockupAnimating: boolean
-  /** Live phase word the slot shows, or null for the idle wordmark. */
-  lockupPhase: string | null
+  /**
+   * Live activity state the slot shows, or null for the idle wordmark.
+   * Typed to the closed set (not `string`) so a raw tool/MCP/plugin
+   * identifier reaching this field is a compile error, not just a test one.
+   */
+  lockupPhase: ActivityState | null
   /** Clock reading when `lockupPhase` last changed — the fade's origin. */
   lockupChangedMs: number
   /** Density ramp phase for the same turn — drives the slot's pulse cell and tint. */
@@ -876,8 +881,11 @@ function syncLandingSuggestions(shell: AppShell): void {
 export type LockupFrame = {
   readonly nowMs: number
   readonly animating: boolean
-  /** Live phase word, or null for the idle wordmark. */
-  readonly phase: string | null
+  /**
+   * Live activity state, or null for the idle wordmark. Typed to the closed
+   * set so the caller cannot hand this a raw tool identifier.
+   */
+  readonly phase: ActivityState | null
   /** The turn's ramp phase, or null when idle. */
   readonly rampPhase: RampPhase | null
   /** How long the turn has been stalled, or null when it is not stalled. */

src/tui-opentui/turn-monitor.test.ts

@@ -80,10 +80,10 @@ describe("turn progress label", () => {
 
         t.bridge.handle({
           type: "inference.tool_call.end",
-          data: { name: "bash", callId: "c1" },
+          data: { name: "mcp__glitchtip__resolve_issue", callId: "c1" },
         })
-        // Unmapped tool identifiers fall back to the generic working state
-        // rather than leaking the raw name.
+        // Unmapped tool identifiers — including MCP tools — fall back to the
+        // generic working state rather than leaking the raw name.
         expect(t.shell.lockupPhase).toBe("working")
 
         t.bridge.handle({ type: "reactor.done", data: {} })