@aragon-agent/cli 0.5.6 → 0.5.8

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,18 @@ interface AssistantEntryProps {
     thinkingVisible: boolean;
     streaming: boolean;
     aborted?: 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,43 @@
 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';
+function AssistantEntryImpl(props) {
+    const { text, thinking, thinkingOpen, thinkingVisible, streaming, aborted, 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)))] })] })), (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/TeamCard.d.ts

@@ -28,4 +28,12 @@ export interface TeamCardProps {
 }
 /** The card's aggregate colour: any failure dominates. */
 export declare function teamCardColor(runs: SubagentRun[], active: boolean, aborted: boolean, theme: Theme): string | undefined;
-export declare function TeamCard(props: TeamCardProps): React.ReactElement;
+declare function TeamCardImpl(props: TeamCardProps): React.ReactElement;
+/**
+ * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).
+ * `mapEntry` already preserves object identity for untouched entries, so the
+ * array props below are stable references on a settled card, and `theme` /
+ * `caps` are `useMemo`d in `App.tsx` (I-L2-1).
+ */
+export declare const TeamCard: React.MemoExoticComponent<typeof TeamCardImpl>;
+export {};

package/dist/ui/entries/TeamCard.js

@@ -1,4 +1,18 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * TeamCard — the settled-dispatch transcript entry (team-subagents §6.3).
+ *
+ * ASCII ONLY: every glyph comes from `pickGlyphs`.
+ *
+ * The panel is EPHEMERAL and this card is the HISTORY. It renders like a
+ * `ToolCard` — same `EntryFrame` supplied by `EntryView`, same left rail for the
+ * expanded body — so a dispatch reads as one more step in the transcript rather
+ * than a second kind of object.
+ *
+ * `Ctrl+O` expands it to the per-agent summaries, which is why `App.tsx`'s
+ * Ctrl+O finder had to widen from `kind === 'tool'` to `tool || team`.
+ */
+import React from 'react';
 import { Box, Text } from 'ink';
 import Spinner from 'ink-spinner';
 import { pickGlyphs } from '../glyphs.js';
@@ -15,7 +29,7 @@ export function teamCardColor(runs, active, aborted, theme) {
         return theme.toolError;
     return theme.toolDone;
 }
-export function TeamCard(props) {
+function TeamCardImpl(props) {
     const { requested, runs, aborted, durationMs, active, expanded, reducedMotion, theme, caps } = props;
     const glyphs = pickGlyphs(caps);
     const color = teamCardColor(runs, active, aborted, theme);
@@ -37,3 +51,10 @@ export function TeamCard(props) {
     return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: theme.accent, bold: true, children: "team" }), _jsxs(Text, { color: theme.muted, children: [' ', count, dropped, '  '] }), active && !reducedMotion && caps.unicode ? (_jsxs(Text, { color: color, children: [_jsx(Spinner, { type: "dots" }), " ", headline] })) : (_jsxs(Text, { color: color, children: [active ? `${glyphs.spinnerStill} ` : '', headline] }))] }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: [runs.map((run) => (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: isOk(run) ? theme.toolDone : theme.toolError, children: isOk(run) ? glyphs.toolDone : glyphs.toolError }), _jsxs(Text, { color: theme.primary, children: [" ", run.label.padEnd(8).slice(0, 8)] }), _jsxs(Text, { color: theme.muted, children: [' ', run.description, '  ', run.startedAt ? formatDuration(Math.max(0, (run.endedAt ?? 0) - run.startedAt)) : '', `  ${run.turns} turns`, run.filesTouched.length > 0 ? `  ${run.filesTouched.length} files` : '', run.error ? `  ${run.error}` : ''] })] }, run.label))), expanded &&
                         runs.map((run) => (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { color: theme.accent, children: [run.label, " ", glyphs.midDot, " ", run.description] }), _jsx(Text, { color: theme.muted, children: run.summary ?? '(no summary)' })] }, `s-${run.label}`))), !expanded && !active && runs.length > 0 && (_jsxs(Text, { color: theme.muted, children: ["+", runs.length, " ", runs.length === 1 ? 'summary' : 'summaries', " (Ctrl+O)"] })), expanded && _jsx(Text, { color: theme.muted, children: "(Ctrl+O to collapse)" })] })] }));
 }
