@aragon-agent/cli 0.5.8 → 0.5.9

package/dist/ui/PromptInput.js

@@ -127,7 +127,7 @@ function isControlSeq(input) {
 // ---------------------------------------------------------------------------
 // Component
 // ---------------------------------------------------------------------------
-export function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, agentMode, onSubmit, onHelp, bordered, onDraftChange, historyIntent, }) {
+export function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, agentMode, onSubmit, onHelp, bordered, onDraftChange, }) {
     const [buffer, setBuffer] = useState('');
     const [cursor, setCursor] = useState(0);
     const [historyIndex, setHistoryIndex] = useState(null);
@@ -261,43 +261,6 @@ export function PromptInput({ isActive, running, history, commands, cwd, theme,
                 recallDown();
         }
     };
-    // --- Wheel-driven history step (mouse-wheel-region-routing §5.6). ---------
-    // The applier closes over the buffer, the cursor and the popup state, so it
-    // is re-created on every render and reached through a ref: depending on it
-    // directly would re-fire the effect on every keystroke.
-    const applyHistoryIntent = useRef(() => { });
-    applyHistoryIntent.current = (dir) => {
-        // Mirrors the keyboard branch exactly — with the completion popup open,
-        // Up/Down move the selection rather than recalling history.
-        if (popupItems.length > 0) {
-            setSel(dir === 'up'
-                ? Math.max(0, clampedSel - 1)
-                : Math.min(popupItems.length - 1, clampedSel + 1));
-            return;
-        }
-        verticalOrHistory(dir);
-    };
-    const historyIntentRef = useRef(historyIntent);
-    historyIntentRef.current = historyIntent;
-    // I-9: seeded from the incoming nonce during the FIRST render, so a mount
-    // that inherits a nonce cannot replay it. This component really does remount
-    // — `App` returns the terminal-too-small placeholder before `AppShell` —
-    // so without the guard, shrinking the window mid-wheel and growing it back
-    // recalls a history entry with no gesture behind it.
-    const lastHistoryNonce = useRef(historyIntent?.nonce);
-    const historyNonce = historyIntent?.nonce ?? 0;
-    useEffect(() => {
-        const current = historyIntentRef.current;
-        if (!current || !isActive)
-            return;
-        if (current.nonce === lastHistoryNonce.current)
-            return;
-        lastHistoryNonce.current = current.nonce;
-        applyHistoryIntent.current(current.dir);
-        // Keyed on the nonce alone, same reasoning as `ScrollViewport`'s intent
-        // effect: `historyIntent` is a fresh object on every parent render.
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [historyNonce]);
     // --- Input handling. -----------------------------------------------------
     useInput((input, key) => {
         // FIRST STATEMENT, BEFORE THE POPUP BRANCH, AND IT HAS TO STAY THERE.

package/dist/ui/StatusBar.d.ts

@@ -88,6 +88,25 @@ interface StatusBarProps {
         done: number;
         total: number;
     };
+    /**
+     * Live retry state (llm-api-retry-backoff §6.6), or absent when nothing is
+     * retrying — an ordinary session's bar is then unchanged.
+     *
+     * LEFT CLUSTER, after `teamActive`, and it DEGRADES. It is a run-state fact like
+     * `agents 3/5`, and the left cluster is `flexShrink={0}` so every column it takes
+     * comes out of the context gauge; below `RETRY_UI.statusCompactCols` it renders
+     * as `[r3]`.
+     *
+     * This does NOT contradict the "no `cols >= N` breakpoint" rule on `agentMode`
+     * above: that rule exists because the MODE must never be unreportable. The retry
+     * has a second, fuller home in the transcript card, which is exactly why it is
+     * the kind of readout that can afford to shrink.
+     */
+    retryActive?: {
+        attempt: number;
+        max: number;
+        secondsLeft: number;
+    };
     /**
      * Render-governor rung (tui-render-performance L4). `> 0` renders a muted
      * `eco` chip.
@@ -101,6 +120,24 @@ interface StatusBarProps {
      * eco chip on a 50-column terminal costs the context gauge more than it says.
      */
     ecoRung?: number;
+    /**
+     * The live fast tier (fast-model-tier §6), or absent when it is off for this
+     * session — in which case an ordinary session's bar is byte-identical.
+     *
+     * RIGHT CLUSTER, next to `eco`, and it DEGRADES below
+     * `FAST_LIMITS.statusCompactCols`. This is the `teamActive` / `ecoRung`
+     * treatment rather than the `agentMode` one, and the distinction is the note
+     * on `agentMode` above: the mode must never be unreportable, whereas the fast
+     * tier has a fuller home in `/fast status` — which is the GUARANTEED reporting
+     * surface — and a chip on a 60-column terminal costs the context gauge more
+     * than it says.
+     *
+     * `inFlight` renders `fast*`, so a review that is taking a while is visible
+     * without a spinner competing with the run's own.
+     */
+    fastActive?: {
+        inFlight: boolean;
+    };
 }
 export declare function StatusBar(props: StatusBarProps): React.ReactElement;
 export {};

package/dist/ui/StatusBar.js

@@ -4,6 +4,8 @@ import { pickGlyphs } from './glyphs.js';
 import { formatCost, formatTokens, formatDuration } from '../agent/usage.js';
 import { buildGauge } from './gauge.js';
 import { MODE_LABEL } from '../agent/agent-mode.js';
+import { formatRetryChip } from '../agent/retry-view.js';
+import { FAST_LIMITS } from '../fast/limits.js';
 import { TEAM_LIMITS } from '../team/limits.js';
 import { TODO_LIMITS } from '../todo/limits.js';
 /** Below this the `eco` chip costs the context gauge more than it is worth. */
@@ -27,7 +29,7 @@ function redrawChar(nonce) {
     return nonce % 2 === 0 ? ' ' : NBSP;
 }
 export function StatusBar(props) {
-    const { model, provider, usageTotal, contextTokens, contextWindow, contextWindowKnown, status, elapsedMs, thinkingLevel, tokPerSec, theme, caps, scrolledLines = 0, redrawNonce = 0, agentMode = 'build', pendingAgentMode = null, teamActive, todoActive, ecoRung = 0, } = props;
+    const { model, provider, usageTotal, contextTokens, contextWindow, contextWindowKnown, status, elapsedMs, thinkingLevel, tokPerSec, theme, caps, scrolledLines = 0, redrawNonce = 0, agentMode = 'build', pendingAgentMode = null, teamActive, todoActive, retryActive, ecoRung = 0, fastActive, } = props;
     const { stdout } = useStdout();
     const cols = stdout?.columns ?? 80;
     const running = status === 'running';
@@ -53,7 +55,7 @@ export function StatusBar(props) {
     // land in one predictable place.
     _jsxs(Box, { flexDirection: "row", justifyContent: "space-between", flexShrink: 0, children: [_jsxs(Box, { flexDirection: "row", flexShrink: 0, children: [_jsxs(Text, { color: running ? theme.toolRunning : theme.toolDone, children: [redrawChar(redrawNonce), statusGlyph, " ", running ? 'running' : 'idle'] }), modeWord && (_jsxs(Text, { color: theme.accent, bold: true, children: ['  ', modeWord] })), teamActive && (_jsxs(Text, { color: theme.toolRunning, bold: true, children: ['  ', cols >= TEAM_LIMITS.statusCompactCols
                                 ? `agents ${teamActive.running}/${teamActive.total}`
-                                : `[${teamActive.running}]`] })), todoActive && (_jsxs(Text, { color: theme.accent, children: ['  ', cols >= TODO_LIMITS.statusCompactCols
+                                : `[${teamActive.running}]`] })), retryActive && (_jsxs(Text, { color: theme.noticeWarn, bold: true, children: ['  ', formatRetryChip(retryActive, cols)] })), todoActive && (_jsxs(Text, { color: theme.accent, children: ['  ', cols >= TODO_LIMITS.statusCompactCols
                                 ? `todo ${todoActive.done}/${todoActive.total}`
-                                : `[${todoActive.done}/${todoActive.total}]`] })), cols >= 60 && (_jsxs(Text, { color: theme.muted, children: ['  ', provider, ":", model] })), thinkingLevel !== 'off' && cols >= 72 && (_jsxs(Text, { color: theme.accent, children: ["  think:", thinkingLevel] }))] }), _jsxs(Box, { flexDirection: "row", children: [ecoRung > 0 && cols >= ECO_MIN_COLS && (_jsxs(Text, { color: theme.muted, children: ["eco", '  '] })), scrolledLines > 0 && (_jsxs(Text, { color: theme.noticeWarn, children: [glyphs.arrowUp, scrolledLines, '  '] })), cols >= 60 && (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: "[" }), _jsx(Text, { color: gauge.fillColor, children: gauge.filled }), _jsx(Text, { color: gauge.trackColor, children: gauge.empty }), _jsx(Text, { color: theme.muted, children: "] " })] })), _jsx(Text, { color: theme.muted, children: pctLabel }), cols >= 72 && _jsxs(Text, { color: theme.muted, children: ["  ", tokens] }), _jsxs(Text, { color: theme.muted, children: ["  ", formatCost(usageTotal.costUsd)] }), running && (_jsxs(Text, { color: theme.muted, children: [tokPerSec > 0 && cols >= 72 ? `  ${tokPerSec} tok/s` : '', "  ", formatDuration(elapsedMs)] }))] })] }));
+                                : `[${todoActive.done}/${todoActive.total}]`] })), cols >= 60 && (_jsxs(Text, { color: theme.muted, children: ['  ', provider, ":", model] })), thinkingLevel !== 'off' && cols >= 72 && (_jsxs(Text, { color: theme.accent, children: ["  think:", thinkingLevel] }))] }), _jsxs(Box, { flexDirection: "row", children: [fastActive && cols >= FAST_LIMITS.statusCompactCols && (_jsxs(Text, { color: theme.muted, children: ["fast", fastActive.inFlight ? '*' : '', '  '] })), ecoRung > 0 && cols >= ECO_MIN_COLS && (_jsxs(Text, { color: theme.muted, children: ["eco", '  '] })), scrolledLines > 0 && (_jsxs(Text, { color: theme.noticeWarn, children: [glyphs.arrowUp, scrolledLines, '  '] })), cols >= 60 && (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: "[" }), _jsx(Text, { color: gauge.fillColor, children: gauge.filled }), _jsx(Text, { color: gauge.trackColor, children: gauge.empty }), _jsx(Text, { color: theme.muted, children: "] " })] })), _jsx(Text, { color: theme.muted, children: pctLabel }), cols >= 72 && _jsxs(Text, { color: theme.muted, children: ["  ", tokens] }), _jsxs(Text, { color: theme.muted, children: ["  ", formatCost(usageTotal.costUsd)] }), running && (_jsxs(Text, { color: theme.muted, children: [tokPerSec > 0 && cols >= 72 ? `  ${tokPerSec} tok/s` : '', "  ", formatDuration(elapsedMs)] }))] })] }));
 }

