@aragon-agent/cli 0.5.6 → 0.5.9

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

package/dist/ui/entries/RetryCard.js

@@ -0,0 +1,60 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * 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 { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { pickGlyphs } from '../glyphs.js';
+import { formatRetryLine } from '../../agent/retry-view.js';
+/**
+ * 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 function retryCardColor(phase, theme) {
+    if (phase === 'waiting' || phase === 'retrying')
+        return theme.noticeWarn;
+    if (phase === 'exhausted')
+        return theme.noticeError;
+    return theme.muted;
+}
+function RetryCardImpl(props) {
+    const { attempt, maxRetries, errorType, phase, resumeAt, totalRetries, elapsedMs, now, 
+    // DEFAULTS TO TRUE: reaching this component means a TUI is mounted, and the
+    // TUI always binds Esc to abort. The prop exists so headless-shaped callers
+    // and the render tests can assert the suppressed form.
+    interactive = true, reducedMotion, theme, caps, } = props;
+    const glyphs = pickGlyphs(caps);
+    const color = retryCardColor(phase, theme);
+    const inFlight = phase === 'waiting' || phase === 'retrying';
+    const line = formatRetryLine({
+        attempt,
+        maxRetries,
+        errorType,
+        phase,
+        ...(resumeAt !== undefined ? { resumeAt } : {}),
+        ...(totalRetries !== undefined ? { totalRetries } : {}),
+        ...(elapsedMs !== undefined ? { elapsedMs } : {}),
+    }, glyphs, now);
+    // REDUCED MOTION SUPPRESSES THE SPINNER AND KEEPS THE COUNTDOWN. A frozen number
+    // is not calmer, it is broken: reduced motion is about animation, and a
+    // countdown is information.
+    const animate = inFlight && !reducedMotion && caps.unicode;
+    return (_jsxs(Box, { flexDirection: "row", children: [animate ? (_jsxs(Text, { color: color, children: [_jsx(Spinner, { type: "dots" }), ' '] })) : null, _jsx(Text, { color: color, wrap: "truncate", children: line }), phase === 'waiting' && interactive && (_jsxs(Text, { color: theme.muted, children: ['  ', "Esc to cancel"] }))] }));
+}
+/**
+ * `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 const RetryCard = React.memo(RetryCardImpl);

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);
@@ -34,6 +48,18 @@ export function TeamCard(props) {
             : `${formatDuration(durationMs ?? 0)}  (${ok} ok, ${failed} failed)`;
     const count = `${runs.length} ${runs.length === 1 ? 'subagent' : 'subagents'}`;
     const dropped = requested > runs.length ? `  (${runs.length} of ${requested} requested)` : '';
-    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 &&
+    // ABSENT WHEN NO FAST CHILD RAN, so an ordinary dispatch's card is unchanged
+    // (fast-model-tier §6). `n fast` rather than a ratio: the total is already one
+    // column to the left.
+    const fastCount = runs.filter((r) => r.tier === 'fast').length;
+    const fastNote = fastCount > 0 ? `  ${fastCount} fast` : '';
+    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, fastNote, '  '] }), 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}${run.tier === 'fast' ? '~' : ''}`.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.retry && (_jsxs(Text, { color: theme.noticeWarn, bold: true, children: ['  ', "retry ", run.retry.attempt, "/", run.retry.maxRetries] }))] }, 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

@@ -17,6 +17,7 @@ import React from 'react';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
 import type { ToolStatus } from '../../agent/reducer.js';
+import type { FilePatch } from '../../tools/patch.js';
 interface ToolCardProps {
     name: string;
     label: string;
@@ -24,15 +25,63 @@ interface ToolCardProps {
     args?: Record<string, unknown>;
     status: ToolStatus;
     preview?: string;
+    /**
+     * The structured file diff, when the tool produced one (§3.4). Present it and
+     * `DiffView` draws INSTEAD of `ToolPreview`; absent — a session saved by an
+     * older build, an entry the store's 64-write ring evicted, or a toolset built
+     * without a recorder — and the text preview renders exactly what it does
+     * today. Nothing ever renders blank.
+     */
+    patch?: FilePatch;
     durationMs?: number;
     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;
+    /**
+     * The sanitised live tail while the tool runs
+     * (agent-activity-presentation-live §3.3.4).
+     *
+     * PASSED AS `live={entry.live}` AND NEVER `live={entry.live ?? []}` (P2-4).
+     * This component is `React.memo` with the DEFAULT comparator, so a fresh `[]`
+     * per render is a changed prop and defeats the boundary for every settled card
+     * in the transcript — which is exactly why `EMPTY_LINES` above exists.
+     */
+    live?: readonly string[];
+    /** Epoch ms of the last output row; with `nowSec`, the stall row's clock. */
+    lastOutputAt?: number;
+    /**
+     * Wall-clock SECONDS, passed ONLY to running entries (D-29 / D-36).
+     *
+     * Seconds and not milliseconds, and `undefined` on every other card, for the
+     * same reason: a prop that changed five times a second on every entry would
+     * defeat this memo boundary transcript-wide. The value is wall-clock rather
+     * than the ticker's `elapsedMs` because the stall is `now - lastOutputAt` and
+     * `lastOutputAt` is epoch ms; the ticker's job is to cause the render.
+     */
+    nowSec?: 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),
+ * `patch` and `theme` / `caps` (both `useMemo`d in `App.tsx` — I-L2-1).
+ *
+ * `patch` QUALIFIES ONLY BECAUSE THE REDUCER WRITES IT ONCE, at `toolExecEnd`,
+ * and never rebuilds it — `mapEntry` preserves object identity for untouched
+ * entries. A future action that recomputed or normalized a patch would turn this
+ * boundary into a no-op WITH NOTHING FAILING, which is the same trap I-L2-1
+ * exists to catch for `theme` and `caps` (P2-9).
+ */
+export declare const ToolCard: React.MemoExoticComponent<typeof ToolCardImpl>;
 export {};