+/**
+ * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).
+ * `mapEntry` already preserves object identity for untouched entries, so the
+ * array props below are stable references on a settled card, and `theme` /
+ * `caps` are `useMemo`d in `App.tsx` (I-L2-1).
+ */
+export const TeamCard = React.memo(TeamCardImpl);

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

@@ -28,4 +28,12 @@ export interface TodoCardProps {
 }
 /** The card's aggregate colour: complete is done, anything else is in flight. */
 export declare function todoCardColor(doneCount: number, total: number, live: boolean, theme: Theme): string | undefined;
-export declare function TodoCard(props: TodoCardProps): React.ReactElement;
+declare function TodoCardImpl(props: TodoCardProps): React.ReactElement;
+/**
+ * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).
+ * `mapEntry` already preserves object identity for untouched entries, so the
+ * array props below are stable references on a settled card, and `theme` /
+ * `caps` are `useMemo`d in `App.tsx` (I-L2-1).
+ */
+export declare const TodoCard: React.MemoExoticComponent<typeof TodoCardImpl>;
+export {};

package/dist/ui/entries/TodoCard.js

@@ -1,4 +1,19 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * TodoCard — the transcript checklist entry (todo-plan-execution §6.2).
+ *
+ * ASCII ONLY: every glyph comes from `pickGlyphs`.
+ *
+ * ONE CARD PER USER TURN, REWRITTEN IN PLACE. The rail is EPHEMERAL and this is
+ * the HISTORY, exactly as `TeamPanel` and `TeamCard` divide the same work. It
+ * renders through the shared `EntryFrame` supplied by `EntryView`, so a plan
+ * reads as one more step in the transcript rather than a second kind of object.
+ *
+ * THE FULL LIST, NO WINDOWING (the transcript scrolls; the rail does not), and
+ * NEVER ANIMATED even while `live` — a resumed session would otherwise spin
+ * forever on a card whose run ended days ago.
+ */
+import React from 'react';
 import { Box, Text } from 'ink';
 import { pickGlyphs } from '../glyphs.js';
 import { railBorderProps } from '../layout/Gutter.js';
@@ -24,7 +39,7 @@ function rowColor(item, theme) {
         return theme.primary;
     return theme.hintFg ?? theme.muted;
 }
-export function TodoCard(props) {
+function TodoCardImpl(props) {
     const { items, doneCount, total, live, interrupted, theme, caps } = props;
     const glyphs = pickGlyphs(caps);
     return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: theme.accent, bold: true, children: "Todos" }), _jsxs(Text, { color: todoCardColor(doneCount, total, live, theme), children: ['  ', doneCount, "/", total] }), interrupted && (
@@ -33,3 +48,10 @@ export function TodoCard(props) {
                     // dispatch that never got a duration.
                     _jsxs(Text, { color: theme.muted, children: ['  ', "interrupted (session resumed)"] }))] }), _jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: items.map((item, index) => (_jsxs(Text, { wrap: "truncate", color: rowColor(item, theme), children: [marker(item, glyphs).padEnd(3), item.status === 'in_progress' ? item.activeForm : item.content] }, `${index}-${item.content}`))) })] }));
 }
+/**
+ * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).
+ * `mapEntry` already preserves object identity for untouched entries, so the
+ * array props below are stable references on a settled card, and `theme` /
+ * `caps` are `useMemo`d in `App.tsx` (I-L2-1).
+ */
+export const TodoCard = React.memo(TodoCardImpl);

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

