Clear the stall notice on paint, not only on the watchdog tick

The cadence timer is cancelled the moment the turn settles, so a tool.done then inference.done burst that lands before the next tick would otherwise leave the banner up forever.

Author: TheGreatAxios

CHANGELOG.md

@@ -11,6 +11,19 @@ matching `## [X.Y.Z]` section (plus install instructions). Do not maintain
 parallel copies under `docs/` or `scripts/notes/`. At cut time: rename
 `## [Unreleased]` to `## [X.Y.Z] - YYYY-MM-DD`, then run the release script.
 
+## [Unreleased]
+
+### TUI
+
+- **In-flight tool rows show elapsed time.** Ordinary pending calls (MCP,
+  search, shell) tick a live clock the same way Task rows already do, so a
+  slow-but-alive call is distinguishable from a hung turn.
+
+- **The stall notice comes down the moment activity resumes.** It is a live
+  diagnosis, not a sticky banner: a tool finishing or the turn settling
+  clears it on that paint, even if the monitor tick has already been
+  cancelled.
+
 ## [0.2.102] - 2026-08-22
 
 ### Permissions

docs/TUI.md

@@ -140,6 +140,9 @@ instant a tool batch resolves and `awaitingResponse` flips back to true).
 That wait has no signal to tell "still coming" from "never coming" apart, so
 it is never auto-aborted no matter how long it runs; it still surfaces via
 the notice, keeping the operator in control of whether to give up on it.
+The notice is a live diagnosis, not a sticky banner: it comes down on the
+same paint as the activity that ends the silence, including when the turn
+settles before the next monitor tick.
 
 An idle session animates nothing at all: the monitor tick stops entirely
 rather than repainting an unchanging frame.
@@ -211,7 +214,10 @@ operator-preferred Amp/Codex-style lines:
 
 `runtime-bridge` paints each `task` call as a stream row and rewrites it in
 place via `syncAgentProgress` / `agentProgress` (elapsed clock, current tool,
-stall marker). There is no standing FLEET board and no dual-rail agents chrome:
+stall marker). Ordinary in-flight tool rows get the same elapsed clock
+(`syncToolElapsed`) without the current-tool suffix, so a slow MCP or
+network call is distinguishable from a hung turn. There is no standing
+FLEET board and no dual-rail agents chrome:
 `formatChromeZones` always returns both zones null (`task` and `agents`), and
 geometry is stack-only (`layoutMode: "stack"`, `railWidth: 0`). Checklist and
 agents strips are parked pending rebuild; Alt+T / direct `setChromeZones` may

src/tui/runtime-bridge.ts

@@ -927,6 +927,17 @@ export function attachSessionBridge(
 
   const paintPhaseAt = (nowMs: number, isStalled: boolean): void => {
     const turn = bag.turn
+    // The stall notice is a live diagnosis, not a sticky banner: it has to
+    // set *and* clear on every paint — including handle() — because the
+    // cadence timer is cancelled the moment the turn settles. If we only
+    // touched it from tick(), a tool.done → inference.done burst that lands
+    // before the next tick would leave the banner up forever.
+    const level = stallLevel(stallArgsFor(nowMs))
+    if (level === "notice") {
+      setStatusFlash(shell, STALL_NOTICE_MESSAGE)
+    } else if (shell.statusFlash === STALL_NOTICE_MESSAGE) {
+      setStatusFlash(shell, null)
+    }
     // The landing mark rides this same re-entry: it animates through the
     // draw/fill loop while a turn is live and holds its filled frame otherwise.
     paintLanding(shell, nowMs, turn.isProcessing)
@@ -1216,18 +1227,6 @@ export function attachSessionBridge(
       return
     }
 
-    // Notice only — the phase still paints below, because a ramp that stops
-    // moving is the very thing that reads as a hang.
-    const level = stallLevel(stallArgs)
-    if (level === "notice") {
-      setStatusFlash(shell, STALL_NOTICE_MESSAGE)
-    } else if (shell.statusFlash === STALL_NOTICE_MESSAGE) {
-      // Activity resumed after the notice was posted: it carries no ttl (it
-      // must stay up for as long as the silence lasts), so nothing else would
-      // ever take it down once the run starts producing again.
-      setStatusFlash(shell, null)
-    }
-
     // 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.

src/tui/turn-monitor.test.ts

@@ -338,9 +338,30 @@ describe("stall watchdog", () => {
         expect(t.shell.statusFlash).toBe(STALL_NOTICE_MESSAGE)
 
         // The model starts producing again — the notice must not linger past
-        // the silence it was reporting.
+        // the silence it was reporting. handle() itself has to take it down;
+        // waiting for the next tick leaves a window where the turn can settle
+        // and cancel the cadence, which would strand the banner forever.
         t.bridge.handle({ type: "inference.text.delta", data: { token: "ok" } })
+        expect(t.shell.statusFlash).not.toBe(STALL_NOTICE_MESSAGE)
+      } finally {
+        t.bridge.dispose()
+      }
+    })
+  })
+
+  test("clears the notice when the turn settles before the next tick", async () => {
+    await withTestRenderer(async (h) => {
+      const t: Harness = await setup(h)
+      try {
+        t.bridge.submit("build it", "immediate")
+        t.port.clear()
+
+        t.advance(500)
         t.tick()
+        expect(t.shell.statusFlash).toBe(STALL_NOTICE_MESSAGE)
+
+        t.bridge.handle({ type: "inference.done", data: {} })
+        // Cadence is cancelled on settle. The notice has to already be gone.
         expect(t.shell.statusFlash).not.toBe(STALL_NOTICE_MESSAGE)
       } finally {
         t.bridge.dispose()