Render a semantic activity state in the status ticker, not raw tool names

The ticker rendered whatever tool identifier was currently executing —
internal plumbing vocabulary leaking into a product surface, and
redundant with the transcript, which already shows the tool call.

Replace it with a closed set of human activity states (thinking,
planning, researching, building, working, waiting, stalled, stopping).
The execution-to-state mapping lives in one place with an explicit
fallback to 'working', so an unmapped tool, MCP server, or plugin name
can never reach the ticker and adding a tool needs no ticker change.
Stalled reuses the existing stall-watchdog signal rather than a second
notion of stuck, and waiting on operator approval is now its own state
distinct from active work.

Author: TheGreatAxios

src/tui-opentui/runtime-bridge.ts

@@ -805,9 +805,8 @@ export function attachSessionBridge(
       awaitingResponse: turn.awaitingResponse,
       currentToolName: turn.currentToolName,
       streamingType: turn.streamingType,
-      streamTokenCount: turn.streamTokenCount,
     }
-    const label = resolveTurnLabel(input)
+    const label = resolveTurnLabel(input, isStalled)
     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.

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

@@ -47,7 +47,7 @@ describe("resolveTurnLabel closed-set guarantee", () => {
         streamingType: "tool",
       })
       expect(label).not.toBe(currentToolName)
-      expect(ACTIVITY_STATES).toContain(label)
+      expect(ACTIVITY_STATES).toContain(label!)
     })
   }
 
@@ -63,7 +63,7 @@ describe("resolveTurnLabel closed-set guarantee", () => {
       true,
     )
     expect(label).toBe("stalled")
-    expect(ACTIVITY_STATES).toContain(label)
+    expect(ACTIVITY_STATES).toContain(label!)
   })
 
   test("waiting on the operator is distinguishable from working", () => {
@@ -76,7 +76,7 @@ describe("resolveTurnLabel closed-set guarantee", () => {
     })
     expect(label).toBe("waiting")
     expect(label).not.toBe("working")
-    expect(ACTIVITY_STATES).toContain(label)
+    expect(ACTIVITY_STATES).toContain(label!)
   })
 })
 
@@ -93,7 +93,7 @@ describe("resolveTurnLabel", () => {
     ).toBeUndefined()
   })
 