package/dist/ui/TeamPanel.d.ts

@@ -10,10 +10,11 @@
  * not mounted at all, so a session that never delegates has zero rows and zero
  * layout shift.
  *
- * IT MUST BE MOUNTED INSIDE `AppShell`'s MEASURED BOTTOM BOX (I-10). The wheel
- * router reads the composer band boundary from `measureElement(bottomRef)`; a
- * panel rendered outside it makes that boundary stale the moment a dispatch
- * starts, and the wheel begins scrolling prompt history over the transcript.
+ * IT MUST BE MOUNTED IN `AppShell`'s BOTTOM CHROME (I-10), not in the middle
+ * band. The roster is transient status about the run in progress, so it belongs
+ * with the other transient rows — toast, composer, status bar — rather than
+ * inside the scrolling transcript, where it would be interleaved with history
+ * and scroll out of sight exactly when the user wants to watch it.
  */
 import React from 'react';
 import type { Theme } from './theme.js';

package/dist/ui/TeamPanel.js

@@ -120,7 +120,7 @@ export function TeamPanel({ snapshot, rows, cols, reducedMotion, theme, caps, no
                 // `reducedMotion` and a non-Unicode terminal fall back to the same
                 // static marker, exactly as `AssistantEntry` and `ToolCard` already do.
                 const animate = isRunning(run) && !reducedMotion && caps.unicode;
-                return (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: color, children: [' ', animate ? _jsx(Spinner, { type: "dots" }) : marker(run, glyphs), ' '] }), _jsx(Text, { color: theme.primary, children: run.label.padEnd(8).slice(0, 8) }), _jsx(Box, { flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(Text, { wrap: "truncate", color: theme.muted, children: run.description }) }), _jsx(Box, { flexShrink: 1, overflow: "hidden", children: _jsxs(Text, { wrap: "truncate", color: color, children: ['  ', activityLine(run, cols)] }) }), _jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', run.startedAt ? formatDuration(Math.max(0, (run.endedAt ?? at) - run.startedAt)) : ''] })] }, run.label));
+                return (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: color, children: [' ', animate ? _jsx(Spinner, { type: "dots" }) : marker(run, glyphs), ' '] }), _jsx(Text, { color: theme.primary, children: `${run.label}${run.tier === 'fast' ? '~' : ''}`.padEnd(8).slice(0, 8) }), _jsx(Box, { flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(Text, { wrap: "truncate", color: theme.muted, children: run.description }) }), _jsx(Box, { flexShrink: 1, overflow: "hidden", children: _jsxs(Text, { wrap: "truncate", color: color, children: ['  ', activityLine(run, cols)] }) }), _jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', run.startedAt ? formatDuration(Math.max(0, (run.endedAt ?? at) - run.startedAt)) : ''] })] }, run.label));
             }), hiddenTotal > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', "+", hiddenTotal, " more", hiddenRunning > 0 ? ` (${hiddenRunning} running)` : ''] })), snapshot.lastMessage && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: [' ', glyphs.teamMail, " ", snapshot.lastMessage.from, " ", glyphs.arrowRight, " ", snapshot.lastMessage.to, ": ", snapshot.lastMessage.subject] }))] }));
 }
 function marker(run, glyphs) {

package/dist/ui/TodoPanel.d.ts

@@ -8,10 +8,11 @@
  * this component is not rendered at all, so a session that never plans has zero
  * columns and zero layout shift (R-g's "no furniture when idle" / AC-24).
  *
- * IT MUST BE MOUNTED IN `AppShell`'s MIDDLE BAND, NEVER INSIDE `bottomRef`
- * (C-6 / I-4). That box is MEASURED and the wheel router reads the composer band
- * boundary from it; a column added there would inflate the measurement and start
- * routing transcript scrolls into prompt history.
+ * IT MUST BE MOUNTED IN `AppShell`'s MIDDLE BAND, NEVER IN THE BOTTOM CHROME
+ * (C-6 / I-4). This is a COLUMN BESIDE the viewport, and the middle band is the
+ * only row-wrapped region there is; moved down into the bottom chrome it would
+ * stop being a rail and start eating viewport height, growing and shrinking the
+ * transcript every time the list changed length.
  *
  * WIDTH IS MEASURED IN COLUMNS, NEVER IN CODE UNITS (P2-3). This rail is 18-36
  * columns wide and the system prompt's last line is "Respond in the language the

package/dist/ui/Transcript.d.ts

@@ -30,6 +30,7 @@ import { type Theme } from './theme.js';
 import type { TermCapabilities } from './capabilities.js';
 import { type DensityMode } from './density.js';
 import type { Entry } from '../agent/reducer.js';
+import type { RenderMode } from './layout/frame.js';
 import type { HeightStore } from './use-height-store.js';
 /**
  * Largest prefix length P such that `entries[0..P)` are all terminal, none is
@@ -44,6 +45,25 @@ interface TranscriptProps {
     thinkingVisible: boolean;
     reducedMotion: boolean;
     density: DensityMode;
+    /**
+     * The render mode, threaded from `App` as a plain scalar prop.
+     *
+     * It decides whether the collapsed thinking marker may offer `ctrl+t` (D-16):
+     * inline prints settled entries into `<Static>`, which cannot re-print them.
+     * NOT read from a module-level singleton — `render-memo.test.tsx` asserts prop
+     * stability across frames, and a hidden read would be invisible to it.
+     */
+    mode: RenderMode;
+    /**
+     * Wall-clock seconds, threaded from `App`'s existing 200 ms ticker, for the
+     * live tool card's stall row (agent-activity-presentation-live §3.3.4 / D-36).
+     *
+     * BOTH MAP CALLBACKS BELOW DECIDE PER ENTRY WHETHER TO PASS IT ON, and neither
+     * may pass it unconditionally: `ToolCard` is `React.memo` with the default
+     * comparator, so a prop that changes every second on every card would defeat
+     * that boundary for the whole transcript.
+     */
+    nowSec?: number;
     theme: Theme;
     caps: TermCapabilities;
 }
@@ -55,12 +75,15 @@ export interface EntryViewProps {
     thinkingVisible: boolean;
     reducedMotion: boolean;
     density: DensityMode;
+    mode: RenderMode;
     theme: Theme;
     caps: TermCapabilities;
     /** Inline mode only (L5); `undefined` in full-screen, which means no clamp. */
     liveClampRows?: number;
+    /** Wall-clock seconds; set ONLY on a running tool entry (§3.3.4 / P1-3). */
+    nowSec?: number;
 }
-declare function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion, density, theme, caps, liveClampRows, }: EntryViewProps): React.ReactElement | null;
+declare function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion, density, mode, theme, caps, liveClampRows, nowSec, }: EntryViewProps): React.ReactElement | null;
 /**
  * THE memo boundary that makes a long transcript cheap (L2 / R3).
  *
@@ -96,7 +119,7 @@ export declare const EntryView: React.MemoExoticComponent<typeof EntryViewImpl>;
  * `selectWindow`, and the two spacers are what keep the scroll maths honest
  * while they are absent.
  */
