@robota-sdk/agent-ui-terminal 3.0.0-beta.81

package/src/__tests__/abort-after-permission.test.tsx

@@ -0,0 +1,160 @@
+/**
+ * Test: ESC abort after permission prompt was shown and dismissed.
+ * Verifies that the global ESC handler remains available after overlays close.
+ */
+
+import React, { useState } from 'react';
+import { render } from 'ink-testing-library';
+import { Box, Text, useInput } from 'ink';
+import { describe, it, expect } from 'vitest';
+
+/**
+ * Simulates App's global ESC handler with permission prompt overlay guard.
+ * 1. Start with "thinking" active
+ * 2. Permission prompt appears (App-level ESC ignores while overlay is active)
+ * 3. Permission resolved (App-level ESC handles abort again)
+ * 4. ESC should trigger abort
+ */
+function AbortAfterPermissionApp({
+  onAbort,
+  onPermissionReady,
+}: {
+  onAbort: () => void;
+  onPermissionReady: (grantPermission: () => void) => void;
+}): React.ReactElement {
+  const [isThinking] = useState(true);
+  const [permissionRequest, setPermissionRequest] = useState<{
+    resolve: () => void;
+  } | null>(null);
+  const [aborted, setAborted] = useState(false);
+
+  // Give parent a way to grant permission
+  React.useEffect(() => {
+    // Show permission prompt immediately
+    const pr = {
+      resolve: () => setPermissionRequest(null),
+    };
+    setPermissionRequest(pr);
+    onPermissionReady(() => pr.resolve());
+  }, [onPermissionReady]);
+
+  // App's ESC handler — same pattern as real App.tsx
+  useInput((_input: string, key: { escape: boolean }) => {
+    if (!key.escape || !isThinking) return;
+    if (permissionRequest) return;
+    setAborted(true);
+    onAbort();
+  });
+
+  // Permission prompt's own useInput (when active)
+  useInput(
+    (_input: string, key: { return: boolean }) => {
+      if (key.return && permissionRequest) {
+        permissionRequest.resolve();
+      }
+    },
+    { isActive: !!permissionRequest },
+  );
+
+  return (
+    <Box flexDirection="column">
+      {permissionRequest && <Text color="yellow">[Permission Required]</Text>}
+      {!permissionRequest && isThinking && <Text color="cyan">Streaming...</Text>}
+      {aborted && <Text color="red">Aborted!</Text>}
+      <Text dimColor>
+        thinking={String(isThinking)} permission={String(!!permissionRequest)} aborted=
+        {String(aborted)}
+      </Text>
+    </Box>
+  );
+}
+
+describe('ESC abort after permission prompt', () => {
+  it('ESC works when no permission prompt was shown', async () => {
+    let abortCalled = false;
+    const grantHolder: { fn: (() => void) | null } = { fn: null };
+
+    const { stdin, lastFrame } = render(
+      <AbortAfterPermissionApp
+        onAbort={() => {
+          abortCalled = true;
+        }}
+        onPermissionReady={(fn) => {
+          grantHolder.fn = fn;
+        }}
+      />,
+    );
+
+    // Wait for mount
+    await new Promise((r) => setTimeout(r, 20));
+
+    // Grant permission immediately
+    grantHolder.fn?.();
+    await new Promise((r) => setTimeout(r, 50));
+
+    // Now ESC should work
+    stdin.write('\x1B');
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(abortCalled).toBe(true);
+    expect(lastFrame()!).toContain('Aborted!');
+  });
+
+  it('ESC works AFTER permission prompt was shown and dismissed', async () => {
+    let abortCalled = false;
+    const grantHolder: { fn: (() => void) | null } = { fn: null };
+
+    const { stdin, lastFrame } = render(
+      <AbortAfterPermissionApp
+        onAbort={() => {
+          abortCalled = true;
+        }}
+        onPermissionReady={(fn) => {
+          grantHolder.fn = fn;
+        }}
+      />,
+    );
+
+    // Wait for permission prompt to appear
+    await new Promise((r) => setTimeout(r, 20));
+    expect(lastFrame()!).toContain('[Permission Required]');
+
+    // Grant permission (dismiss prompt)
+    grantHolder.fn?.();
+    await new Promise((r) => setTimeout(r, 50));
+
+    // Permission dismissed, streaming should show
+    expect(lastFrame()!).toContain('Streaming...');
+    expect(lastFrame()!).not.toContain('[Permission Required]');
+
+    // Now press ESC — should trigger abort
+    stdin.write('\x1B');
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(abortCalled).toBe(true);
+    expect(lastFrame()!).toContain('Aborted!');
+  });
+
+  it('ESC does NOT work during permission prompt', async () => {
+    let abortCalled = false;
+
+    const { stdin, lastFrame } = render(
+      <AbortAfterPermissionApp
+        onAbort={() => {
+          abortCalled = true;
+        }}
+        onPermissionReady={() => {}}
+      />,
+    );
+
+    await new Promise((r) => setTimeout(r, 20));
+    expect(lastFrame()!).toContain('[Permission Required]');
+
+    // ESC during permission prompt should NOT trigger abort
+    stdin.write('\x1B');
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(abortCalled).toBe(false);
+    expect(lastFrame()!).not.toContain('Aborted!');
+  });
+});