@@ -28,11 +28,23 @@ interface ToolCardProps {
     isError?: boolean;
     expanded?: boolean;
     reducedMotion?: 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 and byte-identical output.
+     */
+    liveClampRows?: number;
     theme: Theme;
     caps: TermCapabilities;
 }
 export declare function statusColor(status: ToolStatus, theme: Theme): string | undefined;
 /** The tool's own glyph, used by `EntryView` as the entry's rail marker. */
 export declare function toolEntryGlyph(name: string, caps: TermCapabilities): string;
-export declare function ToolCard(props: ToolCardProps): React.ReactElement;
+declare function ToolCardImpl(props: ToolCardProps): React.ReactElement;
+/**
+ * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).
+ * Every prop is a scalar except `args` (a stable reference on a settled entry),
+ * `theme` and `caps` (both `useMemo`d in `App.tsx` — I-L2-1).
+ */
+export declare const ToolCard: React.MemoExoticComponent<typeof ToolCardImpl>;
 export {};

package/dist/ui/entries/ToolCard.js

@@ -1,12 +1,31 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Tool-call card (spec §3.5): a per-tool glyph, the tool name, a compact args
+ * summary, a colored status badge, and a duration, over a collapsible rich
+ * preview delegated to `<ToolPreview>`. Collapsed to the first 8 lines with a
+ * `+M lines (Ctrl+O)` footer; `Ctrl+O` / `/expand` toggle the full preview.
+ *
+ * Two v0.4.0 changes (§4.1 / §4.3):
+ *  - capabilities arrive as a prop. This used to infer Unicode support by
+ *    comparing `theme.symbols.gaugeFull` against a literal block character, so
+ *    editing an unrelated gauge glyph would have silently sent every tool icon
+ *    back to ASCII;
+ *  - the preview's round border is gone. It cost 2 rows and 4 columns per card,
+ *    and nested visibly inside markdown code blocks. A left rail carries the
+ *    same grouping in 1 column and 0 rows.
+ */
+import React from 'react';
 import { Box, Text } from 'ink';
 import Spinner from 'ink-spinner';
 import { pickGlyphs, toolGlyph } from '../glyphs.js';
 import { railBorderProps } from '../layout/Gutter.js';
+import { splitLinesCached } from '../render-cache.js';
 import { formatDuration } from '../../agent/usage.js';
 import { ToolPreview, bashBadge } from './ToolPreview.js';
 /** Number of preview lines shown before collapse. */
 const COLLAPSED_LINES = 8;
