@aragon-agent/cli 0.5.8 → 0.5.10

package/dist/ui/UpdateLine.js

@@ -0,0 +1,129 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { pickGlyphs } from './glyphs.js';
+export function UpdateLine({ snapshot, compact, theme, caps }) {
+    const glyphs = pickGlyphs(caps);
+    const version = snapshot.latestVersion ?? snapshot.currentVersion;
+    const advice = snapshot.advice ?? '';
+    const dot = glyphs.midDot;
+    const line = (() => {
+        if (snapshot.phase === 'installing') {
+            return {
+                glyph: glyphs.arrowUp,
+                text: compact
+                    ? `${version}${glyphs.ellipsis}`
+                    : `updating to ${version}${glyphs.ellipsis}`,
+                color: theme.muted,
+            };
+        }
+        if (snapshot.phase === 'ready') {
+            return {
+                glyph: glyphs.check,
+                text: compact ? `${version} ready` : `${version} installed ${dot} restart aragon to apply`,
+                color: theme.toast.success,
+            };
+        }
+        if (snapshot.phase === 'failed') {
+            // H2's three classified failures (cli-auto-update-hardening section 8).
+            // Each names the REAL obstacle rather than the generic one, because each
+            // is allowed to break the three-strike silence and a notice that breaks
+            // silence must be worth the interruption.
+            if (snapshot.reason === 'blocked-by-os') {
+                // `npm i -g` FROM THE SAME SHELL HITS THE SAME HANDLE. On Windows the
+                // shim that launched us is being read by the `cmd.exe` running it for
+                // as long as our process lives, and npm's install rewrites that shim -
+                // so the generic advice is not merely unhelpful here, it is a wrong
+                // instruction (R-3 / section 5.3.1).
+                return {
+                    glyph: glyphs.warn,
+                    text: compact || !advice
+                        ? 'update blocked'
+                        : `update blocked ${dot} close other aragon windows, then: ${advice}`,
+                    color: theme.noticeWarn,
+                };
+            }
+            if (snapshot.reason === 'no-space') {
+                return {
+                    glyph: glyphs.warn,
+                    text: compact ? 'no disk space' : `update failed ${dot} no disk space`,
+                    color: theme.noticeWarn,
+                };
+            }
+            if (snapshot.reason === 'not-writable') {
+                return {
+                    glyph: glyphs.warn,
+                    text: compact || !advice
+                        ? 'update blocked'
+                        : `update needs write access ${dot} ${advice}`,
+                    color: theme.noticeWarn,
+                };
+            }
+            return {
+                glyph: glyphs.warn,
+                text: compact || !advice ? 'update failed' : `update failed ${dot} ${advice}`,
+                color: theme.noticeWarn,
+            };
+        }
+        if (snapshot.phase === 'available') {
+            if (snapshot.reason === 'node-too-old') {
+                // Both numbers or neither: "needs a newer Node" without saying which is
+                // a notice the user cannot act on.
+                const detail = snapshot.requiredNode && snapshot.runningNode
+                    ? `${version} needs Node ${snapshot.requiredNode} (running ${snapshot.runningNode})`
+                    : `${version} needs a newer Node`;
+                return {
+                    glyph: glyphs.warn,
+                    text: compact ? 'needs newer Node' : detail,
+                    color: theme.noticeWarn,
+                };
+            }
+            if (snapshot.reason === 'install-ineffective') {
+                return {
+                    glyph: glyphs.warn,
+                    text: compact
+                        ? 'check npm prefix'
+                        : `${version} installed elsewhere${advice ? ` ${dot} ${advice}` : ''}`,
+                    color: theme.noticeWarn,
+                };
+            }
+            return {
+                glyph: glyphs.arrowUp,
+                text: compact
+                    ? version
+                    : `${version} available${advice ? ` ${dot} ${advice}` : ''}`,
+                color: theme.muted,
+            };
+        }
+        // H1's rollback notice, and it goes HERE rather than in a phase branch
+        // (cli-auto-update-hardening section 8 / P0-1). It is true for a whole
+        // SESSION rather than for a phase, so `shouldRenderUpdateLine` decides its
+        // presence from `snapshot.rolledBackFrom` outside `phase` entirely - and the
+        // phases that leaves are exactly `idle` / `checking`, which is this
+        // fallthrough. An earlier draft put it in the `failed` / `available`
+        // branches and keyed it on phase `idle`, a phase neither branch handles;
+        // three independent suppressions, so the one line telling a user their CLI
+        // had been silently downgraded could never have appeared.
+        //
+        // NOT `version` ABOVE: that is `latestVersion ?? currentVersion`, and after
+        // a rollback `latestVersion` may well be the BAD release we just escaped.
+        if (snapshot.rolledBackFrom) {
+            const to = snapshot.rolledBackTo ?? snapshot.currentVersion;
+            return {
+                glyph: glyphs.warn,
+                text: compact
+                    ? 'rolled back'
+                    : `rolled back to ${to} after ${snapshot.rolledBackFrom} failed to start`,
+                color: theme.noticeWarn,
+            };
+        }
+        // `idle` / `checking`, and a `failed` below the notice threshold. The CALLER
+        // never mounts us here (`shouldRenderUpdateLine` is false), but the row must
+        // still be exactly one row if it ever is - the same blank-row discipline
+        // `ToastStack` applies to its own budgeted row.
+        return null;
+    })();
+    if (!line) {
+        return (_jsx(Box, { flexShrink: 0, children: _jsx(Text, { children: " " }) }));
+    }
+    return (_jsx(Box, { flexShrink: 0, children: _jsxs(Text, { wrap: "truncate", color: line.color, children: [' ', line.glyph, " ", line.text] }) }));
+}

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

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);

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