-export declare function TranscriptList({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, theme, caps, windowSize, cols, heights, mountedSink, }: TranscriptProps & {
+export declare function TranscriptList({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, mode, nowSec, theme, caps, windowSize, cols, heights, mountedSink, }: TranscriptProps & {
     windowSize: number;
     /** The viewport's own width — narrower than the terminal when the rail is up. */
     cols: number;
@@ -110,5 +133,5 @@ export declare function TranscriptList({ entries, expandedToolIds, thinkingVisib
         current: number;
     };
 }): React.ReactElement;
-export declare function Transcript({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, theme, caps, }: TranscriptProps): React.ReactElement;
+export declare function Transcript({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, mode, nowSec, theme, caps, }: TranscriptProps): React.ReactElement;
 export {};

package/dist/ui/Transcript.js

@@ -37,6 +37,8 @@ import { AssistantEntry } from './entries/AssistantEntry.js';
 import { ToolCard, statusColor, toolEntryGlyph } from './entries/ToolCard.js';
 import { TeamCard, teamCardColor } from './entries/TeamCard.js';
 import { TodoCard, todoCardColor } from './entries/TodoCard.js';
+import { RetryCard, retryCardColor } from './entries/RetryCard.js';
+import { FastCard, fastCardColor } from './entries/FastCard.js';
 import { MeasuredEntry } from './layout/MeasuredEntry.js';
 import { useViewportGeometry } from './layout/viewport-geometry.js';
 import { estimateEntryRows, heightKey, selectWindow, VIRTUAL_LIMITS, } from './layout/virtual-window.js';
@@ -83,10 +85,34 @@ export function computeSettledCount(entries, expandedToolIds) {
         // on every frame for the rest of the session.
         if (e.kind === 'todo' && e.live)
             break;
+        // Nor is a retry card that is still counting down or still in flight: it is
+        // rewritten on every `retryScheduled` / `retryAttempt` and once a second by
+        // `retryTick`, and `<Static>` cannot un-print what it has already drawn.
+        // `session/persist.ts` forces a loaded card to `interrupted`, which is the
+        // other half — a card that never settles is re-rendered on every frame for
+        // the rest of the session (R-10).
+        if (e.kind === 'retry' && (e.phase === 'waiting' || e.phase === 'retrying'))
+            break;
+        // A live review card is not settled either: it is rewritten once, when the
+        // call comes back, and `<Static>` cannot un-print what it has already drawn
+        // (C-5). `session/persist.ts` forces `live: false` on load, which is the
+        // other half.
+        if (e.kind === 'fast' && e.live)
+            break;
         count = i + 1;
     }
     return count;
 }
+/**
+ * The value `EntryView` should receive for `nowSec` on THIS entry.
+ *
+ * `undefined` for everything that is not a running tool, which is what keeps
+ * every other card's memo boundary intact — `undefined === undefined` in the
+ * comparator, on every frame, forever.
+ */
+function nowSecFor(entry, nowSec) {
+    return entry.kind === 'tool' && entry.status === 'running' ? nowSec : undefined;
+}
 function noticeColor(level, theme) {
     if (level === 'error')
         return theme.noticeError;
@@ -101,7 +127,7 @@ function noticeSymbol(level, theme) {
         return theme.symbols.warn;
     return theme.symbols.info;
 }
-function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion, density, theme, caps, liveClampRows, }) {
+function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion, density, mode, theme, caps, liveClampRows, nowSec, }) {
     const glyphs = pickGlyphs(caps);
     const separation = separationRows(prev, entry, density);
     const frame = (glyph, color, children) => (_jsx(EntryFrame, { glyph: glyph, color: color, continuation: glyphs.railVertical, separation: separation, spacerColor: theme.border, children: children }));
@@ -113,14 +139,37 @@ function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion,
             // both an animation and a Unicode-only glyph, so reduced motion and an
             // ASCII terminal fall back to the same static marker (P2-11 / A-10).
             const animate = entry.streaming && !reducedMotion && caps.unicode;
-            return frame(animate ? _jsx(Spinner, { type: "dots" }) : glyphs.assistant, theme.primary, _jsx(AssistantEntry, { text: entry.text, thinking: entry.thinking, thinkingOpen: entry.thinkingOpen, thinkingVisible: thinkingVisible, streaming: entry.streaming, aborted: entry.aborted, liveClampRows: liveClampRows, theme: theme, caps: caps }));
+            return frame(animate ? _jsx(Spinner, { type: "dots" }) : glyphs.assistant, theme.primary, _jsx(AssistantEntry, { text: entry.text, thinking: entry.thinking, thinkingOpen: entry.thinkingOpen, thinkingVisible: thinkingVisible, streaming: entry.streaming, aborted: entry.aborted, 
+                // `EntryViewImpl` hands each renderer EXPLICIT SCALAR PROPS, so
+                // nothing on the entry reaches a component by itself (P1-6b).
+                thinkingMs: entry.thinkingMs, revealable: mode === 'fullscreen', liveClampRows: liveClampRows, theme: theme, caps: caps }));
         }
         case 'tool':