+/** Shared empty slice, so an argument-less card allocates nothing per frame. */
+const EMPTY_LINES = [];
 export function statusColor(status, theme) {
     switch (status) {
         case 'pending':
@@ -58,15 +77,30 @@ function badgeLabel(name, status, preview) {
 export function toolEntryGlyph(name, caps) {
     return toolGlyph(pickGlyphs(caps), name);
 }
-export function ToolCard(props) {
-    const { name, argsRaw, args, status, preview, durationMs, isError, expanded, reducedMotion, theme, caps, } = props;
+function ToolCardImpl(props) {
+    const { name, argsRaw, args, status, preview, durationMs, isError, expanded, reducedMotion, liveClampRows, theme, caps, } = props;
     const glyphs = pickGlyphs(caps);
     const color = statusColor(status, theme);
     const previewText = preview ?? '';
-    const previewLines = previewText.length > 0 ? previewText.split('\n') : [];
-    const visibleLines = expanded ? previewLines : previewLines.slice(0, COLLAPSED_LINES);
+    // `splitLinesCached` rather than `previewText.split('\n')`: a stored preview
+    // is immutable once written, and this used to reallocate up to 200 strings per
+    // card per frame (R3).
+    const previewLines = previewText.length > 0 ? splitLinesCached(previewText) : EMPTY_LINES;
+    // Head-first, exactly as before: the collapsed card shows the FIRST 8 lines.
+    // The inline clamp only lowers the ceiling — it never changes which end is
+    // kept, because `Ctrl+O` on a 5 000-line bash result is precisely how an
+    // inline session reaches `ink.js:121` (I-L5-1) and the fix must not also
+    // reshuffle what a full-screen user has been reading for four releases.
+    const ceiling = Math.min(expanded ? previewLines.length : COLLAPSED_LINES, liveClampRows ?? Number.POSITIVE_INFINITY);
+    const visibleLines = ceiling >= previewLines.length ? previewLines : previewLines.slice(0, ceiling);
     const hidden = previewLines.length - visibleLines.length;
     const showBody = previewLines.length > 0 && (status === 'done' || status === 'error');
     const badge = status === 'running' && !reducedMotion && caps.unicode ? (_jsxs(Text, { color: color, children: [_jsx(Spinner, { type: "dots" }), " running"] })) : (_jsxs(Text, { color: color, children: [status === 'running' ? `${glyphs.spinnerStill} ` : '', badgeLabel(name, status, previewText)] }));
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: theme.accent, bold: true, children: name }), _jsxs(Text, { color: theme.muted, children: [" ", summarizeArgs(name, glyphs.ellipsis, args, argsRaw), "  "] }), badge, durationMs !== undefined && (_jsxs(Text, { color: theme.muted, children: [" (", formatDuration(durationMs), ")"] }))] }), showBody && (_jsxs(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, isError ? theme.toolError : theme.border), children: [_jsx(ToolPreview, { name: name, lines: visibleLines, theme: theme, isError: isError }), !expanded && hidden > 0 && (_jsxs(Text, { color: theme.muted, children: ["+", hidden, " ", hidden === 1 ? 'line' : 'lines', " (Ctrl+O)"] })), expanded && previewLines.length > COLLAPSED_LINES && (_jsx(Text, { color: theme.muted, children: "(Ctrl+O to collapse)" }))] }))] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: theme.accent, bold: true, children: name }), _jsxs(Text, { color: theme.muted, children: [" ", summarizeArgs(name, glyphs.ellipsis, args, argsRaw), "  "] }), badge, durationMs !== undefined && (_jsxs(Text, { color: theme.muted, children: [" (", formatDuration(durationMs), ")"] }))] }), showBody && (_jsxs(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, isError ? theme.toolError : theme.border), children: [_jsx(ToolPreview, { name: name, lines: visibleLines, theme: theme, isError: isError }), !expanded && hidden > 0 && (_jsxs(Text, { color: theme.muted, children: ["+", hidden, " ", hidden === 1 ? 'line' : 'lines', " (Ctrl+O)"] })), expanded && hidden > 0 && (_jsxs(Text, { color: theme.muted, children: ["+", hidden, " ", hidden === 1 ? 'line' : 'lines', " ", glyphs.midDot, " shown in full when this entry finishes"] })), expanded && previewLines.length > COLLAPSED_LINES && (_jsx(Text, { color: theme.muted, children: "(Ctrl+O to collapse)" }))] }))] }));
 }
+/**
+ * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).
+ * Every prop is a scalar except `args` (a stable reference on a settled entry),
+ * `theme` and `caps` (both `useMemo`d in `App.tsx` — I-L2-1).
+ */
+export const ToolCard = React.memo(ToolCardImpl);

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

@@ -35,7 +35,7 @@ export declare function parseWriteFile(text: string): {
     path: string;
 } | null;
 /** `3 questions · Postgres · REST` — or `dismissed`. */