package/src/__tests__/abort-streaming-e2e.test.tsx

@@ -0,0 +1,183 @@
+/**
+ * E2E-style test for abort during streaming.
+ * Uses ink-testing-library to verify that:
+ * 1. Streaming text debounce works (renders batched, not per-delta)
+ * 2. ESC during streaming triggers abort
+ * 3. Partial text is preserved after abort
+ */
+
+import React, { useState, useCallback, useRef, useEffect } from 'react';
+import { render } from 'ink-testing-library';
+import { Box, Text, useInput } from 'ink';
+import { describe, it, expect } from 'vitest';
+
+/**
+ * Minimal streaming component that simulates the debounced onTextDelta pattern.
+ * Accepts deltas via a callback ref, renders accumulated text.
+ */
+function StreamingTestApp({
+  onReady,
+  onAbort,
+}: {
+  onReady: (appendDelta: (text: string) => void) => void;
+  onAbort: () => void;
+}): React.ReactElement {
+  const [text, setText] = useState('');
+  const textRef = useRef('');
+  const [aborted, setAborted] = useState(false);
+  const flushTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const renderCountRef = useRef(0);
+
+  // Debounced delta handler (same pattern as InteractiveSession)
+  const appendDelta = useCallback((delta: string) => {
+    textRef.current += delta;
+    if (!flushTimerRef.current) {
+      flushTimerRef.current = setTimeout(() => {
+        setText(textRef.current);
+        flushTimerRef.current = null;
+      }, 16);
+    }
+  }, []);
+
+  // ESC handler
+  useInput((_input, key) => {
+    if (key.escape) {
+      setAborted(true);
+      onAbort();
+      // Force flush any pending text
+      if (flushTimerRef.current) {
+        clearTimeout(flushTimerRef.current);
+        flushTimerRef.current = null;
+      }
+      setText(textRef.current);
+    }
+  });
+
+  // Notify parent that we're ready
+  useEffect(() => {
+    onReady(appendDelta);
+  }, [onReady, appendDelta]);
+
+  renderCountRef.current++;
+
+  return (
+    <Box flexDirection="column">
+      <Text>{text}</Text>
+      {aborted && <Text color="yellow">Interrupted by user.</Text>}
+      <Text dimColor>renders: {renderCountRef.current}</Text>
+    </Box>
+  );
+}
+
+describe('Streaming abort E2E', () => {
+  it('debounced streaming renders fewer times than delta count', async () => {
+    let appendDelta: ((text: string) => void) | null = null;
+
+    const { lastFrame } = render(
+      React.createElement(StreamingTestApp, {
+        onReady: (fn: (text: string) => void) => {
+          appendDelta = fn;
+        },
+        onAbort: () => {},
+      }),
+    );
+
+    // Wait for component to mount
+    await new Promise((r) => setTimeout(r, 20));
+    expect(appendDelta).not.toBeNull();
+
+    // Send 20 rapid deltas
+    for (let i = 0; i < 20; i++) {
+      appendDelta!(`chunk${i} `);
+    }
+
+    // Wait for debounce flush
+    await new Promise((r) => setTimeout(r, 50));
+
+    const frame = lastFrame()!;
+    // All text should be present
+    expect(frame).toContain('chunk0');
+    expect(frame).toContain('chunk19');
+
+    // Render count should be MUCH less than 20 (debounced)
+    const renderMatch = frame.match(/renders: (\d+)/);
+    expect(renderMatch).not.toBeNull();
+    const renderCount = parseInt(renderMatch![1], 10);
+    // With 16ms debounce and ~50ms total time, expect 3-5 renders, not 20+
+    expect(renderCount).toBeLessThan(10);
+  });
+
+  it('ESC during rapid streaming triggers abort and shows text', async () => {
+    let appendDelta: ((text: string) => void) | null = null;
+    let abortCalled = false;
+
+    const { stdin, lastFrame } = render(
+      React.createElement(StreamingTestApp, {
+        onReady: (fn: (text: string) => void) => {
+          appendDelta = fn;
+        },
+        onAbort: () => {
+          abortCalled = true;
+        },
+      }),
+    );
+
+    await new Promise((r) => setTimeout(r, 20));
+
+    // Send some deltas
+    for (let i = 0; i < 5; i++) {
+      appendDelta!(`line${i} `);
+    }
+
+    // Press ESC
+    stdin.write('\x1B');
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(abortCalled).toBe(true);
+
+    const frame = lastFrame()!;
+    // Text should be visible (flush on abort)
+    expect(frame).toContain('line0');
+    expect(frame).toContain('line4');
+    // Cancelled indicator
+    expect(frame).toContain('Interrupted by user.');
+  });
+
+  it('ESC during ongoing streaming stops further rendering', async () => {
+    let appendDelta: ((text: string) => void) | null = null;
+    let abortCalled = false;
+
+    const { stdin, lastFrame } = render(
+      React.createElement(StreamingTestApp, {
+        onReady: (fn: (text: string) => void) => {
+          appendDelta = fn;
+        },
+        onAbort: () => {
+          abortCalled = true;
+        },
+      }),
+    );
+
+    await new Promise((r) => setTimeout(r, 20));
+
+    // Send first batch
+    appendDelta!('before_abort ');
+
+    // Wait for flush
+    await new Promise((r) => setTimeout(r, 20));
+
+    // Press ESC
+    stdin.write('\x1B');
+    await new Promise((r) => setTimeout(r, 30));
+
+    expect(abortCalled).toBe(true);
+
+    // Send more deltas AFTER abort (should still accumulate in ref but component should show Cancelled)
+    appendDelta!('after_abort ');
+    await new Promise((r) => setTimeout(r, 50));
+
+    const frame = lastFrame()!;
+    expect(frame).toContain('before_abort');
+    expect(frame).toContain('Interrupted by user.');
+  });
+});