-            return frame(toolEntryGlyph(entry.name, caps), statusColor(entry.status, theme), _jsx(ToolCard, { name: entry.name, label: entry.label, argsRaw: entry.argsRaw, args: entry.args, status: entry.status, preview: entry.preview, durationMs: entry.durationMs, isError: entry.isError, expanded: expanded, reducedMotion: reducedMotion, liveClampRows: liveClampRows, theme: theme, caps: caps }));
+            return frame(toolEntryGlyph(entry.name, caps), statusColor(entry.status, theme), _jsx(ToolCard, { name: entry.name, label: entry.label, argsRaw: entry.argsRaw, args: entry.args, status: entry.status, preview: entry.preview, patch: entry.patch, durationMs: entry.durationMs, isError: entry.isError, expanded: expanded, reducedMotion: reducedMotion, liveClampRows: liveClampRows, 
+                // `entry.live` AND NOT `entry.live ?? []` (P2-4): `ToolCard`'s default
+                // comparator sees a fresh `[]` as a changed prop, which is why that
+                // file already keeps a shared `EMPTY_LINES`.
+                live: entry.live, lastOutputAt: entry.lastOutputAt, nowSec: nowSec, theme: theme, caps: caps }));
         case 'team':
             return frame(glyphs.teamAgent, teamCardColor(entry.runs, entry.active, entry.aborted, theme), _jsx(TeamCard, { requested: entry.requested, runs: entry.runs, aborted: entry.aborted, durationMs: entry.durationMs, active: entry.active, expanded: expanded, reducedMotion: reducedMotion, theme: theme, caps: caps }));
         case 'todo':
             return frame(toolGlyph(glyphs, 'todo_write'), todoCardColor(entry.doneCount, entry.total, entry.live, theme), _jsx(TodoCard, { items: entry.items, doneCount: entry.doneCount, total: entry.total, live: entry.live, interrupted: entry.interrupted, theme: theme, caps: caps }));