-export declare function summarizeAskUser(lines: string[]): string | null;
+export declare function summarizeAskUser(lines: readonly string[]): string | null;
 export interface ListRow {
     kind: 'dir' | 'file';
     name: string;
@@ -51,7 +51,7 @@ export declare function parseListRow(line: string): ListRow | null;
  */
 interface ToolPreviewProps {
     name: string;
-    lines: string[];
+    lines: readonly string[];
     theme: Theme;
     isError?: boolean;
 }

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

@@ -8,7 +8,15 @@
  */
 import React from 'react';
 import type { Theme } from '../theme.js';
-export declare function UserEntry({ text, theme }: {
+declare function UserEntryImpl({ text, theme }: {
     text: string;
     theme: Theme;
 }): React.ReactElement;
+/**
+ * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).
+ * `mapEntry` already preserves object identity for untouched entries, so the
+ * array props below are stable references on a settled card, and `theme` /
+ * `caps` are `useMemo`d in `App.tsx` (I-L2-1).
+ */
+export declare const UserEntry: React.MemoExoticComponent<typeof UserEntryImpl>;
+export {};

package/dist/ui/entries/UserEntry.js

@@ -1,5 +1,21 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Render a user message entry.
+ *
+ * The role glyph, the gutter rail and the inter-entry spacing all belong to
+ * `EntryFrame` now (§4.3), so this component renders content and nothing else.
+ * That is also why it takes no `caps`: it has no glyph of its own left to
+ * degrade.
+ */
+import React from 'react';
 import { Box, Text } from 'ink';
-export function UserEntry({ text, theme }) {
+function UserEntryImpl({ text, theme }) {
     return (_jsx(Box, { flexDirection: "column", children: text.split('\n').map((line, i) => (_jsx(Text, { color: theme.user, bold: i === 0, children: line }, i))) }));
 }
+/**
+ * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).
+ * `mapEntry` already preserves object identity for untouched entries, so the
+ * array props below are stable references on a settled card, and `theme` /
+ * `caps` are `useMemo`d in `App.tsx` (I-L2-1).
+ */
+export const UserEntry = React.memo(UserEntryImpl);

package/dist/ui/exit-snapshot.d.ts

@@ -18,6 +18,13 @@ export interface ExitSnapshot {
     provider: string;
     model: string;
     startedAt: number;
+    /**
+     * Entries the retain ring removed (tui-render-performance L1).
+     *
+     * OPTIONAL so every existing caller and test is unchanged; absent means the
+     * replay says nothing, which is correct for a session that dropped nothing.
+     */
+    droppedEntries?: number;
 }
 /** Called by `App` after every view-state change. Synchronous, side-effect free. */
 export declare function publishExitSnapshot(next: ExitSnapshot): void;

package/dist/ui/layout/MeasuredEntry.d.ts

@@ -0,0 +1,21 @@
+/**
+ * One transcript entry, wrapped so its rendered height reaches the height store
+ * (tui-render-performance L3).
+ *
+ * IT MUST NOT CONSTRAIN HEIGHT. The natural height IS the value being measured;
+ * a `height` prop here would make every entry report back whatever it was told,
+ * and the spacers would encode a fiction.
+ *
+ * Ink computes yoga layout in `onRender`, which React runs BEFORE layout
+ * effects, so the measurement below reflects the commit that just happened —
+ * the same mechanism `ScrollViewport.tsx:87-88` and `AppShell.tsx:100-102`
+ * already document and rely on.
+ */
+import React from 'react';
+import type { HeightKey } from './virtual-window.js';
+export interface MeasuredEntryProps {
+    heightKey: HeightKey;
+    onMeasure: (key: HeightKey, rows: number) => void;
+    children: React.ReactNode;
+}
+export declare function MeasuredEntry({ heightKey, onMeasure, children, }: MeasuredEntryProps): React.ReactElement;

package/dist/ui/layout/MeasuredEntry.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * One transcript entry, wrapped so its rendered height reaches the height store
+ * (tui-render-performance L3).
+ *
+ * IT MUST NOT CONSTRAIN HEIGHT. The natural height IS the value being measured;
+ * a `height` prop here would make every entry report back whatever it was told,
+ * and the spacers would encode a fiction.
+ *
+ * Ink computes yoga layout in `onRender`, which React runs BEFORE layout
+ * effects, so the measurement below reflects the commit that just happened —
+ * the same mechanism `ScrollViewport.tsx:87-88` and `AppShell.tsx:100-102`
+ * already document and rely on.
+ */
+import { useLayoutEffect, useRef } from 'react';
+import { Box, measureElement } from 'ink';
+export function MeasuredEntry({ heightKey, onMeasure, children, }) {
+    const ref = useRef(null);
+    // No dependency array on purpose: the entry's content can change without the
+    // key changing identity in a way this component can see, and `report` is a
+    // no-op when the measurement is unchanged — so an unconditional effect costs
+    // one `getComputedHeight()` read and cannot miss a resize.
+    useLayoutEffect(() => {
+        const node = ref.current;
+        if (!node)
+            return;
+        onMeasure(heightKey, measureElement(node).height);
+    });
+    return (_jsx(Box, { ref: ref, flexDirection: "column", flexShrink: 0, children: children }));
+}

package/dist/ui/layout/ScrollViewport.js

@@ -13,9 +13,10 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * measure → setState → re-render → measure loop whose convergence is provable
  * but whose frame count is not — expensive inside a 33 ms streaming window.
  */
-import { useEffect, useLayoutEffect, useRef, useState } from 'react';
+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
 import { Box, Text, measureElement, useStdout } from 'ink';
 import { pickGlyphs } from '../glyphs.js';
+import { ViewportGeometryContext } from './viewport-geometry.js';
 import { applyScrollTimes, clampScroll, } from './scroll.js';
 import { thumbRange } from './scroll-indicator.js';
 import { MIN_INDICATOR_COLS, ScrollIndicator } from './ScrollIndicator.js';
@@ -81,7 +82,12 @@ export function ScrollViewport({ intent, pinToBottomNonce = 0, onScrolledLinesCh
     // more than the affordance. The routing never reads this flag, which is what
     // keeps the indicator independently revertible (§13-Q3).
     const indicatorVisible = showScrollIndicator && cols >= MIN_INDICATOR_COLS;
-    return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: [_jsxs(Box, { flexDirection: "row", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: [_jsx(Box, { ref: clipRef, flexDirection: "column", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(Box, { ref: innerRef, flexDirection: "column", flexShrink: 0, marginTop: -shiftUp, children: children }) }), indicatorVisible && (_jsx(ScrollIndicator, { rows: metrics.viewport, thumb: thumbRange(metrics.viewport, metrics.content, offset), theme: theme, caps: caps }))] }), showHint && (
+    // PUBLISHED, NOT LIFTED (tui-render-performance L3 / §3.3.2). The three
+    // numbers virtualisation needs are already owned here; a `useMemo`d context
+    // value hands them down without adding a second owner or a second measure
+    // pass, which is exactly what this component's header (P1-7) forbids.
+    const geometry = useMemo(() => ({ viewportRows: metrics.viewport, offset, contentRows: metrics.content }), [metrics.viewport, metrics.content, offset]);
+    return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: [_jsxs(Box, { flexDirection: "row", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: [_jsx(Box, { ref: clipRef, flexDirection: "column", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(Box, { ref: innerRef, flexDirection: "column", flexShrink: 0, marginTop: -shiftUp, children: _jsx(ViewportGeometryContext.Provider, { value: geometry, children: children }) }) }), indicatorVisible && (_jsx(ScrollIndicator, { rows: metrics.viewport, thumb: thumbRange(metrics.viewport, metrics.content, offset), theme: theme, caps: caps }))] }), showHint && (
             // Not an overlay — Ink has no absolute positioning or z-index. This takes
             // the viewport's last row, trading one line of content for a hint that
             // cannot drift. Cheaper than stacking with negative margins.

package/dist/ui/layout/viewport-geometry.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Viewport geometry, published downward (tui-render-performance L3).
+ *
+ * `ScrollViewport`'s header records (P1-7) why it — and not its parent — owns
+ * the metrics and the scroll offset: holding the offset in two places creates a
+ * measure -> setState -> re-render -> measure loop whose convergence is provable
+ * but whose frame count is not.
+ *
+ * Virtualisation needs those same three numbers one level DOWN, in
+ * `TranscriptList`. So the viewport PUBLISHES rather than lifting: a `useMemo`d
+ * context value, no new state, no second owner, no extra layout pass.
+ */
+export interface ViewportGeometry {
+    /** Visible height of the clipping box, in rows. `0` before the first measure. */
+    viewportRows: number;
+    /** Rows hidden BELOW the viewport (`layout/scroll.ts` semantics; V-4). */
+    offset: number;
+    /** Natural (unclipped) height of the content, in rows. */
+    contentRows: number;
+}
+/**
+ * The default is the UNMEASURED geometry, and consumers must treat it as such:
+ * a `TranscriptList` rendered outside a `ScrollViewport` (inline mode, and every
+ * test that mounts it bare) sees `viewportRows: 0`, which `selectWindow` reads
+ * as "first frame" and answers by pinning the live tail.
+ */
+export declare const ViewportGeometryContext: import("react").Context<ViewportGeometry>;
+export declare function useViewportGeometry(): ViewportGeometry;

package/dist/ui/layout/viewport-geometry.js

@@ -0,0 +1,27 @@
+/**
+ * Viewport geometry, published downward (tui-render-performance L3).
+ *
+ * `ScrollViewport`'s header records (P1-7) why it — and not its parent — owns
+ * the metrics and the scroll offset: holding the offset in two places creates a
+ * measure -> setState -> re-render -> measure loop whose convergence is provable
+ * but whose frame count is not.
+ *
+ * Virtualisation needs those same three numbers one level DOWN, in
+ * `TranscriptList`. So the viewport PUBLISHES rather than lifting: a `useMemo`d
+ * context value, no new state, no second owner, no extra layout pass.
+ */
+import { createContext, useContext } from 'react';
+/**
+ * The default is the UNMEASURED geometry, and consumers must treat it as such:
+ * a `TranscriptList` rendered outside a `ScrollViewport` (inline mode, and every
+ * test that mounts it bare) sees `viewportRows: 0`, which `selectWindow` reads
+ * as "first frame" and answers by pinning the live tail.
+ */
+export const ViewportGeometryContext = createContext({
+    viewportRows: 0,
+    offset: 0,
+    contentRows: 0,
+});
+export function useViewportGeometry() {
+    return useContext(ViewportGeometryContext);
+}

package/dist/ui/layout/virtual-window.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Viewport virtualisation maths (tui-render-performance L3 / R1). Pure,
+ * React-free, unit-tested.
+ *
+ * THE STRUCTURAL FIX. Ink's `renderNodeToOutput` has no early-out for clipped
+ * subtrees: for every `ink-text` node it runs `squashTextNodes`, `widestLine`
+ * and possibly `wrapText` — all O(chars) — and `Output.get()` then evaluates
+ * `widestLine` a SECOND time before it is allowed to skip an out-of-clip
+ * operation. A clipped 50 000-character entry therefore costs two full string
+ * scans per frame and buys nothing. Bounding the ENTRY COUNT (`transcriptWindow`)
+ * never bounded that, because one entry can be fifty thousand lines.
+ *
+ * So entries outside the visible band are not mounted at all. They are replaced
+ * by two spacer boxes whose heights come from a height cache, which makes the
+ * per-frame cost O(visible rows) instead of O(characters ever produced).
+ *
+ * V-4 — `offset` counts rows FROM THE BOTTOM (`layout/scroll.ts:1-13`), and that
+ * is what makes virtualisation safe here for free: a height correction on an
+ * entry ABOVE the viewport changes the content height and therefore
+ * `overflowLines`, while `offset` — and hence what the user is looking at — is
+ * unchanged. No scroll-anchoring compensation pass is required. Do NOT
+ * "simplify" `offset` to count from the top.
+ */
+import type { Entry } from '../../agent/reducer.js';
+import type { DensityMode } from '../density.js';
+export declare const VIRTUAL_LIMITS: {
+    /**
+     * Entries kept mounted on each side of the visible band.
+     *
+     * V-2 — must stay `>= 2`, so a one-row scroll can never expose an entry whose
+     * height has never been measured at the very edge of the viewport.
+     */
+    readonly overscan: 2;
+    /** Height-cache ceiling (LRU). Four thousand numbers, not four thousand strings. */
+    readonly heightEntries: 4096;
+};
+export type HeightKey = string;
+/**
+ * A cheap content version: it changes exactly when the rendered content does.
+ *
+ * DERIVED, NEVER HASHED. Hashing a 256 KiB string once per entry per frame would
+ * recreate the very cost this module exists to remove, so every field below is
+ * an O(1) read of a length or a scalar.
+ *
+ * I-L3-1 — this must change whenever the rendered output changes. The only lossy
+ * case is a same-LENGTH text replacement, which the reducer cannot produce: all
+ * text fields are append-only (`appendBounded` only ever elides the middle,
+ * which changes the length). A future NON-APPEND mutation MUST extend the
+ * revision, or the entry freezes at a stale height AND a stale rendered subtree
+ * with nothing anywhere reporting it. `virtual-window.test.ts` enumerates every
+ * kind against every mutating action.
+ */
+export declare function entryRevision(entry: Entry): string;
+/**
+ * The height-cache key.
+ *
+ * V-5 — `cols` is part of the key, so a resize invalidates every entry. The
+ * frame after a resize renders from estimates and re-measures lazily: one
+ * reflow, no crash, no stale layout.
+ *
+ * `flags` carries the render-affecting switches that are neither per-entry nor
+ * part of `density` — today only `thinkingVisible` (Ctrl+T). It is a parameter
+ * rather than a fifth positional scalar so a future switch costs one character
+ * at the call site instead of a signature change at four.
+ */
+export declare function heightKey(entry: Entry, cols: number, expanded: boolean, density: DensityMode, flags?: string): HeightKey;
+/**
+ * Pure UPPER-BOUND estimate of an entry's height, used until a real measurement
+ * exists.
+ *
+ * Upper bound rather than best guess, and deliberately so: an over-estimate
+ * makes the scroll position slightly conservative and self-corrects the frame
+ * after the entry is measured, while an under-estimate can put the newest output
+ * off the bottom of a viewport the user believes is pinned.
+ */
+export declare function estimateEntryRows(entry: Entry, cols: number, density: DensityMode, expanded: boolean): number;
+export interface WindowSelection {
+    /** First mounted entry, inclusive. */
+    startIndex: number;
+    /** One past the last mounted entry. */
+    endIndex: number;
+    /** Spacer rows above the mounted slice. */
+    leadingRows: number;
+    /** Spacer rows below the mounted slice. */
+    trailingRows: number;
+    /** Sum of every entry height, measured or estimated. */
+    totalRows: number;
+}
+export interface SelectWindowInput {
+    entries: readonly Entry[];
+    /** Measured, else estimated; never 0 for a real entry. */
+    heightOf: (index: number) => number;
+    viewportRows: number;
+    /** Rows hidden BELOW the viewport — the existing `scroll.ts` semantic (V-4). */
+    offset: number;
+    /** `>= 2` (V-2). Lower values are raised rather than honoured. */
+    overscan: number;
+}
+/** Choose which entries to mount, and how tall the two spacers must be. */
+export declare function selectWindow(input: SelectWindowInput): WindowSelection;