package/src/__tests__/attention-bell-and-marks.test.ts

@@ -0,0 +1,144 @@
+/**
+ * CLI-2004 TC-08 / TC-09 — the two writers that reach the terminal outside Ink.
+ *
+ * Both are asserted against the exact BYTES, because that is the only channel a screen reader has:
+ * there is no `aria-live` in a terminal, so what a reader gets is what lands in the buffer.
+ */
+
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { BELL, createAttentionBell, LONG_TOOL_BELL_MS } from '../attention-bell.js';
+import { supportsTurnMarks } from '../terminal-capabilities.js';
+import { createTurnMarkWriter, turnMarkSequence } from '../terminal-marks.js';
+
+function collector(): { written: string[]; write: (text: string) => void } {
+  const written: string[] = [];
+  return { written, write: (text: string): void => void written.push(text) };
+}
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+});
+
+describe('TC-08: the attention bell', () => {
+  it('emits exactly one BEL on reply completion', () => {
+    const sink = collector();
+    createAttentionBell({ enabled: true, write: sink.write }).replyCompleted();
+    expect(sink.written).toEqual([BELL]);
+  });
+
+  it('emits exactly one BEL when a prompt mounts', () => {
+    const sink = collector();
+    createAttentionBell({ enabled: true, write: sink.write }).promptMounted();
+    expect(sink.written).toEqual([BELL]);
+  });
+
+  it('rings for a tool that outlived LONG_TOOL_BELL_MS', () => {
+    const sink = collector();
+    let now = 0;
+    const bell = createAttentionBell({ enabled: true, write: sink.write, now: () => now });
+    bell.toolStarted('Bash#0');
+    now = LONG_TOOL_BELL_MS + 1;
+    bell.toolCompleted('Bash#0');
+    expect(sink.written).toEqual([BELL]);
+  });
+
+  it('stays silent for a tool that finished under the threshold', () => {
+    const sink = collector();
+    let now = 0;
+    const bell = createAttentionBell({ enabled: true, write: sink.write, now: () => now });
+    bell.toolStarted('Bash#0');
+    now = LONG_TOOL_BELL_MS;
+    bell.toolCompleted('Bash#0');
+    expect(sink.written).toEqual([]);
+  });
+
+  it('stays silent for a completion whose start was never recorded', () => {
+    const sink = collector();
+    const bell = createAttentionBell({ enabled: true, write: sink.write });
+    bell.toolCompleted('Bash#0');
+    expect(sink.written).toEqual([]);
+  });
+
+  it('writes nothing at all when the mode is off', () => {
+    const sink = collector();
+    let now = 0;
+    const bell = createAttentionBell({ enabled: false, write: sink.write, now: () => now });
+    bell.replyCompleted();
+    bell.promptMounted();
+    bell.toolStarted('Bash#0');
+    now = LONG_TOOL_BELL_MS * 10;
+    bell.toolCompleted('Bash#0');
+    expect(sink.written).toEqual([]);
+  });
+});
+
+describe('TC-09: the OSC 133 turn marks', () => {
+  const A = '\x1b]133;A\x07';
+  const B = '\x1b]133;B\x07';
+  const C = '\x1b]133;C\x07';
+  const D = '\x1b]133;D\x07';
+
+  it('emits A, B, C, D in that order across one turn', () => {
+    const sink = collector();
+    const marks = createTurnMarkWriter({ enabled: true, supported: () => true, write: sink.write });
+    marks.emit('promptStart');
+    marks.emit('promptEnd');
+    marks.emit('turnStart');
+    marks.emit('turnEnd');
+    expect(sink.written).toEqual([A, B, C, D]);
+  });
+
+  it('spells each mark exactly', () => {
+    expect(turnMarkSequence('promptStart')).toBe(A);
+    expect(turnMarkSequence('promptEnd')).toBe(B);
+    expect(turnMarkSequence('turnStart')).toBe(C);
+    expect(turnMarkSequence('turnEnd')).toBe(D);
+  });
+
+  it('emits nothing when the mode is off', () => {
+    const sink = collector();
+    const marks = createTurnMarkWriter({
+      enabled: false,
+      supported: () => true,
+      write: sink.write,
+    });
+    marks.emit('promptStart');
+    marks.emit('turnEnd');
+    expect(sink.written).toEqual([]);
+  });
+
+  it('emits nothing when supportsTurnMarks() is false', () => {
+    const sink = collector();
+    const marks = createTurnMarkWriter({
+      enabled: true,
+      supported: () => false,
+      write: sink.write,
+    });
+    marks.emit('promptStart');
+    marks.emit('turnEnd');
+    expect(sink.written).toEqual([]);
+  });
+});
+
+describe('supportsTurnMarks — the documented negatives', () => {
+  it('is off in WezTerm, which owns OSC 133 itself', () => {
+    vi.stubEnv('ROBOTA_TURN_MARKS', '');
+    vi.stubEnv('TERM_PROGRAM', 'WezTerm');
+    expect(supportsTurnMarks()).toBe(false);
+  });
+
+  it('honours the explicit opt-in and the kill switch over everything else', () => {
+    vi.stubEnv('TERM_PROGRAM', 'WezTerm');
+    vi.stubEnv('ROBOTA_TURN_MARKS', '1');
+    expect(supportsTurnMarks({ override: true })).toBe(true);
+    vi.stubEnv('ROBOTA_TURN_MARKS', '0');
+    expect(supportsTurnMarks({ override: false })).toBe(false);
+  });
+
+  it('ignores an ambient Robota override without a host choice', () => {
+    vi.stubEnv('TERM_PROGRAM', 'WezTerm');
+    vi.stubEnv('ROBOTA_TURN_MARKS', '1');
+    expect(supportsTurnMarks()).toBe(false);
+  });
+});

