@aragon-agent/cli 0.5.6 → 0.5.9

package/dist/ui/Transcript.js

@@ -16,8 +16,17 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * parallel product. What inline still guarantees is its GEOMETRY contract — no
  * fixed frame, `<Static>` keeps the settled history, no private ANSI — not its
  * pixel-for-pixel appearance.
+ *
+ * Two things changed with tui-render-performance:
+ *   - `EntryView` is `React.memo`'d with an explicit comparator (L2 / R3), which
+ *     is only worth anything because `mapEntry` already preserves object
+ *     identity for untouched entries;
+ *   - `TranscriptList` (the FULL-SCREEN body) mounts only the entries inside the
+ *     viewport and replaces the rest with two spacer boxes (L3 / R1), and the
+ *     inline `Transcript` clamps its live region so `ink.js:121` is unreachable
+ *     (L5 / R6).
  */
-import { useRef } from 'react';
+import React, { useCallback, useRef } from 'react';
 import { Box, Static, Text } from 'ink';
 import Spinner from 'ink-spinner';
 import { pickGlyphs, toolGlyph } from './glyphs.js';
@@ -28,8 +37,21 @@ 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';
+import { useTerminalSize } from './layout/useTerminalSize.js';
 /** Keep the last K entries in the live region so a mutating tail stays hot. */
 const LIVE_TAIL = 1;