@@ -0,0 +1,53 @@
+/**
+ * FastCard — one fast-model review in the transcript (fast-model-tier §6).
+ *
+ * ASCII ONLY: every glyph comes from `pickGlyphs`.
+ *
+ * SINGLE AND QUIET, NEVER MORE THAN SIX ROWS. It renders through the shared
+ * `EntryFrame` supplied by `EntryView`, so a review reads as one more step in
+ * the transcript rather than a second kind of object.
+ *
+ * COLLAPSED BY CONSTRUCTION rather than by an expand toggle: the critique is
+ * already clamped to `fast.reviewMaxChars` before it ever reaches here, so there
+ * is nothing hidden for a `Ctrl+O` to reveal.
+ *
+ * `ok`, `failed` and `dropped` each render ONE muted line. `ok` is the common
+ * case and must stay visually cheap — a full card every few turns saying
+ * "nothing to report" would be the feature's most annoying possible surface —
+ * while `failed` and `dropped` exist so that "it did nothing" is never the
+ * observable outcome (R-8).
+ */
+import React from 'react';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+export type FastCardStatus = 'running' | 'ok' | 'advice' | 'empty' | 'failed' | 'dropped';
+export interface FastCardProps {
+    reviewIndex: number;
+    model: string;
+    status: FastCardStatus;
+    text?: string;
+    detail?: string;
+    turn: number;
+    durationMs?: number;
+    live: boolean;
+    reducedMotion?: boolean;
+    theme: Theme;
+    caps: TermCapabilities;
+}
+/**
+ * The card's colour.
+ *
+ * `advice` is the ACCENT rather than a warning colour: a second opinion is not
+ * an error, and colouring it like one would teach the user to read every review
+ * as something having gone wrong.
+ */
+export declare function fastCardColor(status: FastCardStatus, theme: Theme): string | undefined;
+declare function FastCardImpl(props: FastCardProps): React.ReactElement;
+/**
+ * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).
+ * `mapEntry` already preserves object identity for untouched entries, so the
+ * props below are stable references on a settled card, and `theme` / `caps` are
+ * `useMemo`d in `App.tsx` (I-L2-1).
+ */
+export declare const FastCard: React.MemoExoticComponent<typeof FastCardImpl>;
+export {};

package/dist/ui/entries/FastCard.js