-  test("blocked gate shows approval wait", () => {
+  test("blocked gate shows a waiting-on-operator state", () => {
     expect(
       resolveTurnLabel({
         isProcessing: true,
@@ -102,7 +102,7 @@ describe("resolveTurnLabel", () => {
         currentToolName: "run_shell",
         streamingType: "tool",
       }),
-    ).toBe("blocked")
+    ).toBe("waiting")
   })
 
   test("stopping beats tool phase", () => {
@@ -117,7 +117,7 @@ describe("resolveTurnLabel", () => {
     ).toBe("stopping")
   })
 
-  test("tool phase beats generic working", () => {
+  test("tool phase maps to its semantic activity, never the raw name", () => {
     expect(
       resolveTurnLabel({
         isProcessing: true,
@@ -126,7 +126,7 @@ describe("resolveTurnLabel", () => {
         currentToolName: "grep",
         streamingType: "tool",
       }),
-    ).toBe("grep")
+    ).toBe("researching")
   })
 
   test("thinking and text phases", () => {
@@ -140,8 +140,8 @@ describe("resolveTurnLabel", () => {
       resolveTurnLabel({ ...base, streamingType: "thinking" }),
     ).toBe("thinking")
     expect(
-      resolveTurnLabel({ ...base, streamingType: "text", streamTokenCount: 7 }),
-    ).toBe("streaming 7 tok")
+      resolveTurnLabel({ ...base, streamingType: "text" }),
+    ).toBe("working")
     expect(
       resolveTurnLabel({
         ...base,
@@ -150,18 +150,6 @@ describe("resolveTurnLabel", () => {
       }),
     ).toBe("working")
   })
-
-  test("text phase with no count yet reads zero", () => {
-    expect(
-      resolveTurnLabel({
-        isProcessing: true,
-        status: "running",
-        awaitingResponse: false,
-        currentToolName: null,
-        streamingType: "text",
-      }),
-    ).toBe("streaming 0 tok")
-  })
 })
 
 describe("resolveRampPhase", () => {

src/tui-opentui/session-chrome.ts

@@ -23,31 +23,77 @@ export type TurnLabelInput = {
   readonly awaitingResponse: boolean
   readonly currentToolName: string | null
   readonly streamingType: "text" | "thinking" | "tool" | null
-  /** Text deltas seen so far this turn; read only while `streamingType` is `text`. */
-  readonly streamTokenCount?: number
+}
+
+/**
+ * Closed set the status ticker is allowed to render. Every path through
+ * `resolveTurnLabel` returns one of these — never a tool identifier, MCP
+ * server name, or plugin name. This is what the leak-prevention test checks
+ * membership against, so it must stay the single source of truth for "what
+ * can appear in the ticker."
+ */
+export const ACTIVITY_STATES = [
+  "thinking",
+  "planning",
+  "researching",
+  "building",
+  "working",
+  "waiting",
+  "stalled",
+  "stopping",
+] as const
+
+export type ActivityState = (typeof ACTIVITY_STATES)[number]
+
+/**
+ * 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: "researching",
+  search_files: "researching",
+  grep: "researching",
+  list_dir: "researching",
+  web_search: "researching",
+  web_fetch: "researching",
+  write_file: "building",
+  edit_file: "building",
+  run_shell: "building",
+  manage_tasks: "planning",
+  task: "planning",
+  ask_operator: "waiting",
+  submit_output: "working",
+}
+
+function activityStateForTool(name: string | null): ActivityState {
+  if (name === null) return "working"
+  return TOOL_ACTIVITY_STATES[name] ?? "working"
 }
 
 /**
  * Single session-phase label accompanying the density ramp. Lowercase and
  * 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.
  *
- * Text streaming carries a live count (`streaming 7 tok`) rather than the
- * bare word: it is the one phase with something to count, and the count is
- * what tells the operator the slot is not stalled.
+ * `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.
  */
-export function resolveTurnLabel(input: TurnLabelInput): string | undefined {
+export function resolveTurnLabel(
+  input: TurnLabelInput,
+  isStalled: boolean = false,
+): ActivityState | undefined {
   if (!input.isProcessing) return undefined
-  if (input.status === "blocked") return "blocked"
+  if (input.status === "blocked") return "waiting"
   if (input.status === "stopping" || input.status === "stopped") {
     return "stopping"
   }
-  if (input.currentToolName !== null) return input.currentToolName
-  if (input.streamingType === "tool") return "tool"
+  if (isStalled) return "stalled"
+  if (input.currentToolName !== null) return activityStateForTool(input.currentToolName)
   if (input.streamingType === "thinking") return "thinking"
-  if (input.streamingType === "text") {
-    return `streaming ${String(input.streamTokenCount ?? 0)} tok`
-  }
   return "working"
 }
 

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

@@ -73,16 +73,18 @@ describe("turn progress label", () => {
         expect(t.shell.lockupPhase).toBe("thinking")
 
         t.bridge.handle({ type: "inference.text.delta", data: { token: "hi" } })
-        expect(t.shell.lockupPhase).toBe("streaming 1 tok")
+        expect(t.shell.lockupPhase).toBe("working")
 
         t.bridge.handle({ type: "inference.text.delta", data: { token: " there" } })
-        expect(t.shell.lockupPhase).toBe("streaming 2 tok")
+        expect(t.shell.lockupPhase).toBe("working")
 
         t.bridge.handle({
           type: "inference.tool_call.end",
           data: { name: "bash", callId: "c1" },
         })
-        expect(t.shell.lockupPhase).toBe("bash")
+        // Unmapped tool identifiers 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: {} })
         expect(t.shell.lockupPhase).toBeNull()
@@ -223,15 +225,15 @@ describe("turn progress label", () => {
     })
   })
 
-  test("an open permission overlay freezes the ramp and reads blocked", async () => {
+  test("an open permission overlay freezes the ramp and reads waiting", async () => {
     await withTestRenderer(async (h) => {
       const t: Harness = await setup(h)
       try {
         t.bridge.handle({ type: "inference.start", data: {} })
         t.shell.overlayKind = "permissions"
         t.bridge.gateOpened()
         t.tick()
-        expect(t.shell.lockupPhase).toBe("blocked")
+        expect(t.shell.lockupPhase).toBe("waiting")
 
         // Frozen is the signal: the ramp must not move while a human is asked.
         const frozen = t.shell.lockupPhase