package/dist/ui/entries/ToolCard.js

@@ -1,12 +1,33 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } 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';
+import { DiffView } from './DiffView.js';
+import { STALL_AFTER_MS } from '../../tools/tool-output-store.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 +79,91 @@ 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, patch, durationMs, isError, expanded, reducedMotion, liveClampRows, live, lastOutputAt, nowSec, 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 settled = status === 'done' || status === 'error';
+    const showPatch = !!patch && settled;
+    // The live tail (agent-activity-presentation-live §3.3.4). `expanded` is
+    // deliberately ABSENT from this arithmetic: `Ctrl+O` is inert on a live card
+    // (D-26), because expansion is a promise about STORED content and the store
+    // deliberately holds eight rows. A key that silently does nothing is better
+    // than a key that promises the rest of a 400 MB stream.
+    //
+    // THE TAIL IS THE **LAST** ROWS, and the settled preview above keeps its
+    // head-first slice (E-21). Two different ends because they answer two
+    // different questions — "what did this command do" versus "what is it doing
+    // NOW" (D-25). Head-first while live would freeze on the first eight lines a
+    // build ever printed and then never change again.
+    const liveRows = live ?? EMPTY_LINES;
+    const liveCeiling = Math.min(COLLAPSED_LINES, 
+    // Inline only: `liveClampRows` already subtracts one row per live entry to
+    // pay for a marker (`Transcript.tsx:534-538`), which is what this card's
+    // unconditional footer spends (AC-36 / P2-7).
+    liveClampRows ?? Number.POSITIVE_INFINITY);
+    const visibleLive = liveRows.length > liveCeiling ? liveRows.slice(-Math.max(1, liveCeiling)) : liveRows;
+    const showLive = !settled && visibleLive.length > 0;
+    // THE OUTER GUARD WIDENS WITH THE BRANCH (P2-2). It was `previewLines.length >
+    // 0 && ...`, and the reducer now truncates the stored preview to ONE LINE when
+    // a patch is attached (D-19) — so a card whose preview were ever empty would
+    // render its header and swallow the diff, silently. It widens a second time
+    // here, for the third branch: without `|| showLive` the tail would be computed
+    // and never drawn.
+    const showBody = ((previewLines.length > 0 || showPatch) && settled) || showLive;
+    // ONE FOOTER ROW, ALWAYS, matching `estimateEntryRows`'s arithmetic exactly: a
+    // CONSTANT row count is what lets the estimate be exact rather than an upper
+    // bound. `nowSec` is absent until the first tick, which reads as "not stalled".
+    const stalledFor = nowSec !== undefined && lastOutputAt !== undefined
+        ? nowSec * 1000 - lastOutputAt
+        : 0;
+    const liveFooter = stalledFor >= STALL_AFTER_MS
+        ? `no output for ${Math.floor(stalledFor / 1000)}s`
+        : '(running)';
     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 && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, isError ? theme.toolError : theme.border), children: showLive ? (_jsxs(_Fragment, { children: [visibleLive.map((row, i) => (
+                        // The row is already terminal-safe and clipped at
+                        // `LIVE_ROW_MAX_CHARS` by `sanitizeChunk`, so `wrap="truncate"`
+                        // is an exact height rather than a hope — which is the coupling
+                        // `estimateEntryRows`'s live branch relies on.
+                        //
+                        // The index IS the key: these rows are positional slots in a
+                        // ring, not identities, and the whole array is replaced on every
+                        // chunk anyway.
+                        //
+                        // AN EMPTY ROW RENDERS AS A SPACE, and that is not cosmetic:
+                        // Ink measures a `<Text>` with an empty child as ZERO rows, so a
+                        // blank separator line — which `npm test`, `cargo` and every
+                        // build tool print — would make the card shorter than
+                        // `estimateEntryRows` charged for it. That is an over-estimate,
+                        // the safe direction, but it would quietly cost §3.3.4's
+                        // "constant row count" the exactness its arithmetic claims. A
+                        // space is also what the terminal itself shows for a blank line.
+                        // eslint-disable-next-line react/no-array-index-key
+                        _jsx(Text, { wrap: "truncate", color: theme.muted, children: row.length > 0 ? row : ' ' }, i))), _jsx(Text, { color: theme.muted, children: liveFooter })] })) : showPatch ? (_jsx(DiffView, { patch: patch, expanded: expanded, liveClampRows: liveClampRows, theme: theme })) : (_jsxs(_Fragment, { 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),
+ * `patch` and `theme` / `caps` (both `useMemo`d in `App.tsx` — I-L2-1).
+ *
+ * `patch` QUALIFIES ONLY BECAUSE THE REDUCER WRITES IT ONCE, at `toolExecEnd`,
+ * and never rebuilds it — `mapEntry` preserves object identity for untouched
+ * entries. A future action that recomputed or normalized a patch would turn this
+ * boundary into a no-op WITH NOTHING FAILING, which is the same trap I-L2-1
+ * exists to catch for `theme` and `caps` (P2-9).
+ */
+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 {};