@aragon-agent/cli 0.5.6 → 0.5.9

package/dist/ui/BottomStatusRow.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The bottom status row — the one already-budgeted row above the composer, now
+ * shared by two occupants (agent-activity-presentation §3.2.3 / D-17 / P0-1).
+ *
+ * THE ACTIVITY LINE IS NOT A NEW `AppShell` SLOT, AND THIS FILE IS WHY.
+ *
+ * `viewportRows()` (`layout/budget.ts`) is the ONE function that says how many
+ * rows the viewport gets, and it enumerates exactly `header + toast + composer +
+ * status`. In full-screen `AppShell`'s root is `height={frameHeight(rows)}` with
+ * `overflow="hidden"`, the bottom chrome box is `flexShrink={0}` and the viewport
+ * box is its only `flexShrink={1}` child — so an extra chrome row does not make
+ * the frame taller, Yoga takes the row out of the TRANSCRIPT. Meanwhile
+ * `viewportRows()` keeps returning the old number to `ScrollViewport`,
+ * `selectWindow`'s spacers, `overlayMaxRows`, `popupMaxRows` and `todoRailRows`.
+ * The transcript would draw one row shorter than every consumer believes, ONLY
+ * WHILE A RUN IS IN FLIGHT, so the layout would shift on submit and shift back on
+ * `agent_end`.
+ *
+ * `ToastStack.tsx` already legislates this for itself: *"in `fullscreen` this
+ * ALWAYS occupies exactly one row — an empty row when there is nothing to say.
+ * Rendering conditionally would make the viewport height (and therefore the whole
+ * transcript) jump every time a toast appears or expires."* A run starts and ends
+ * far more often than a toast appears and expires, so the activity line is the
+ * STRONGER case for that rule, not an exception to it.
+ *
+ * Sharing the row means `budget.ts` and `AppShell.tsx` come out of this round
+ * UNMODIFIED — and `budget.test.ts` asserts that they did (AC-8a, DoD #8).
+ *
+ * PRECEDENCE: a toast wins. A transient ack is a RESPONSE TO THE USER, and the
+ * row nearest the input belongs to it.
+ */
+import React from 'react';
+import type { Theme } from './theme.js';
+import type { Toast } from '../agent/reducer.js';
+import type { RenderMode } from './layout/frame.js';
+export interface BottomStatusRowProps {
+    mode: RenderMode;
+    toasts: Toast[];
+    /** `<ActivityLine>` while a run owns the screen, else `null`. */
+    activity: React.ReactNode;
+    theme: Theme;
+}
+export declare function BottomStatusRow({ mode, toasts, activity, theme, }: BottomStatusRowProps): React.ReactElement | null;

package/dist/ui/BottomStatusRow.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box } from 'ink';
+import { ToastStack } from './ToastStack.js';
+export function BottomStatusRow({ mode, toasts, activity, theme, }) {
+    // A toast wins the row; so does an empty toast stack in full-screen, whose
+    // blank `<Text> </Text>` IS the budgeted row and must keep being emitted.
+    if (toasts.length > 0 || !activity) {
+        return _jsx(ToastStack, { toasts: toasts, theme: theme, mode: mode });
+    }
+    // Inline has no frame and therefore nothing to protect: `ToastStack`'s inline
+    // branch is already a conditional 0-3 row stack, and this is simply one more
+    // conditional row above it.
+    return _jsx(Box, { flexShrink: 0, children: activity });
+}

package/dist/ui/Composer.d.ts

@@ -35,14 +35,9 @@ export interface ComposerProps {
     /** Mirror of the controller's effective mode; drives the chip and the border. */
     agentMode: AgentMode;
     popupMaxRows?: number;
-    /** Pure pass-through to `PromptInput` (mouse-wheel-region-routing §5.6). */
-    historyIntent?: {
-        dir: 'up' | 'down';
-        nonce: number;
-    };
     theme: Theme;
     caps: TermCapabilities;
     onSubmit: (text: string) => void;
     onHelp?: () => void;
 }
-export declare function Composer({ isActive, running, history, commands, cwd, showHint, submitCount, hintsEnabled, agentMode, popupMaxRows, historyIntent, theme, caps, onSubmit, onHelp, }: ComposerProps): React.ReactElement;
+export declare function Composer({ isActive, running, history, commands, cwd, showHint, submitCount, hintsEnabled, agentMode, popupMaxRows, theme, caps, onSubmit, onHelp, }: ComposerProps): React.ReactElement;

