Auto-dismiss temporary status flashes on the notice row

One-shot confirmations now pass a TTL at the call site so they clear
themselves. Rate-limit countdown no longer parks on the bottom chrome;
the durable error stays in the transcript, and only clear-and-resubmit
flashes briefly.

Author: TheGreatAxios

docs/TUI.md

@@ -546,7 +546,9 @@ running its own selection. Two chords cover remaining copy needs:
   (`CliRenderEvents.SELECTION` → `copyFinishedSelection` in
   `selection-copy.ts`). On mouse-up, non-empty selected text is written
   through the system clipboard port and the highlight clears with a status
-  flash. Empty clicks do not copy.
+  flash. Empty clicks do not copy. Confirmation flashes pass
+  `ttlMs: RUNTIME_FLASH_MS` so they clear themselves; omit TTL only for
+  live conditions that stay true until replaced (stall notice, landing hold).
 - **Alt+M** toggles DEC mouse reporting off and back on
   (`toggleMouseCapture`, `shell.ts`). Off, the terminal's own drag-select
   and copy work exactly as in any other terminal program; the status flash

src/tui/copy-wire.test.ts

@@ -8,8 +8,10 @@ import {
   createAppShell,
   enterCopyMode,
   toggleMouseCapture,
+  type FlashSchedule,
 } from "./shell";
 import { createRecordingClipboard } from "./copy-path";
+import { RUNTIME_FLASH_MS } from "./runtime-notices";
 
 // One renderer for the whole file: harness renderers are a scarce native
 // resource and the suite exhausts them when every test claims its own.
@@ -23,6 +25,15 @@ afterAll(() => {
   harness.destroy();
 });
 