package/src/__tests__/autocomplete-editing-keys.test.tsx

@@ -0,0 +1,127 @@
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { describe, expect, it, vi } from 'vitest';
+
+import InputArea from '../InputArea.js';
+import { KeybindingsProvider } from '../keybindings/keybindings-context.js';
+import { parseKeybindingsDocument } from '../keybindings/keybinding-registry.js';
+
+import type { IKeybindingsSource } from '../keybindings/node-keybindings-source.js';
+import type { ITuiCommandQueryPort } from '../tui-app-channel-port.js';
+
+async function tick(ms = 25): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+const commandQueryPort: ITuiCommandQueryPort = {
+  getCommands: (filter) =>
+    [
+      { name: 'help', description: 'Show help', source: 'test' },
+      { name: 'permissions', description: 'Permissions', source: 'test' },
+    ].filter((command) => command.name.startsWith(filter ?? '')),
+  getSubcommands: (parent) =>
+    parent === 'permissions'
+      ? [{ name: 'retry', description: 'Retry a denial', source: 'test' }]
+      : [],
+};
+
+describe('InputArea editing keys while the slash autocomplete is open', () => {
+  it('deletes with backspace', async () => {
+    const { stdin, lastFrame } = render(
+      <InputArea onSubmit={vi.fn()} isDisabled={false} commandQueryPort={commandQueryPort} />,
+    );
+    await tick();
+    stdin.write('/per');
+    await tick();
+    expect(lastFrame()).toContain('permissions');
+
+    stdin.write('\x7f');
+    await tick();
+    expect(lastFrame()).toMatch(/> \/pe$/m);
+
+    stdin.write('\x7f\x7f\x7f');
+    await tick();
+    expect(lastFrame()).toContain('Type a message or /help');
+  });
+
+  it('deletes back out of a tab-completed command whose subcommands stay listed', async () => {
+    const { stdin, lastFrame } = render(
+      <InputArea onSubmit={vi.fn()} isDisabled={false} commandQueryPort={commandQueryPort} />,
+    );
+    await tick();
+    stdin.write('/per');
+    await tick();
+    stdin.write('\t');
+    await tick();
+    expect(lastFrame()).toContain('> /permissions');
+    expect(lastFrame()).toContain('retry');
+
+    stdin.write('\x7f\x7f');
+    await tick();
+    expect(lastFrame()).toMatch(/> \/permission$/m);
+    expect(lastFrame()).not.toContain('retry');
+  });
+
+  it('clears the line with ctrl+u', async () => {
+    const { stdin, lastFrame } = render(
+      <InputArea onSubmit={vi.fn()} isDisabled={false} commandQueryPort={commandQueryPort} />,
+    );
+    await tick();
+    stdin.write('/he');
+    await tick();
+    expect(lastFrame()).toContain('help');
+
+    stdin.write('\x15');
+    await tick();
+    expect(lastFrame()).toContain('Type a message or /help');
+  });
+
+  it('moves the cursor with the arrow keys so an insertion lands mid-word', async () => {
+    const { stdin, lastFrame } = render(
+      <InputArea onSubmit={vi.fn()} isDisabled={false} commandQueryPort={commandQueryPort} />,
+    );
+    await tick();
+    stdin.write('/pe');
+    await tick();
+    expect(lastFrame()).toContain('permissions');
+    stdin.write('\x1b[D');
+    await tick();
+    stdin.write('r');
+    await tick();
+    expect(lastFrame()).toMatch(/> \/pre$/m);
+  });
+
+  it("follows the user's chat-input bindings, not the defaults", async () => {
+    const parsed = parseKeybindingsDocument(
+      JSON.stringify({ version: 1, bindings: { 'chat-input': { 'delete-line': 'ctrl+k' } } }),
+      '/tmp/keybindings.json',
+    );
+    if (!parsed.ok) throw new Error(parsed.diagnostic.message);
+    const source: IKeybindingsSource = {
+      filePath: '/tmp/keybindings.json',
+      start: async () => undefined,
+      isStarted: () => true,
+      ensureFile: async () => '/tmp/keybindings.json',
+      getSnapshot: () => parsed.snapshot,
+      subscribe: () => () => undefined,
+      dispose: () => undefined,
+    };
+    const { stdin, lastFrame } = render(
+      <KeybindingsProvider source={source}>
+        <InputArea onSubmit={vi.fn()} isDisabled={false} commandQueryPort={commandQueryPort} />
+      </KeybindingsProvider>,
+    );
+    await tick();
+    stdin.write('/he');
+    await tick();
+    expect(lastFrame()).toContain('help');
+
+    stdin.write('\x15'); // ctrl+u is no longer bound
+    await tick();
+    expect(lastFrame()).toMatch(/> \/he$/m);
+
+    stdin.write('\x0b'); // ctrl+k
+    await tick();
+    expect(lastFrame()).toContain('Type a message or /help');
+  });
+});