+        case 'retry':
+            return frame(entry.phase === 'exhausted' ? glyphs.error : glyphs.retry, retryCardColor(entry.phase, theme), _jsx(RetryCard, { attempt: entry.attempt, maxRetries: entry.maxRetries, errorType: entry.errorType, phase: entry.phase, resumeAt: entry.resumeAt, totalRetries: entry.totalRetries, elapsedMs: entry.elapsedMs, 
+                // READ HERE, not threaded from `App`, and that is what keeps the memo
+                // boundary intact: a `now` prop on every `EntryView` would change on
+                // every frame and re-render the whole transcript. The `retryTick` action
+                // refreshes THIS entry's identity once a second, which re-renders this
+                // one card and gives it a fresh clock; nothing else moves.
+                now: Date.now(), 
+                // NOT THREADED FROM `App`: reaching this renderer means a TUI is
+                // mounted, and the TUI always binds Esc to abort. Headless mode writes
+                // its retry lines to stderr and never mounts an entry component, and the
+                // exit replay goes through `transcript-text.ts`. `RetryCard` keeps the
+                // prop so the render tests can assert the suppressed form.
+                reducedMotion: reducedMotion, theme: theme, caps: caps }));
+        case 'fast':
+            return frame(entry.status === 'failed' ? glyphs.toolError : glyphs.teamAgent, fastCardColor(entry.status, theme), _jsx(FastCard, { reviewIndex: entry.reviewIndex, model: entry.model, status: entry.status, text: entry.text, detail: entry.detail, turn: entry.turn, durationMs: entry.durationMs, live: entry.live, reducedMotion: reducedMotion, theme: theme, caps: caps }));
         case 'notice':
             return frame(noticeSymbol(entry.level, theme), noticeColor(entry.level, theme), _jsx(Text, { color: noticeColor(entry.level, theme), children: entry.text }));
         default:
@@ -148,9 +197,21 @@ export const EntryView = React.memo(EntryViewImpl, (a, b) => {
         a.thinkingVisible === b.thinkingVisible &&
         a.reducedMotion === b.reducedMotion &&
         a.density === b.density &&
+        a.mode === b.mode &&
         a.theme === b.theme &&
         a.caps === b.caps &&
-        a.liveClampRows === b.liveClampRows);
+        a.liveClampRows === b.liveClampRows &&
+        /*
+         * ELEVENTH TERM, AND OMITTING IT IS THE TRAP I-L2-1 DESCRIBES ONE COMMENT UP
+         * (P1-3). This comparator is a CLOSED LIST: a prop absent from it changes
+         * without invalidating the boundary, so `ToolCard` is never re-rendered and
+         * the stall row freezes at whatever second it first drew — AC-26's "and the
+         * seconds advance" failing with nothing reporting it.
+         *
+         * It is free: `nowSecFor` returns `undefined` for every entry that is not a
+         * running tool, and `undefined === undefined` on every frame.
+         */
+        a.nowSec === b.nowSec);
 });
 /**
  * Full-screen transcript body — the same entry renderers with NO `<Static>`.
@@ -172,7 +233,7 @@ export const EntryView = React.memo(EntryViewImpl, (a, b) => {
  * `selectWindow`, and the two spacers are what keep the scroll maths honest
  * while they are absent.
  */