+/**
+ * Rows the inline live region leaves for the composer, the prompt echo and the
+ * one-row margin Ink needs before `outputHeight >= stdout.rows` (I-L5-1).
+ */
+const INLINE_LIVE_MARGIN = 4;
+/** Floor on the clamp, so a very short terminal still shows something useful. */
+const INLINE_LIVE_MIN_ROWS = 4;
 /**
  * Largest prefix length P such that `entries[0..P)` are all terminal, none is
  * within the last `LIVE_TAIL` entries, and none is currently expanded. Pure and
@@ -63,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;
@@ -81,7 +127,7 @@ function noticeSymbol(level, theme) {
         return theme.symbols.warn;
     return theme.symbols.info;
 }
-function EntryView({ entry, prev, expanded, thinkingVisible, reducedMotion, density, theme, caps, }) {
+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 }));
@@ -93,20 +139,80 @@ function EntryView({ entry, prev, expanded, thinkingVisible, reducedMotion, dens
             // 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, 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, 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:
             return null;
     }
 }
+/**
+ * THE memo boundary that makes a long transcript cheap (L2 / R3).
+ *
+ * The comparator is written out rather than defaulted because `prev` is the one
+ * prop whose identity matters for a reason the type does not show: it feeds
+ * `separationRows`, so an entry whose PREDECESSOR changed kind must re-render
+ * even though the entry itself did not.
+ *
+ * I-L2-1 — `theme` and `caps` are `useMemo`d in `App.tsx` and are therefore
+ * referentially stable across frames. If a future change makes either a fresh
+ * object per render, EVERY boundary below becomes a no-op AND NOTHING FAILS;
+ * `render-memo.test.tsx` asserts that stability directly so the trap is a red
+ * test rather than a silent regression.
+ */
+export const EntryView = React.memo(EntryViewImpl, (a, b) => {
+    return (a.entry === b.entry &&
+        a.prev === b.prev &&
+        a.expanded === b.expanded &&
+        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 &&
+        /*
+         * 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>`.
  *
@@ -121,20 +227,64 @@ function EntryView({ entry, prev, expanded, thinkingVisible, reducedMotion, dens
  * mark feeds nothing else — `/save` serializes `entries` in full — so leaving it
  * un-advanced has no side effect.
  *
- * Rendering budget (I-3): yoga lays out every child even when `overflow: hidden`
- * clips it, so cost grows linearly with the entry count. Only the last
- * `windowSize` entries are rendered; the reducer and `/save` keep everything.
+ * VIRTUALISED (L3 / R1). `windowSize` is now the SCROLL HORIZON — how far back
+ * the user can scroll — and no longer the rendering budget, because entries
+ * outside the viewport are not mounted at all. What bounds the frame is
+ * `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, }) {
+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;
     const glyphs = pickGlyphs(caps);
-    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)"] })), visible.map((entry, i) => (_jsx(EntryView, { entry: entry, prev: i > 0 ? visible[i - 1] : undefined, expanded: !!expandedToolIds[entry.id], thinkingVisible: thinkingVisible, reducedMotion: reducedMotion, density: density, theme: theme, caps: caps }, entry.id)))] }));
+    const geometry = useViewportGeometry();
+    // Ctrl+T changes every assistant entry's height without changing any entry,
+    // so it has to reach the cache key or the spacers freeze at the wrong size.
+    const flags = thinkingVisible ? 't' : '';
+    // ONE key builder, shared by the lookup below and by `MeasuredEntry`'s report.
+    // Two spellings of the same key is a SILENT failure and not a compile error:
+    // the measurement lands under a key `resolve` never asks for, every entry
+    // falls back to its estimate for the rest of the session, and the spacers
+    // quietly encode heights nothing will ever correct.
+    const keyOf = (entry) => heightKey(entry, cols, !!expandedToolIds[entry.id], density, flags);
+    const { resolve, report } = heights;
+    const heightOf = useCallback((index) => {
+        const entry = visible[index];
+        // `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
+    // rebuilds on some frames and not others. Either is correct — `selectWindow`
+    // consumes it synchronously below and it is never handed to a child — and
+    // `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, thinkingVisible]);
+    const selection = selectWindow({
+        entries: visible,
+        heightOf,
+        viewportRows: geometry.viewportRows,
+        offset: geometry.offset,
+        overscan: VIRTUAL_LIMITS.overscan,
+    });
+    const slice = visible.slice(selection.startIndex, selection.endIndex);
+    if (mountedSink)
+        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, 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();
     const raw = computeSettledCount(entries, expandedToolIds);
     // The transcript shrank (clear / reset / restore) — drop the high-water mark.
     if (entries.length < prevLen.current)
@@ -144,5 +294,23 @@ export function Transcript({ entries, expandedToolIds, thinkingVisible, reducedM
     highWater.current = settled;
     const settledEntries = entries.slice(0, settled);
     const liveEntries = entries.slice(settled);
-    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 }, entry.id))) })] }));
+    // I-L5-1 — the live region must stay strictly below `stdout.rows`, or Ink
+    // takes the `ink.js:118-123` branch and writes `clearTerminal +
+    // fullStaticOutput + output` on EVERY subsequent frame for the rest of the
+    // session.
+    //
+    // `LIVE_TAIL` is 1, so the common case is the design's `rows - 4` less the one
+    // row the clamp marker costs. THE DIVISION IS NOT DECORATION: the settled
+    // boundary is held back by an expanded card, a running tool, a live dispatch
+    // or a live todo list, and in every one of those cases the region holds
+    // SEVERAL entries at once — a flat per-entry ceiling of `rows - 4` would then
+    // overrun by a multiple of itself. `- 1` pays for each entry's marker row.
+    //
+    // The residual: an entry contributes at least its header row whatever the
+    // clamp says, so the bound holds while the live region holds fewer than about
+    // `rows / 2` entries. Bounding it unconditionally would mean refusing to draw
+    // 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, 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

@@ -5,6 +5,13 @@
  *
  * The role glyph and spacing belong to `EntryFrame` (§4.3) — including the
  * streaming spinner, which IS the role marker while text is arriving.
+ *
+ * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3):
+ * every prop here is a scalar except `theme` and `caps`, both of which are
+ * `useMemo`d in `App.tsx` and therefore referentially stable across frames
+ * (I-L2-1, asserted by `render-memo.test.tsx`). If either ever becomes a fresh
+ * object per render this boundary silently becomes a no-op — which is exactly
+ * why that assertion exists rather than a comment.
  */
 import React from 'react';
 import type { Theme } from '../theme.js';
@@ -16,8 +23,38 @@ 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
+     * clamp on the ANSWER BODY, which is what the full-screen branch passes — so
+     * the rendered answer there is byte-identical to a pre-feature build. (The
+     * thinking block has its own streaming clamp below and is not covered by that
+     * statement.)
+     */
+    liveClampRows?: number;
     theme: Theme;
     caps: TermCapabilities;
 }
-export declare function AssistantEntry(props: AssistantEntryProps): React.ReactElement | null;
+declare function AssistantEntryImpl(props: AssistantEntryProps): React.ReactElement | null;
+export declare const AssistantEntry: React.MemoExoticComponent<typeof AssistantEntryImpl>;
 export {};

package/dist/ui/entries/AssistantEntry.js

@@ -1,13 +1,44 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Render a streaming assistant entry: an optional collapsible thinking block
+ * above the markdown-rendered answer text. Empty entries render nothing (a turn
+ * that only produced tool calls has no assistant text).
+ *
+ * The role glyph and spacing belong to `EntryFrame` (§4.3) — including the
+ * streaming spinner, which IS the role marker while text is arriving.
+ *
+ * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3):
+ * every prop here is a scalar except `theme` and `caps`, both of which are
+ * `useMemo`d in `App.tsx` and therefore referentially stable across frames
+ * (I-L2-1, asserted by `render-memo.test.tsx`). If either ever becomes a fresh
+ * object per render this boundary silently becomes a no-op — which is exactly
+ * why that assertion exists rather than a comment.
+ */
+import React from 'react';
 import { Box, Text } from 'ink';
 import { pickGlyphs } from '../glyphs.js';
 import { Markdown } from '../Markdown.js';
-export function AssistantEntry(props) {
-    const { text, thinking, thinkingOpen, thinkingVisible, streaming, aborted, theme, caps } = props;
+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, thinkingMs, revealable, liveClampRows, theme, caps, } = props;
     const glyphs = pickGlyphs(caps);
     const hasThinking = !!thinking && thinking.trim().length > 0;
     const hasText = text.trim().length > 0;
     if (!hasThinking && !hasText && !streaming)
         return null;
-    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 : ''] }), _jsx(Box, { flexDirection: "column", marginLeft: 2, children: thinking.split('\n').map((line, i) => (_jsx(Text, { color: theme.thinking, dimColor: true, children: line }, i))) })] })), (hasText || streaming) && (_jsxs(Box, { flexDirection: "column", children: [hasText ? (_jsx(Markdown, { text: text, theme: theme, caps: caps })) : (_jsx(Text, { color: theme.muted, children: glyphs.ellipsis })), aborted && _jsx(Text, { color: theme.noticeWarn, children: "[aborted]" })] }))] }));
+    // The thinking block is clamped to its TAIL while streaming even in
+    // full-screen mode: it is scratch reasoning the user reads the newest end of,
+    // and an unbounded one is the single easiest way to push a live entry past the
+    // whole viewport.
+    const thinkingRows = liveClampRows ?? (streaming ? STREAMING_THINKING_ROWS : undefined);
+    const clampedThinking = hasThinking && thinkingRows !== undefined
+        ? 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)))] })] })), 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;
+export const AssistantEntry = React.memo(AssistantEntryImpl);

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 {};