package/src/__tests__/background-task-panel-countdown.test.tsx

@@ -0,0 +1,75 @@
+import React from 'react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { render } from 'ink-testing-library';
+import type { IExecutionWorkspaceEntry } from '@robota-sdk/agent-interface-execution';
+import BackgroundTaskPanel from '../BackgroundTaskPanel.js';
+import { ScreenReaderProvider } from '../screen-reader-context.js';
+
+function makeEntry(overrides: Partial<IExecutionWorkspaceEntry>): IExecutionWorkspaceEntry {
+  return {
+    id: 'task:sched_1',
+    sourceId: 'sched_1',
+    kind: 'background_task',
+    origin: { kind: 'slash_command', sessionId: 'session_1', commandName: 'schedule' },
+    taskKind: 'scheduled',
+    status: 'sleeping',
+    state: 'working',
+    title: 'wake',
+    unread: false,
+    attention: 'none',
+    visibility: 'default',
+    updatedAt: '2026-01-01T00:00:00.000Z',
+    controls: ['select', 'cancel'],
+    ...overrides,
+  };
+}
+
+/** SCREEN-1992 TC-04: the tick advances the countdown once a second, only while one exists. */
+describe('BackgroundTaskPanel countdown tick', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2026-01-01T00:00:00.000Z'));
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('advances the rendered countdown every second while a schedule sleeps', async () => {
+    const { lastFrame, rerender } = render(
+      <BackgroundTaskPanel entries={[makeEntry({ nextFireAt: '2026-01-01T00:01:00.000Z' })]} />,
+    );
+    expect(lastFrame()).toContain('in 1m 0s');
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(lastFrame()).toContain('in 59s');
+    await vi.advanceTimersByTimeAsync(2000);
+    expect(lastFrame()).toContain('in 57s');
+
+    // No sleeping schedule ⇒ the tick stops: the frame no longer changes with time.
+    rerender(
+      <BackgroundTaskPanel entries={[makeEntry({ status: 'completed', state: 'completed' })]} />,
+    );
+    expect(vi.getTimerCount()).toBe(0);
+    expect(lastFrame()).not.toContain('in ');
+  });
+
+  it('never starts the tick in screen-reader mode, yet renders against the current clock', async () => {
+    // Mounted at app start with nothing scheduled, as the real panel is.
+    const { lastFrame, rerender } = render(
+      <ScreenReaderProvider enabled>
+        <BackgroundTaskPanel entries={[makeEntry({ status: 'completed', state: 'completed' })]} />
+      </ScreenReaderProvider>,
+    );
+    // Half an hour later a schedule for one minute out appears: the reader must hear `in 1m`,
+    // not the thirty minutes since mount.
+    vi.setSystemTime(new Date('2026-01-01T00:30:00.000Z'));
+    rerender(
+      <ScreenReaderProvider enabled>
+        <BackgroundTaskPanel entries={[makeEntry({ nextFireAt: '2026-01-01T00:31:00.000Z' })]} />
+      </ScreenReaderProvider>,
+    );
+    expect(lastFrame()).toContain('in 1m 0s');
+    expect(vi.getTimerCount()).toBe(0);
+    await vi.advanceTimersByTimeAsync(3000);
+    expect(lastFrame()).toContain('in 1m 0s');
+  });
+});