-export function TranscriptList({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, theme, caps, windowSize, cols, heights, mountedSink, }) {
+export function TranscriptList({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, mode, nowSec, theme, caps, windowSize, cols, heights, mountedSink, }) {
     const size = Math.max(1, Math.floor(windowSize));
     const visible = entries.length > size ? entries.slice(-size) : entries;
     const collapsed = entries.length - visible.length;
@@ -190,7 +251,12 @@ export function TranscriptList({ entries, expandedToolIds, thinkingVisible, redu
     const { resolve, report } = heights;
     const heightOf = useCallback((index) => {
         const entry = visible[index];
-        return resolve(keyOf(entry), () => estimateEntryRows(entry, cols, density, !!expandedToolIds[entry.id]));
+        // `thinkingVisible` IS PASSED, not left to the parameter's conservative
+        // default (P1-6a / condition 5). With thinking hidden the default would
+        // inflate every assistant entry that thought by its whole wrapped length,
+        // and an entry estimated at 400 rows against a real height of 1 is exactly
+        // the one `selectWindow` then never mounts and never re-measures.
+        return resolve(keyOf(entry), () => estimateEntryRows(entry, cols, density, !!expandedToolIds[entry.id], thinkingVisible));
     }, 
     // Memoised only incidentally: `visible` IS `entries` while the session is
     // shorter than the horizon and a fresh slice once it is past it, so this
@@ -199,7 +265,7 @@ export function TranscriptList({ entries, expandedToolIds, thinkingVisible, redu
     // `keyOf` is omitted from the list because every input it closes over is
     // already in it.
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [visible, expandedToolIds, cols, density, flags, resolve]);
+    [visible, expandedToolIds, cols, density, flags, resolve, thinkingVisible]);
     const selection = selectWindow({
         entries: visible,
         heightOf,
@@ -212,10 +278,10 @@ export function TranscriptList({ entries, expandedToolIds, thinkingVisible, redu
         mountedSink.current = slice.length;
     return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [collapsed > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.hintFg ?? theme.muted, children: [glyphs.ellipsis, " ", collapsed, " earlier ", collapsed === 1 ? 'entry' : 'entries', " collapsed (/save exports the full session)"] })), selection.leadingRows > 0 && (_jsx(Box, { flexShrink: 0, height: selection.leadingRows })), slice.map((entry, i) => {
                 const index = selection.startIndex + i;
-                return (_jsx(MeasuredEntry, { heightKey: keyOf(entry), onMeasure: report, children: _jsx(EntryView, { entry: entry, prev: index > 0 ? visible[index - 1] : undefined, expanded: !!expandedToolIds[entry.id], thinkingVisible: thinkingVisible, reducedMotion: reducedMotion, density: density, theme: theme, caps: caps }) }, entry.id));
+                return (_jsx(MeasuredEntry, { heightKey: keyOf(entry), onMeasure: report, children: _jsx(EntryView, { entry: entry, prev: index > 0 ? visible[index - 1] : undefined, expanded: !!expandedToolIds[entry.id], thinkingVisible: thinkingVisible, reducedMotion: reducedMotion, density: density, mode: mode, nowSec: nowSecFor(entry, nowSec), theme: theme, caps: caps }) }, entry.id));
             }), selection.trailingRows > 0 && (_jsx(Box, { flexShrink: 0, height: selection.trailingRows }))] }));
 }
-export function Transcript({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, theme, caps, }) {
+export function Transcript({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, mode, nowSec, theme, caps, }) {
     const highWater = useRef(0);
     const prevLen = useRef(0);
     const { rows } = useTerminalSize();
@@ -246,5 +312,5 @@ export function Transcript({ entries, expandedToolIds, thinkingVisible, reducedM
     // a live entry at all, which is worse than a tall frame.
     const liveBudget = Math.max(INLINE_LIVE_MIN_ROWS, rows - INLINE_LIVE_MARGIN);
     const liveClampRows = Math.max(1, Math.floor(liveBudget / Math.max(1, liveEntries.length)) - 1);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: settledEntries, children: (entry, index) => (_jsx(EntryView, { entry: entry, prev: index > 0 ? settledEntries[index - 1] : undefined, expanded: !!expandedToolIds[entry.id], thinkingVisible: thinkingVisible, reducedMotion: reducedMotion, density: density, theme: theme, caps: caps }, entry.id)) }), _jsx(Box, { flexDirection: "column", children: liveEntries.map((entry, i) => (_jsx(EntryView, { entry: entry, prev: i > 0 ? liveEntries[i - 1] : entries[settled - 1], expanded: !!expandedToolIds[entry.id], thinkingVisible: thinkingVisible, reducedMotion: reducedMotion, density: density, theme: theme, caps: caps, liveClampRows: liveClampRows }, entry.id))) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: settledEntries, children: (entry, index) => (_jsx(EntryView, { entry: entry, prev: index > 0 ? settledEntries[index - 1] : undefined, expanded: !!expandedToolIds[entry.id], thinkingVisible: thinkingVisible, reducedMotion: reducedMotion, density: density, mode: mode, theme: theme, caps: caps }, entry.id)) }), _jsx(Box, { flexDirection: "column", children: liveEntries.map((entry, i) => (_jsx(EntryView, { entry: entry, prev: i > 0 ? liveEntries[i - 1] : entries[settled - 1], expanded: !!expandedToolIds[entry.id], thinkingVisible: thinkingVisible, reducedMotion: reducedMotion, density: density, mode: mode, theme: theme, caps: caps, liveClampRows: liveClampRows, nowSec: nowSecFor(entry, nowSec) }, entry.id))) })] }));
 }

package/dist/ui/activity-phrases.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The working line's vocabulary (agent-activity-presentation §3.2.1).
+ *
+ * PURE: no React, no Ink, no clock. Everything here is a function of the two
+ * numbers the caller already has, which is what makes the rotation testable
+ * without a terminal and without fake timers.
+ */
+/** Rotation cadence. Long enough to read, short enough to prove liveness. */
+export declare const PHRASE_ROTATE_MS = 4000;
+/**
+ * ASCII ONLY, by the rule this tree is under (`glyphs.ts` header, enforced by
+ * `glyphs.test.ts`'s static scan). Present participles, so the line reads as an
+ * action in progress; twelve characters or fewer so the row never fights the
+ * terminal's width.
+ */
+export declare const ACTIVITY_PHRASES: readonly string[];
+/**
+ * The phrase for a run at a moment.
+ *
+ * PURE AND TOTAL: the same inputs give the same word, for any finite numbers,
+ * including a `now` before `startedAt`.
+ *
+ * The run's start seeds the sequence, so two consecutive runs do not open on the
+ * same word — which is what makes the line read as alive rather than as a fixed
+ * label. (The seed's granularity is one second, so two runs starting inside the
+ * same second do share an opening word — P2-6.)
+ *
+ * `rotate: false` is the reduced-motion path: the word is chosen once for the run
+ * and then holds. Rotating text IS motion, and a user who asked for
+ * `reducedMotion` asked for the screen to stop changing under them; degrading
+ * only the spinner would honor the letter of the setting and not its point.
+ */
+export declare function pickActivityPhrase(startedAt: number, now: number, rotate?: boolean): string;

package/dist/ui/activity-phrases.js