@@ -0,0 +1,87 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * FastCard — one fast-model review in the transcript (fast-model-tier §6).
+ *
+ * ASCII ONLY: every glyph comes from `pickGlyphs`.
+ *
+ * SINGLE AND QUIET, NEVER MORE THAN SIX ROWS. It renders through the shared
+ * `EntryFrame` supplied by `EntryView`, so a review reads as one more step in
+ * the transcript rather than a second kind of object.
+ *
+ * COLLAPSED BY CONSTRUCTION rather than by an expand toggle: the critique is
+ * already clamped to `fast.reviewMaxChars` before it ever reaches here, so there
+ * is nothing hidden for a `Ctrl+O` to reveal.
+ *
+ * `ok`, `failed` and `dropped` each render ONE muted line. `ok` is the common
+ * case and must stay visually cheap — a full card every few turns saying
+ * "nothing to report" would be the feature's most annoying possible surface —
+ * while `failed` and `dropped` exist so that "it did nothing" is never the
+ * observable outcome (R-8).
+ */
+import React from 'react';
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { pickGlyphs } from '../glyphs.js';
+import { railBorderProps } from '../layout/Gutter.js';
+import { formatDuration } from '../../agent/usage.js';
+import { FAST_LIMITS } from '../../fast/limits.js';
+/**
+ * The card's colour.
+ *
+ * `advice` is the ACCENT rather than a warning colour: a second opinion is not
+ * an error, and colouring it like one would teach the user to read every review
+ * as something having gone wrong.
+ */
+export function fastCardColor(status, theme) {
+    if (status === 'running')
+        return theme.toolRunning;
+    if (status === 'advice')
+        return theme.accent;
+    if (status === 'failed')
+        return theme.toolError;
+    return theme.muted;
+}
+/** The one-line summary that follows the header on every non-advice status. */
+function statusLine(props) {
+    switch (props.status) {
+        case 'running':
+            return 'reviewing...';
+        case 'ok':
+            return 'on track';
+        case 'empty':
+            return 'no answer';
+        case 'failed':
+            return props.detail ? `failed: ${props.detail}` : 'failed';
+        case 'dropped':
+            return props.detail ? `dropped: ${props.detail}` : 'dropped';
+        default:
+            return '';
+    }
+}
+/**
+ * Split the critique into at most `FAST_LIMITS.cardTextRows` lines.
+ *
+ * The clamp is a ROW budget, not a character one: `reviewMaxChars` already
+ * bounded the text, and this only stops a critique with no whitespace at all
+ * from turning into a wall on a narrow terminal. Ink wraps the rest.
+ */
+function textRows(text) {
+    const lines = text.split('\n').filter((l) => l.trim().length > 0);
+    return lines.slice(0, FAST_LIMITS.cardTextRows);
+}
+function FastCardImpl(props) {
+    const { reviewIndex, model, status, text, turn, durationMs, live, reducedMotion, theme, caps } = props;
+    const glyphs = pickGlyphs(caps);
+    const color = fastCardColor(status, theme);
+    const duration = durationMs === undefined ? '' : `  ${glyphs.midDot}  ${formatDuration(durationMs)}`;
+    const head = `fast review #${reviewIndex}  ${glyphs.midDot}  ${model}  ${glyphs.midDot}  turn ${turn}${duration}`;
+    const showBody = status === 'advice' && text !== undefined && text.trim().length > 0;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: theme.accent, bold: true, children: "fast" }), live && !reducedMotion && caps.unicode ? (_jsxs(Text, { color: color, children: ['  ', _jsx(Spinner, { type: "dots" }), " ", head] })) : (_jsxs(Text, { color: theme.muted, wrap: "truncate", children: ['  ', live ? `${glyphs.spinnerStill} ` : '', head] }))] }), showBody ? (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: textRows(text).map((line, index) => (_jsx(Text, { color: theme.primary, children: line }, index))) })) : (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, children: _jsx(Text, { color: color, wrap: "truncate", children: statusLine(props) }) }))] }));
+}
+/**
+ * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).
+ * `mapEntry` already preserves object identity for untouched entries, so the
+ * props below are stable references on a settled card, and `theme` / `caps` are
+ * `useMemo`d in `App.tsx` (I-L2-1).
+ */
+export const FastCard = React.memo(FastCardImpl);

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

@@ -0,0 +1,56 @@
+/**
+ * RetryCard — the one-line retry entry (llm-api-retry-backoff §6.5).
+ *
+ * ASCII ONLY: every glyph comes from `pickGlyphs`, and the line itself is built by
+ * the pure `formatRetryLine` in `agent/retry-view.ts` so it can be asserted
+ * without a terminal.
+ *
+ * ONE LINE. ALWAYS ONE LINE. Ten retries rendered as ten notices would bury the
+ * transcript in the one moment the user most needs it legible, so this card is
+ * rewritten in place for the whole turn and settles into a single row of history.
+ * Amber while in flight, muted once recovered, red once the ladder is exhausted.
+ */
+import React from 'react';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+import { type RetryPhase } from '../../agent/retry-view.js';
+export interface RetryCardProps {
+    attempt: number;
+    maxRetries: number;
+    errorType: string;
+    phase: RetryPhase;
+    resumeAt?: number;
+    totalRetries?: number;
+    elapsedMs?: number;
+    /**
+     * `Date.now()` at render, injected so the component stays testable.
+     *
+     * The countdown is recomputed from `resumeAt - now` on every frame; `App` runs a
+     * 1 Hz tick ONLY while the phase is `waiting`, so an idle session has no timer.
+     */
+    now: number;
+    /**
+     * Whether Esc would actually be felt. `App` passes `true` only for an
+     * interactive session, because the hint has to be the truth: the wait is
+     * signal-aware in `withRetry`, so Esc lands within a frame — but there is no Esc
+     * in headless mode to promise.
+     */
+    interactive?: boolean;
+    reducedMotion?: boolean;
+    theme: Theme;
+    caps: TermCapabilities;
+}
+/**
+ * The card's tone. `exhausted` is the only failure: an `interrupted` card records
+ * a user decision, and colouring that red would blame them for it.
+ */
+export declare function retryCardColor(phase: RetryPhase, theme: Theme): string | undefined;
+declare function RetryCardImpl(props: RetryCardProps): React.ReactElement;
+/**
+ * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).
+ * `mapEntry` preserves object identity for untouched entries, and `theme` / `caps`
+ * are `useMemo`d in `App.tsx` (I-L2-1). `now` changes once a second while the card
+ * is waiting, which is exactly when it must re-render.
+ */
+export declare const RetryCard: React.MemoExoticComponent<typeof RetryCardImpl>;
+export {};