package/dist/ui/entries/DiffView.js

@@ -0,0 +1,103 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * 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 { Box, Text } from 'ink';
+/**
+ * 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 const DIFF_COLLAPSED_LINES = 12;
+/** Gutter width bounds; three digits is the floor so narrow files still align. */
+const GUTTER_MIN = 3;
+const GUTTER_MAX = 6;
+/**
+ * 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 function diffRows(patch) {
+    const rows = [];
+    patch.hunks.forEach((hunk, index) => {
+        if (index > 0) {
+            rows.push({
+                kind: 'meta',
+                text: `@@ -${hunk.oldStart},${hunk.oldCount} +${hunk.newStart},${hunk.newCount} @@`,
+            });
+        }
+        for (const line of hunk.lines) {
+            rows.push({
+                kind: line.kind,
+                // An `add` shows its new number, a `del` its old, a `ctx` its new.
+                ...(pickNumber(line) !== undefined ? { num: pickNumber(line) } : {}),
+                text: line.text,
+            });
+        }
+    });
+    return rows;
+}
+function pickNumber(line) {
+    return line.kind === 'del' ? line.oldLine : line.newLine ?? line.oldLine;
+}
+function signOf(kind) {
+    if (kind === 'add')
+        return '+';
+    if (kind === 'del')
+        return '-';
+    return ' ';
+}
+function colorOf(kind, theme) {
+    if (kind === 'add')
+        return theme.diff.add;
+    if (kind === 'del')
+        return theme.diff.remove;
+    if (kind === 'meta')
+        return theme.diff.meta;
+    return theme.diff.context;
+}
+function gutterWidth(rows) {
+    let max = 0;
+    for (const row of rows)
+        if (row.num !== undefined && row.num > max)
+            max = row.num;
+    return Math.min(GUTTER_MAX, Math.max(GUTTER_MIN, String(max).length));
+}
+function DiffViewImpl({ patch, expanded, liveClampRows, theme, }) {
+    const rows = diffRows(patch);
+    const ceiling = Math.min(expanded ? rows.length : DIFF_COLLAPSED_LINES, liveClampRows ?? Number.POSITIVE_INFINITY);
+    const visible = ceiling >= rows.length ? rows : rows.slice(0, Math.max(0, ceiling));
+    const hidden = rows.length - visible.length;
+    const width = gutterWidth(rows);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { wrap: "truncate", children: [_jsxs(Text, { color: theme.diff.add, children: ["+", patch.added] }), _jsx(Text, { color: theme.muted, children: " " }), _jsxs(Text, { color: theme.diff.remove, children: ["-", patch.removed] }), patch.truncated && _jsx(Text, { color: theme.muted, children: " (truncated)" }), patch.degraded && (_jsxs(Text, { color: theme.muted, children: [" old side not read: ", patch.degraded] }))] }), visible.map((row, i) => (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: theme.muted, children: String(row.num ?? '').padStart(width) }), _jsxs(Text, { color: colorOf(row.kind, theme), children: [' ', signOf(row.kind), " ", row.text] })] }, i))), hidden > 0 ? (_jsxs(Text, { color: theme.muted, children: ["+", hidden, " ", hidden === 1 ? 'line' : 'lines', " (Ctrl+O)"] })) : (rows.length > DIFF_COLLAPSED_LINES && _jsx(Text, { color: theme.muted, children: "(Ctrl+O to collapse)" }))] }));
+}
+/**
+ * `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 const DiffView = React.memo(DiffViewImpl);