@@ -0,0 +1,50 @@
+/**
+ * The working line's vocabulary (agent-activity-presentation §3.2.1).
+ *
+ * PURE: no React, no Ink, no clock. Everything here is a function of the two
+ * numbers the caller already has, which is what makes the rotation testable
+ * without a terminal and without fake timers.
+ */
+/** Rotation cadence. Long enough to read, short enough to prove liveness. */
+export const PHRASE_ROTATE_MS = 4_000;
+/**
+ * ASCII ONLY, by the rule this tree is under (`glyphs.ts` header, enforced by
+ * `glyphs.test.ts`'s static scan). Present participles, so the line reads as an
+ * action in progress; twelve characters or fewer so the row never fights the
+ * terminal's width.
+ */
+export const ACTIVITY_PHRASES = [
+    'Assembling', 'Brewing', 'Calibrating', 'Cogitating', 'Composing',
+    'Computing', 'Concocting', 'Conjuring', 'Considering', 'Crunching',
+    'Distilling', 'Divining', 'Drafting', 'Excavating', 'Fathoming',
+    'Fermenting', 'Finessing', 'Foraging', 'Germinating', 'Herding',
+    'Incubating', 'Inferring', 'Marinating', 'Meandering', 'Mulling',
+    'Musing', 'Noodling', 'Percolating', 'Pondering', 'Puzzling',
+    'Ruminating', 'Scheming', 'Sculpting', 'Simmering', 'Sketching',
+    'Spelunking', 'Steeping', 'Stitching', 'Summoning', 'Tinkering',
+    'Unfurling', 'Untangling', 'Weaving', 'Whittling', 'Wrangling',
+];
+/**
+ * The phrase for a run at a moment.
+ *
+ * PURE AND TOTAL: the same inputs give the same word, for any finite numbers,
+ * including a `now` before `startedAt`.
+ *
+ * The run's start seeds the sequence, so two consecutive runs do not open on the
+ * same word — which is what makes the line read as alive rather than as a fixed
+ * label. (The seed's granularity is one second, so two runs starting inside the
+ * same second do share an opening word — P2-6.)
+ *
+ * `rotate: false` is the reduced-motion path: the word is chosen once for the run
+ * and then holds. Rotating text IS motion, and a user who asked for
+ * `reducedMotion` asked for the screen to stop changing under them; degrading
+ * only the spinner would honor the letter of the setting and not its point.
+ */
+export function pickActivityPhrase(startedAt, now, rotate = true) {
+    const n = ACTIVITY_PHRASES.length;
+    if (!Number.isFinite(startedAt) || !Number.isFinite(now))
+        return ACTIVITY_PHRASES[0];
+    const seed = Math.floor(startedAt / 1000);
+    const step = rotate ? Math.floor(Math.max(0, now - startedAt) / PHRASE_ROTATE_MS) : 0;
+    return ACTIVITY_PHRASES[(((seed + step) % n) + n) % n];
+}

package/dist/ui/entries/AssistantEntry.d.ts