+/** Capture scheduled flash expiries so tests can lapse without wall time. */
+function capturingSchedule(lapse: (() => void)[], expectedMs = RUNTIME_FLASH_MS): FlashSchedule {
+  return (fn, ms) => {
+    expect(ms).toBe(expectedMs);
+    lapse.push(fn);
+    return () => {};
+  };
+}
+
 describe("Alt+C reaches the injected clipboard", () => {
   test("confirming a copy target writes its text", () => {
     const clipboard = createRecordingClipboard();
@@ -46,6 +57,36 @@ describe("Alt+C reaches the injected clipboard", () => {
     expect(clipboard.writes[0]).toContain("two");
     shell.dispose();
   });
+
+  test("copy confirmation clears itself when the flash window lapses", () => {
+    const lapse: (() => void)[] = [];
+    const clipboard = createRecordingClipboard();
+    const shell = createAppShell(harness.renderer, {
+      clipboard,
+      flashSchedule: capturingSchedule(lapse),
+    });
+    appendStreamRow(shell, { role: "assistant", text: "copy me" });
+    enterCopyMode(shell);
+    expect(confirmCopySelection(shell)).toBe(true);
+    expect(shell.statusFlash).toContain("Copied");
+    expect(lapse).toHaveLength(1);
+    lapse[0]?.();
+    expect(shell.statusFlash).toBeNull();
+    shell.dispose();
+  });
+
+  test("nothing-to-copy flash clears itself when the window lapses", () => {
+    const lapse: (() => void)[] = [];
+    const shell = createAppShell(harness.renderer, {
+      flashSchedule: capturingSchedule(lapse),
+    });
+    expect(enterCopyMode(shell)).toBe(false);
+    expect(shell.statusFlash).toBe("nothing to copy");
+    expect(lapse).toHaveLength(1);
+    lapse[0]?.();
+    expect(shell.statusFlash).toBeNull();
+    shell.dispose();
+  });
 });
 
 describe("drag-select auto-copy", () => {
@@ -62,6 +103,24 @@ describe("drag-select auto-copy", () => {
     shell.dispose();
   });
 
+  test("SELECTION flash clears itself when the window lapses", () => {
+    const lapse: (() => void)[] = [];
+    const clipboard = createRecordingClipboard();
+    const shell = createAppShell(harness.renderer, {
+      clipboard,
+      flashSchedule: capturingSchedule(lapse),
+    });
+    harness.renderer.emit(CliRenderEvents.SELECTION, {
+      isDragging: false,
+      getSelectedText: () => "dragged snippet",
+    });
+    expect(shell.statusFlash).toContain("Copied 15 chars");
+    expect(lapse).toHaveLength(1);
+    lapse[0]?.();
+    expect(shell.statusFlash).toBeNull();
+    shell.dispose();
+  });
+
   test("SELECTION while dragging is a no-op", () => {
     const clipboard = createRecordingClipboard();
     const shell = createAppShell(harness.renderer, { clipboard });
@@ -105,6 +164,26 @@ describe("Alt+M mouse capture", () => {
     shell.dispose();
   });
 
+  test("mouse-toggle flash clears itself when the window lapses", () => {
+    const lapse: (() => void)[] = [];
+    let enabled = false;
+    const shell = createAppShell(harness.renderer, {
+      flashSchedule: capturingSchedule(lapse),
+      mouseCapture: {
+        get: () => enabled,
+        set: (v) => {
+          enabled = v;
+        },
+      },
+    });
+    expect(toggleMouseCapture(shell)).toBe(true);
+    expect(shell.statusFlash).toContain("drag text to copy");
+    expect(lapse).toHaveLength(1);
+    lapse[0]?.();
+    expect(shell.statusFlash).toBeNull();
+    shell.dispose();
+  });
+
   test("reports unavailable when the host exposes no control", () => {
     const shell = createAppShell(harness.renderer);
     expect(toggleMouseCapture(shell)).toBeNull();

src/tui/prompt-chrome.test.ts

@@ -16,6 +16,7 @@ import {
   setStatusFlash,
   submitPrompt,
 } from "./shell";
+import { RUNTIME_FLASH_MS } from "./runtime-notices";
 import { UI } from "./theme";
 
 async function withShell(
@@ -295,12 +296,21 @@ describe("no permanent hint strip", () => {
 
   test("state that is only sometimes true takes a row only while it is true", async () => {
     await withShell((shell) => {
-      setStatusFlash(shell, "copied 3 lines");
+      const lapse: (() => void)[] = [];
+      setStatusFlash(shell, "copied 3 lines", {
+        ttlMs: RUNTIME_FLASH_MS,
+        schedule: (fn, ms) => {
+          expect(ms).toBe(RUNTIME_FLASH_MS);
+          lapse.push(fn);
+          return () => {};
+        },
+      });
       expect(noticeText(shell)).toContain("copied 3 lines");
       expect(shell.layout.heights.notice).toBe(1);
       expect(shell.notice.visible).toBe(true);
 
-      setStatusFlash(shell, null);
+      lapse[0]?.();
+      expect(shell.statusFlash).toBeNull();
       expect(noticeText(shell)).toBe("");
       expect(shell.layout.heights.notice).toBe(0);
       expect(shell.notice.visible).toBe(false);

src/tui/prompt-features.test.ts

@@ -21,7 +21,9 @@ import {
   setShellBridgeHooks,
   submitPrompt,
   type AppShell,
+  type FlashSchedule,
 } from "./shell";
+import { RUNTIME_FLASH_MS } from "./runtime-notices";
 
 const CLIP: PendingImageAttachment = {
   id: "clip-1",
@@ -51,14 +53,15 @@ const CLIP_OTHER: PendingImageAttachment = {
 
 function withShell(
   fn: (shell: AppShell) => Promise<void>,
-  opts?: { readonly wireKeys?: boolean },
+  opts?: { readonly wireKeys?: boolean; readonly flashSchedule?: FlashSchedule },
 ): Promise<void> {
   return withTestRenderer(
     async (h) => {
       const shell = createAppShell(h.renderer, {
         terminal: { columns: 80, rows: 24 },
         wireKeys: opts?.wireKeys ?? true,
         run: "idle",
+        ...(opts?.flashSchedule !== undefined ? { flashSchedule: opts.flashSchedule } : {}),
       });
       try {
         await fn(shell);
@@ -91,6 +94,47 @@ describe("image attachments", () => {
     });
   });
 
+  test("fail / attached / duplicate confirmation flashes expire via flashSchedule", async () => {
+    const lapse: (() => void)[] = [];
+    const flashSchedule: FlashSchedule = (fn, ms) => {
+      expect(ms).toBe(RUNTIME_FLASH_MS);
+      lapse.push(fn);
+      return () => {};
+    };
+
+    await withShell(
+      async (shell) => {
+        setPromptImageSource(shell, async () => ({ ok: false, reason: "no PNG" }));
+        expect(await attachClipboardImage(shell)).toBe(false);
+        expect(shell.statusFlash).toContain("no PNG");
+        expect(lapse).toHaveLength(1);
+        lapse[0]?.();
+        expect(shell.statusFlash).toBeNull();
+      },
+      { flashSchedule },
+    );
+
+    lapse.length = 0;
+    await withShell(
+      async (shell) => {
+        setPromptImageSource(shell, async () => ({ ok: true, attachment: CLIP }));
+        expect(await attachClipboardImage(shell)).toBe(true);
+        expect(shell.statusFlash).toContain("attached clipboard.png");
+        expect(lapse).toHaveLength(1);
+        lapse[0]?.();
+        expect(shell.statusFlash).toBeNull();
+
+        setPromptImageSource(shell, async () => ({ ok: true, attachment: CLIP_SAME_CONTENT }));
+        expect(await attachClipboardImage(shell)).toBe(false);
+        expect(shell.statusFlash).toContain(`${CLIP.name} is already attached`);
+        expect(lapse).toHaveLength(2);
+        lapse[1]?.();
+        expect(shell.statusFlash).toBeNull();
+      },
+      { flashSchedule },
+    );
+  });
+
   test("quitting mid-read does not attach into the disposed shell", async () => {
     await withTestRenderer(
       async (h) => {

src/tui/prompt-slash-exit.test.ts

@@ -17,6 +17,7 @@ import {
   setStatusFlash,
   type AppShell,
 } from "./shell";
+import { RUNTIME_FLASH_MS } from "./runtime-notices";
 
 const CATALOG: readonly PaletteCommand[] = [
   {
@@ -241,7 +242,15 @@ describe("Ctrl+C exit", () => {
           return () => {};
         },
       });
-      setStatusFlash(shell, "copied 3 lines");
+      setStatusFlash(shell, "copied 3 lines", {
+        ttlMs: RUNTIME_FLASH_MS,
+        schedule: (fn) => {
+          // Armed but not fired — the ctrl+c window must not clear it.
+          return () => {
+            void fn;
+          };
+        },
+      });
       lapse[0]?.();
       expect(shell.statusFlash).toBe("copied 3 lines");
     });

src/tui/runner.ts

@@ -198,6 +198,7 @@ import {
   setStatusFlash,
   surfaceSystemNotice,
 } from "./shell.js";
+import { RUNTIME_FLASH_MS } from "./runtime-notices.js";
 import {
   captureAuthFailure,
   classifyAgentSendFailure,
@@ -2619,7 +2620,9 @@ export async function runTUI(initialConfig: Config): Promise<number> {
         isCodexProviderName(config.providerName),
       );
       if (next === undefined) {
-        setStatusFlash(host.shell, "this model has no reasoning effort levels");
+        setStatusFlash(host.shell, "this model has no reasoning effort levels", {
+          ttlMs: RUNTIME_FLASH_MS,
+        });
         return;
       }
       config = { ...config, reasoningEffort: next };
@@ -2630,7 +2633,9 @@ export async function runTUI(initialConfig: Config): Promise<number> {
         model: config.model,
         effort: next,
       });
-      setStatusFlash(host.shell, `reasoning effort: ${next}`);
+      setStatusFlash(host.shell, `reasoning effort: ${next}`, {
+        ttlMs: RUNTIME_FLASH_MS,
+      });
     });
 
     // Recall spans the whole session, including what was sent before a resume.

src/tui/runtime-bridge.ts

@@ -34,7 +34,8 @@ import {
 import { rampAnimating } from "./ramp.js";
 import { onTurnBoundary } from "../agent/reactor-events.js";
 import { resolveRampPhase, resolveTurnLabel, sendFailureText } from "./session-chrome.js";
-import { quotaWaitSeconds, shouldAutoRetryQuota } from "./quota-retry.js";
+import { shouldAutoRetryQuota } from "./quota-retry.js";
+import { RUNTIME_FLASH_MS } from "./runtime-notices.js";
 import {
   applyStallRecovery,
   repetitionRecoveryMessage,
@@ -1153,16 +1154,16 @@ export function attachSessionBridge(
       bag.quotaFired = true;
       const replay = bag.lastSentMessage;
       bag.turn = clearQuotaWait(bag.turn);
-      setStatusFlash(shell, "rate limit cleared — resubmitting");
+      setStatusFlash(shell, "rate limit cleared — resubmitting", {
+        ttlMs: RUNTIME_FLASH_MS,
+      });
       submit(replay, "immediate");
       return;
     }
 
     if (quota !== null) {
-      setStatusFlash(
-        shell,
-        `rate limited — retrying in ${quotaWaitSeconds(quota.retryAt, nowMs)}s`,
-      );
+      // Durable error already lives in the transcript; do not park a sticky
+      // countdown flash that outlives every other confirmation.
       return;
     }
 
@@ -1180,7 +1181,10 @@ export function attachSessionBridge(
     if (bag.turn.status === "running" && bag.turn.repeating) {
       const repeatedTokens = bag.turn.streamTokenCount - (bag.turn.repeatingSinceTokenCount ?? 0);
       applyStallRecovery(
-        { abort: doInterrupt, notify: (message) => setStatusFlash(shell, message) },
+        {
+          abort: doInterrupt,
+          notify: (message) => setStatusFlash(shell, message, { ttlMs: RUNTIME_FLASH_MS }),
+        },
         repetitionRecoveryMessage(repeatedTokens),
       );
       return;
@@ -1190,7 +1194,10 @@ export function attachSessionBridge(
 
     if (shouldAbortForStall(stallArgs)) {
       applyStallRecovery(
-        { abort: doInterrupt, notify: (message) => setStatusFlash(shell, message) },
+        {
+          abort: doInterrupt,
+          notify: (message) => setStatusFlash(shell, message, { ttlMs: RUNTIME_FLASH_MS }),
+        },
         STALL_RECOVERY_MESSAGE,
       );
       return;