package/dist/ui/Composer.js

@@ -56,7 +56,7 @@ function hintText(running, submitCount, glyphs, mode) {
         '? help',
     ].join(dot);
 }
-export function Composer({ isActive, running, history, commands, cwd, showHint, submitCount, hintsEnabled, agentMode, popupMaxRows, historyIntent, theme, caps, onSubmit, onHelp, }) {
+export function Composer({ isActive, running, history, commands, cwd, showHint, submitCount, hintsEnabled, agentMode, popupMaxRows, theme, caps, onSubmit, onHelp, }) {
     const [hasDraft, setHasDraft] = useState(false);
     const onDraftChange = useCallback((next) => setHasDraft(next), []);
     // Plan mode inserts ONE branch, above `draft` and below `running`. The
@@ -73,7 +73,7 @@ export function Composer({ isActive, running, history, commands, cwd, showHint,
                     : theme.idleBorder ?? theme.border;
     const glyphs = pickGlyphs(caps);
     const visible = showHint && hintsEnabled;
-    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsx(PromptInput, { isActive: isActive, running: running, history: history, commands: commands, cwd: cwd, theme: theme, caps: caps, popupMaxRows: popupMaxRows, onSubmit: onSubmit, onHelp: onHelp, agentMode: agentMode, bordered: { color: borderColor }, onDraftChange: onDraftChange, historyIntent: historyIntent }), visible && (
+    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsx(PromptInput, { isActive: isActive, running: running, history: history, commands: commands, cwd: cwd, theme: theme, caps: caps, popupMaxRows: popupMaxRows, onSubmit: onSubmit, onHelp: onHelp, agentMode: agentMode, bordered: { color: borderColor }, onDraftChange: onDraftChange }), visible && (
             // The chip rides the EXISTING hint row rather than adding one, so it
             // costs zero rows on a 24-row terminal.
             _jsxs(Box, { flexDirection: "row", flexShrink: 0, children: [_jsx(Text, { children: '  ' }), _jsx(ModeChip, { mode: agentMode, theme: theme, caps: caps }), _jsx(Text, { wrap: "truncate", color: theme.hintFg ?? theme.muted, children: hintText(running, submitCount, glyphs, agentMode) })] }))] }));

package/dist/ui/Markdown.d.ts

@@ -7,7 +7,13 @@
  * *italic* / `code` / ~~strike~~. Anything else renders as plain text. Still
  * intentionally small — not a CommonMark implementation.
  *
- * The grammar lives in `markdown-blocks.ts`; this file only renders.
+ * The grammar lives in `markdown-blocks.ts`; this file only renders. That was
+ * true of the file header long before it was true of the file
+ * (tui-render-performance R2): the block grammar used to run here, in the render
+ * body, on every frame. Both expensive halves are now memoised on the input
+ * string — `parseMarkdownCached` for the AST, `highlightCached` for the ANSI —
+ * while theme and glyphs stay render-time, so `/theme` still takes effect
+ * immediately (K-5).
  */
 import React from 'react';
 import type { Theme } from './theme.js';

package/dist/ui/Markdown.js

@@ -1,54 +1,27 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
-import { highlight } from 'cli-highlight';
 import { pickGlyphs } from './glyphs.js';
 import { railBorderProps } from './layout/Gutter.js';
-import { formatTable, isRule, isTableDivider, parseHeading, parseInline, parseTableRow, tableAlignments, } from './markdown-blocks.js';
-const FENCE = /^```(\w*)\s*$/;
+import { highlightCached, parseMarkdownCached } from './render-cache.js';
+import { formatTable, isRule, parseHeading, parseInline, } from './markdown-blocks.js';
 /** Width of the `---` rule. Fixed so it cannot force a wrap on narrow frames. */
 const RULE_WIDTH = 24;
 export function Markdown({ text, theme, caps }) {
     const glyphs = pickGlyphs(caps);
-    const lines = text.split('\n');
-    const blocks = [];
-    let i = 0;
-    let key = 0;
-    while (i < lines.length) {
-        const line = lines[i] ?? '';
-        const fence = FENCE.exec(line.trim());
-        if (fence) {
-            const lang = fence[1] || '';
-            const codeLines = [];
-            i += 1;
-            while (i < lines.length && !FENCE.test((lines[i] ?? '').trim())) {
-                codeLines.push(lines[i] ?? '');
-                i += 1;
-            }
-            i += 1; // skip closing fence
-            blocks.push(_jsx(CodeBlock, { code: codeLines.join('\n'), lang: lang, theme: theme, glyphs: glyphs }, `b${key++}`));
-            continue;
-        }
-        // A pipe row followed by a divider row starts a table; consume the run.
-        const headerCells = parseTableRow(line);
-        if (headerCells && i + 1 < lines.length && isTableDivider(lines[i + 1] ?? '')) {
-            const align = tableAlignments(lines[i + 1] ?? '');
-            const rows = [headerCells];
-            i += 2;
-            while (i < lines.length) {
-                const cells = parseTableRow(lines[i] ?? '');
-                if (!cells)
-                    break;
-                rows.push(cells);
-                i += 1;
-            }
-            const formatted = formatTable(rows, align);
-            blocks.push(_jsx(Box, { flexDirection: "column", children: formatted.map((row, r) => (_jsx(Text, { wrap: "truncate", bold: r === 0, color: r === 0 ? theme.accent : undefined, children: row }, r))) }, `b${key++}`));
-            continue;
+    const blocks = parseMarkdownCached(text);
+    return (_jsx(Box, { flexDirection: "column", children: blocks.map((block, i) => renderBlock(block, i, theme, glyphs)) }));
+}
+function renderBlock(block, key, theme, glyphs) {
+    switch (block.kind) {
+        case 'code':
+            return (_jsx(CodeBlock, { code: block.code, lang: block.lang, theme: theme, glyphs: glyphs }, `b${key}`));
+        case 'table': {
+            const formatted = formatTable(block.rows, block.align);
+            return (_jsx(Box, { flexDirection: "column", children: formatted.map((row, r) => (_jsx(Text, { wrap: "truncate", bold: r === 0, color: r === 0 ? theme.accent : undefined, children: row }, r))) }, `b${key}`));
         }
-        blocks.push(_jsx(InlineLine, { line: line, theme: theme, glyphs: glyphs }, `b${key++}`));
-        i += 1;
+        default:
+            return _jsx(InlineLine, { line: block.text, theme: theme, glyphs: glyphs }, `b${key}`);
     }
-    return _jsx(Box, { flexDirection: "column", children: blocks });
 }
 /**
  * Fenced code. The round border is gone (§4.3): nested inside a tool card it
@@ -57,13 +30,7 @@ export function Markdown({ text, theme, caps }) {
  * code" boundary for 1 column and 0 rows.
  */
 function CodeBlock({ code, lang, theme, glyphs, }) {
-    let rendered = code;
-    try {
-        rendered = highlight(code, { language: lang || undefined, ignoreIllegals: true });
-    }
-    catch {
-        rendered = code;
-    }
+    const rendered = highlightCached(code, lang);
     return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: [lang.length > 0 && (_jsx(Text, { color: theme.chip.fg, backgroundColor: theme.chip.bg, children: ` ${lang} ` })), _jsx(Text, { children: rendered })] }));
 }
 /** Six heading levels used to render identically; now they carry three weights. */

package/dist/ui/PromptInput.d.ts

@@ -55,20 +55,6 @@ interface PromptInputProps {
     };
     /** Fires only when the draft flips empty ⇄ non-empty, for the border color. */
     onDraftChange?: (hasDraft: boolean) => void;
-    /**
-     * One prompt-history step, pushed by the wheel router when a notch lands on
-     * the composer band (mouse-wheel-region-routing §5.6). `nonce` is monotonic
-     * so two notches in the same direction are two steps.
-     *
-     * Applied through the SAME `verticalOrHistory` / popup-selection branches the
-     * keyboard uses, deliberately: it means the wheel and `↑`/`↓` cannot drift
-     * apart, and the "never clobber an in-progress draft" guard protects the
-     * wheel for free.
-     */
-    historyIntent?: {
-        dir: 'up' | 'down';
-        nonce: number;
-    };
 }
 /** Apply an edit intent as a pure buffer/cursor transform. */
 export declare function applyEdit(buffer: string, cursor: number, intent: EditIntent): {
@@ -98,5 +84,5 @@ export declare function fileTokenAt(buffer: string, cursor: number): {
     end: number;
     query: string;
 } | null;
-export declare function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, agentMode, onSubmit, onHelp, bordered, onDraftChange, historyIntent, }: PromptInputProps): React.ReactElement;
+export declare function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, agentMode, onSubmit, onHelp, bordered, onDraftChange, }: PromptInputProps): React.ReactElement;
 export {};

package/dist/ui/PromptInput.js

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

package/dist/ui/StatusBar.d.ts

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

package/dist/ui/StatusBar.js

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

package/dist/ui/TeamPanel.d.ts

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

package/dist/ui/TeamPanel.js

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

package/dist/ui/TodoPanel.d.ts

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

package/dist/ui/Transcript.d.ts

@@ -15,12 +15,23 @@
  * 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 React from 'react';
 import { type Theme } from './theme.js';
 import type { TermCapabilities } from './capabilities.js';
 import { type DensityMode } from './density.js';
 import type { Entry } from '../agent/reducer.js';
+import type { RenderMode } from './layout/frame.js';
+import type { HeightStore } from './use-height-store.js';
 /**
  * Largest prefix length P such that `entries[0..P)` are all terminal, none is
  * within the last `LIVE_TAIL` entries, and none is currently expanded. Pure and
@@ -34,9 +45,60 @@ interface TranscriptProps {
     thinkingVisible: boolean;
     reducedMotion: boolean;
     density: DensityMode;
+    /**
+     * The render mode, threaded from `App` as a plain scalar prop.
+     *
+     * It decides whether the collapsed thinking marker may offer `ctrl+t` (D-16):
+     * inline prints settled entries into `<Static>`, which cannot re-print them.
+     * NOT read from a module-level singleton — `render-memo.test.tsx` asserts prop
+     * stability across frames, and a hidden read would be invisible to it.
+     */
+    mode: RenderMode;
+    /**
+     * Wall-clock seconds, threaded from `App`'s existing 200 ms ticker, for the
+     * live tool card's stall row (agent-activity-presentation-live §3.3.4 / D-36).
+     *
+     * BOTH MAP CALLBACKS BELOW DECIDE PER ENTRY WHETHER TO PASS IT ON, and neither
+     * may pass it unconditionally: `ToolCard` is `React.memo` with the default
+     * comparator, so a prop that changes every second on every card would defeat
+     * that boundary for the whole transcript.
+     */
+    nowSec?: number;
     theme: Theme;
     caps: TermCapabilities;
 }
+export interface EntryViewProps {
+    entry: Entry;
+    /** Previous entry in the list; `undefined` for the first item. */
+    prev: Entry | undefined;
+    expanded: boolean;
+    thinkingVisible: boolean;
+    reducedMotion: boolean;
+    density: DensityMode;
+    mode: RenderMode;
+    theme: Theme;
+    caps: TermCapabilities;
+    /** Inline mode only (L5); `undefined` in full-screen, which means no clamp. */
+    liveClampRows?: number;
+    /** Wall-clock seconds; set ONLY on a running tool entry (§3.3.4 / P1-3). */
+    nowSec?: number;
+}
+declare function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion, density, mode, theme, caps, liveClampRows, nowSec, }: EntryViewProps): React.ReactElement | 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 declare const EntryView: React.MemoExoticComponent<typeof EntryViewImpl>;
 /**
  * Full-screen transcript body — the same entry renderers with NO `<Static>`.
  *
@@ -51,12 +113,25 @@ interface TranscriptProps {
  * 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 declare function TranscriptList({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, theme, caps, windowSize, }: TranscriptProps & {
+export declare function TranscriptList({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, mode, nowSec, theme, caps, windowSize, cols, heights, mountedSink, }: TranscriptProps & {
     windowSize: number;
+    /** The viewport's own width — narrower than the terminal when the rail is up. */
+    cols: number;
+    heights: HeightStore;
+    /**
+     * Written during render with the number of entries actually mounted, for
+     * `/perf` (AC-9). A ref rather than a callback: a `setState` here would make
+     * observing the render budget cost a render.
+     */
+    mountedSink?: {
+        current: number;
+    };
 }): React.ReactElement;
-export declare function Transcript({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, theme, caps, }: TranscriptProps): React.ReactElement;
+export declare function Transcript({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, mode, nowSec, theme, caps, }: TranscriptProps): React.ReactElement;
 export {};