@@ -23,6 +23,26 @@ interface AssistantEntryProps {
     thinkingVisible: boolean;
     streaming: boolean;
     aborted?: boolean;
+    /**
+     * Sealed reasoning time (§3.1.2). OMITTED WHEN UNKNOWN rather than printed as
+     * `0s`: a session restored from a file written by an older build has none, and
+     * `thought for 0s` is a lie where a bare `thought` is merely terse.
+     */
+    thinkingMs?: number;
+    /**
+     * Whether pressing `Ctrl+T` would actually reveal THIS entry's body — i.e.
+     * `mode === 'fullscreen'` (D-16 / P0-2).
+     *
+     * In inline mode a settled entry has already been printed into Ink's
+     * `<Static>`, which cannot un-print or re-print (`Transcript.tsx:9-10`), and
+     * the settled boundary is held monotonic precisely so an entry never flows back
+     * out. With thinking hidden by default the body is never printed there AT ALL,
+     * so a row reading `ctrl+t to show` would be an instruction that provably does
+     * nothing. The row degrades to `* thought for 12s` instead — still honest that
+     * reasoning happened and how long it took, and silent about a key that cannot
+     * deliver.
+     */
+    revealable?: boolean;
     /**
      * Inline mode only (L5): keep at most this many rows of a LIVE entry, so the
      * non-`<Static>` region cannot reach `stdout.rows`. `undefined` means no

package/dist/ui/entries/AssistantEntry.js

@@ -20,8 +20,9 @@ import { pickGlyphs } from '../glyphs.js';
 import { Markdown } from '../Markdown.js';
 import { splitLinesCached } from '../render-cache.js';
 import { clampLiveText } from '../live-clamp.js';
+import { formatDuration } from '../../agent/usage.js';
 function AssistantEntryImpl(props) {
-    const { text, thinking, thinkingOpen, thinkingVisible, streaming, aborted, liveClampRows, theme, caps, } = props;
+    const { text, thinking, thinkingOpen, thinkingVisible, streaming, aborted, thinkingMs, revealable, liveClampRows, theme, caps, } = props;
     const glyphs = pickGlyphs(caps);
     const hasThinking = !!thinking && thinking.trim().length > 0;
     const hasText = text.trim().length > 0;
@@ -36,7 +37,7 @@ function AssistantEntryImpl(props) {
         ? clampLiveText(thinking, thinkingRows)
         : { text: thinking ?? '', hiddenRows: 0 };
     const body = liveClampRows === undefined ? { text, hiddenRows: 0 } : clampLiveText(text, liveClampRows);
-    return (_jsxs(Box, { flexDirection: "column", children: [hasThinking && thinkingVisible && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { wrap: "truncate", color: theme.thinking, children: [glyphs.thinking, " thinking", thinkingOpen ? glyphs.ellipsis : ''] }), _jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [clampedThinking.hiddenRows > 0 && (_jsxs(Text, { color: theme.muted, children: [glyphs.ellipsis, " ", clampedThinking.hiddenRows, " earlier", ' ', clampedThinking.hiddenRows === 1 ? 'line' : 'lines'] })), splitLinesCached(clampedThinking.text).map((line, i) => (_jsx(Text, { color: theme.thinking, dimColor: true, children: line }, i)))] })] })), (hasText || streaming) && (_jsxs(Box, { flexDirection: "column", children: [body.hiddenRows > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: [glyphs.ellipsis, " ", body.hiddenRows, " earlier", ' ', body.hiddenRows === 1 ? 'line' : 'lines', " ", glyphs.midDot, " shown in full when this entry finishes"] })), hasText ? (_jsx(Markdown, { text: body.text, theme: theme, caps: caps })) : (_jsx(Text, { color: theme.muted, children: glyphs.ellipsis })), aborted && _jsx(Text, { color: theme.noticeWarn, children: "[aborted]" })] }))] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [hasThinking && thinkingVisible && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { wrap: "truncate", color: theme.thinking, children: [glyphs.thinking, " thinking", thinkingOpen ? glyphs.ellipsis : ''] }), _jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [clampedThinking.hiddenRows > 0 && (_jsxs(Text, { color: theme.muted, children: [glyphs.ellipsis, " ", clampedThinking.hiddenRows, " earlier", ' ', clampedThinking.hiddenRows === 1 ? 'line' : 'lines'] })), splitLinesCached(clampedThinking.text).map((line, i) => (_jsx(Text, { color: theme.thinking, dimColor: true, children: line }, i)))] })] })), hasThinking && !thinkingVisible && !streaming && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: [glyphs.thinking, " thought", thinkingMs !== undefined ? ` for ${formatDuration(thinkingMs)}` : '', revealable ? ` ${glyphs.midDot} ctrl+t to show` : ''] })), (hasText || streaming) && (_jsxs(Box, { flexDirection: "column", children: [body.hiddenRows > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: [glyphs.ellipsis, " ", body.hiddenRows, " earlier", ' ', body.hiddenRows === 1 ? 'line' : 'lines', " ", glyphs.midDot, " shown in full when this entry finishes"] })), hasText ? (_jsx(Markdown, { text: body.text, theme: theme, caps: caps })) : (_jsx(Text, { color: theme.muted, children: glyphs.ellipsis })), aborted && _jsx(Text, { color: theme.noticeWarn, children: "[aborted]" })] }))] }));
 }
 /** Rows of live thinking kept on screen while an answer streams. */
 const STREAMING_THINKING_ROWS = 24;

package/dist/ui/entries/DiffView.d.ts

@@ -0,0 +1,67 @@
+/**
+ * A `FilePatch` as a diff (agent-activity-presentation §3.4): a `+6 -5` summary,
+ * then hunk-separated rows with a right-aligned line-number gutter, a `+`/`-`/
+ * space sign column and `theme.diff` colors.
+ *
+ * `wrap="truncate"` ON EVERY ROW IS A CORRECTNESS REQUIREMENT, NOT A TASTE ONE.
+ * `estimateEntryRows` computes a diff card's height by COUNTING rows, so a
+ * wrapped patch line would occupy two rows while the estimate charged one — an
+ * under-estimate, which `virtual-window.ts` names as the unsafe direction. One
+ * patch line is one terminal row, always.
+ *
+ * No new keybinding and no new state: collapse rides on `expandedToolIds` and
+ * the existing `Ctrl+O` handler, which targets the MOST RECENT tool card (P2-4).
+ *
+ * `caps` is deliberately NOT a prop. Every character this component emits is
+ * ASCII — `+`, `-`, `@@`, digits — because `+` and `-` are the diff's own
+ * vocabulary and `renderUnifiedDiff` already spells them literally. A glyph
+ * lookup here would buy nothing and add a memo dependency.
+ */
+import React from 'react';
+import type { Theme } from '../theme.js';
+import type { FilePatch, PatchLine } from '../../tools/patch.js';
+/**
+ * Diff rows shown before collapse.
+ *
+ * Higher than the generic preview's 8 (D-11): a diff's rows are half as tall in
+ * information terms, and 8 rows of a 3-context hunk is barely one change.
+ * DUPLICATED AS A NUMBER in `virtual-window.ts`, matching what
+ * `TOOL_COLLAPSED_LINES` already does and the comment that justifies it.
+ */
+export declare const DIFF_COLLAPSED_LINES = 12;
+export interface DiffViewProps {
+    patch: FilePatch;
+    expanded?: boolean;
+    /**
+     * Inline mode only (L5): ceiling on the rows a LIVE card contributes to the
+     * non-`<Static>` region. `undefined` — what the full-screen branch passes —
+     * means no clamp.
+     */
+    liveClampRows?: number;
+    theme: Theme;
+}
+/** One rendered row: a patch line, or the `@@` separator between two hunks. */
+interface DiffRow {
+    kind: PatchLine['kind'] | 'meta';
+    /** The gutter number, or `undefined` for a separator and the newline note. */
+    num?: number;
+    text: string;
+}
+/**
+ * Flatten the hunks into rows, inserting one `@@` separator BETWEEN hunks and
+ * none before the first.
+ *
+ * Exported for `diff-view.test.tsx`, and because the row count it produces is
+ * the number `estimateEntryRows` reproduces arithmetically — the two must not
+ * disagree.
+ */
+export declare function diffRows(patch: FilePatch): DiffRow[];
+declare function DiffViewImpl({ patch, expanded, liveClampRows, theme, }: DiffViewProps): React.ReactElement;
+/**
+ * `React.memo` with the DEFAULT comparator, matching `ToolCard`'s boundary.
+ * `patch` qualifies as a prop only because the reducer writes it ONCE at
+ * `toolExecEnd` and never rebuilds it (P2-9); `theme` is `useMemo`d in `App.tsx`
+ * (I-L2-1).
+ */
+export declare const DiffView: React.MemoExoticComponent<typeof DiffViewImpl>;
+export {};