@aragon-agent/cli 0.5.8 → 0.5.10

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.js

@@ -48,7 +48,12 @@ function TeamCardImpl(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)" })] })] }));
 }
 /**

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,6 +25,14 @@ 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;
@@ -34,6 +43,28 @@ interface ToolCardProps {
      * 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;
 }
@@ -44,7 +75,13 @@ 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).
+ * `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,4 +1,4 @@
-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
@@ -22,6 +22,8 @@ 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. */
@@ -78,7 +80,7 @@ export function toolEntryGlyph(name, caps) {
     return toolGlyph(pickGlyphs(caps), name);
 }
 function ToolCardImpl(props) {
-    const { name, argsRaw, args, status, preview, durationMs, isError, expanded, reducedMotion, liveClampRows, theme, caps, } = 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 ?? '';
@@ -94,13 +96,74 @@ function ToolCardImpl(props) {
     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 && 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)" }))] }))] }));
+    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),
- * `theme` and `caps` (both `useMemo`d in `App.tsx` — I-L2-1).
+ * `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/glyphs.d.ts

@@ -108,6 +108,15 @@ export interface Glyphs {
     todoPending: string;
     todoActive: string;
     todoDone: string;
+    /**
+     * API retry (llm-api-retry-backoff §6.5). The rail marker on the retry card.
+     *
+     * HERE RATHER THAN IN `RetryCard`, for the reason this file's header gives: a
+     * literal in a component bypasses `pickGlyphs` entirely and shows mojibake on a
+     * legacy console whatever the capability probe said. `glyphs.test.ts`'s static
+     * scan fails the build if either spelling appears anywhere else.
+     */
+    retry: string;
     /**
      * Ink `borderStyle` name for every boxed region (composer, completion popup,
      * overlay frame).

package/dist/ui/glyphs.js

@@ -64,6 +64,7 @@ const UNICODE_GLYPHS = {
     todoPending: '○',
     todoActive: '▸',
     todoDone: '✔',
+    retry: '↻',
     tool: {
         read_file: '▤',
         write_file: '✎',
@@ -125,6 +126,7 @@ const ASCII_GLYPHS = {
     todoPending: '[ ]',
     todoActive: '>',
     todoDone: '[x]',
+    retry: '[r]',
     tool: {
         read_file: '=',
         write_file: '+',

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

@@ -11,7 +11,6 @@
  */
 import React from 'react';
 import { type RenderMode } from './frame.js';
-import { type FrameGeometry } from './regions.js';
 export interface AppShellProps {
     mode: RenderMode;
     rows: number;
@@ -21,11 +20,10 @@ export interface AppShellProps {
     /**
      * The live subagent roster (team-subagents §6.1), or nothing.
      *
-     * IT RENDERS INSIDE `bottomRef` IN THE FULL-SCREEN BRANCH, and it has to
-     * (I-10): `geometryRef.current.bottom` is MEASURED from that box, and the
-     * wheel router uses it to decide whether a notch belongs to the transcript or
-     * to prompt history. A panel rendered above the measured box would make the
-     * composer band boundary stale the instant a dispatch started.
+     * IT RENDERS IN THE BOTTOM CHROME OF THE FULL-SCREEN BRANCH, above `toast` and
+     * below the viewport: the roster is transient status about the run in progress,
+     * so it belongs with the other transient rows rather than inside the scrolling
+     * transcript, where it would be interleaved with history and scroll away.
      */
     team?: React.ReactNode;
     /**
@@ -36,10 +34,11 @@ export interface AppShellProps {
      * primitive and has no business knowing what a todo is. `team` above already
      * leaks content vocabulary in here; there is no reason to repeat it.
      *
-     * IT MUST NOT BE RENDERED 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 RENDERED IN THE MIDDLE BAND, BESIDE THE VIEWPORT (C-6 / I-4) —
+     * that is what makes it a rail rather than another row of bottom chrome. Moved
+     * down into the bottom box it would stop being a column beside the transcript
+     * and start eating viewport height, growing and shrinking the transcript every
+     * time the list changed length.
      *
      * The INLINE branch does not include it at all — a structural guarantee rather
      * than a promise that the caller passes `null` (non-goal 4).
@@ -56,21 +55,13 @@ export interface AppShellProps {
      * both on screen showing the same list (I-6). Fullscreen has the rail; that is
      * the whole design.
      *
-     * It sits between `viewport` and `team`, i.e. OUTSIDE the measured box in the
-     * other branch — but inline has no measured box at all (`geometryRef` is set
-     * to `UNMEASURED_GEOMETRY` there), so there is nothing here to invalidate.
+     * It sits between `viewport` and `team`, mirroring where the rail sits in the
+     * other branch: last thing above the bottom chrome, so the strip and the
+     * roster read top-to-bottom in the same order in both modes.
      */
     strip?: React.ReactNode;
     toast: React.ReactNode;
     composer: React.ReactNode;
     status: React.ReactNode;
-    /**
-     * Where the wheel router reads the composer band boundary from (mouse-wheel
-     * §4.5). Written in a LAYOUT EFFECT to a MUTABLE REF, never to state: the
-     * measurement happens on every commit, and routing it through `setState`
-     * would add a re-render to the streaming path for a value nothing renders
-     * (R-7).
-     */
-    geometryRef?: React.MutableRefObject<FrameGeometry>;
 }
-export declare function AppShell({ mode, rows, cols, header, viewport, team, rail, strip, toast, composer, status, geometryRef, }: AppShellProps): React.ReactElement;
+export declare function AppShell({ mode, rows, cols, header, viewport, team, rail, strip, toast, composer, status, }: AppShellProps): React.ReactElement;

package/dist/ui/layout/AppShell.js

@@ -1,44 +1,9 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-/**
- * AppShell (spec §4.3) — the frame that makes R2 true.
- *
- * In `fullscreen` the root box has a FIXED height of `frameHeight(rows)` and the
- * middle viewport is the only `flexGrow` child, so the bottom chrome (toast /
- * composer / status bar) is physically the last thing on the screen from the
- * very first frame — empty session, long session, mid-scroll, overlay open.
- *
- * In `inline` the same children are emitted in the same order with no height
- * constraint, i.e. byte-for-byte the v0.2.0 document-flow behavior.
- */
-import { useLayoutEffect, useRef } from 'react';
-import { Box, measureElement } from 'ink';
+import { Box } from 'ink';
 import { frameHeight } from './frame.js';
-import { UNMEASURED_GEOMETRY } from './regions.js';
-export function AppShell({ mode, rows, cols, header, viewport, team, rail, strip, toast, composer, status, geometryRef, }) {
-    const bottomRef = useRef(null);
-    // DECLARED ABOVE THE INLINE EARLY RETURN, and it has to stay there: React
-    // keys hooks by call order, and a hook that only runs in one mode changes
-    // that order between modes.
-    //
-    // Ink computes yoga layout in `onRender`, which React runs BEFORE layout
-    // effects, so this reflects the commit that just happened — the same
-    // mechanism `ScrollViewport` already relies on.
-    useLayoutEffect(() => {
-        if (!geometryRef)
-            return;
-        if (mode === 'inline' || !bottomRef.current) {
-            geometryRef.current = UNMEASURED_GEOMETRY;
-            return;
-        }
-        geometryRef.current = {
-            // 1 in the alternate screen — see the note on `FrameGeometry.top`.
-            top: 1,
-            height: frameHeight(rows),
-            bottom: measureElement(bottomRef.current).height,
-        };
-    });
+export function AppShell({ mode, rows, cols, header, viewport, team, rail, strip, toast, composer, status, }) {
     if (mode === 'inline') {
         return (_jsxs(Box, { flexDirection: "column", children: [header, viewport, strip, team, toast, composer, status] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", height: frameHeight(rows), width: cols, overflow: "hidden", children: [_jsx(Box, { flexDirection: "column", flexShrink: 0, children: header }), _jsxs(Box, { flexDirection: "row", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: [_jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: viewport }), rail] }), _jsxs(Box, { ref: bottomRef, flexDirection: "column", flexShrink: 0, children: [team, toast, composer, status] })] }));
+    return (_jsxs(Box, { flexDirection: "column", height: frameHeight(rows), width: cols, overflow: "hidden", children: [_jsx(Box, { flexDirection: "column", flexShrink: 0, children: header }), _jsxs(Box, { flexDirection: "row", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: [_jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: viewport }), rail] }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [team, toast, composer, status] })] }));
 }

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

@@ -73,7 +73,7 @@ export declare function heightKey(entry: Entry, cols: number, expanded: boolean,
  * 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 declare function estimateEntryRows(entry: Entry, cols: number, density: DensityMode, expanded: boolean, thinkingVisible?: boolean): number;
 export interface WindowSelection {
     /** First mounted entry, inclusive. */
     startIndex: number;

package/dist/ui/layout/virtual-window.js

@@ -21,6 +21,7 @@
  * unchanged. No scroll-anchoring compensation pass is required. Do NOT
  * "simplify" `offset` to count from the top.
  */
+import { FAST_LIMITS } from '../../fast/limits.js';
 import { GUTTER_WIDTH } from './Gutter.js';
 export const VIRTUAL_LIMITS = {
     /**
@@ -54,16 +55,52 @@ export function entryRevision(entry) {
             return 'u';
         case 'notice':
             return 'n';
+        // `thinkingMs` is O(1) and it CHANGES THE ROW: sealing the clock turns
+        // `* thought` into `* thought for 12s`, and with thinking hidden that row is
+        // the entry's whole rendered height.
         case 'assistant':
-            return `a${entry.text.length}.${entry.thinking?.length ?? 0}.${entry.streaming ? 1 : 0}.${entry.aborted ? 1 : 0}`;
+            return `a${entry.text.length}.${entry.thinking?.length ?? 0}.${entry.streaming ? 1 : 0}.${entry.aborted ? 1 : 0}.${entry.thinkingMs ?? -1}`;
+        // `patch.lineCount` is PRECOMPUTED for exactly this term: summing
+        // `hunks[].lines.length` per entry per frame is the cost the height cache
+        // exists to remove, and I-L3-1 forbids hashing.
+        // `liveSeq` IS A COUNTER AND NOT `live.length`, and that is precisely the
+        // NON-APPEND mutation I-L3-1 above says must extend the revision: a
+        // fixed-size tail evicting its oldest row while appending a new one of the
+        // same width leaves the joined length unchanged, so a length term would go
+        // on matching while the card's content changed under it.
+        //
+        // SIX TERMS NOW, the longest revision in this file (P2-12). Still O(1) per
+        // entry per frame, which is the property I-L3-1 requires -- but the next
+        // field makes it seven, and a term that is not O(1) would put the cost this
+        // module exists to remove back on every frame.
         case 'tool':
-            return `t${entry.status}.${entry.argsRaw.length}.${entry.preview?.length ?? 0}.${entry.durationMs ?? -1}`;
+            return `t${entry.status}.${entry.argsRaw.length}.${entry.preview?.length ?? 0}.${entry.durationMs ?? -1}.${entry.patch?.lineCount ?? -1}.${entry.liveSeq ?? -1}`;
         case 'team':
             return `m${entry.active ? 1 : 0}.${entry.runs.length}.${entry.runs
                 .map((r) => r.phase[0])
                 .join('')}.${entry.runs.reduce((acc, r) => acc + r.toolCalls, 0)}`;
         case 'todo':
             return `d${entry.live ? 1 : 0}.${entry.doneCount}.${entry.total}.${entry.items.length}`;
+        /**
+         * The retry card is ONE ROW IN EVERY PHASE, so its revision carries the phase
+         * and the counter but deliberately NOT the countdown: `resumeAt` changes the
+         * rendered SECONDS once a second while the height stays 1, and folding it in
+         * here would invalidate the height cache 30 times per backoff to re-measure a
+         * number that cannot change the answer.
+         *
+         * `phase` and `attempt` ARE in, because they change the row's text and a stale
+         * measurement would be wrong in a way nothing reports (I-L3-1).
+         */
+        case 'retry':
+            return `r${entry.phase}.${entry.attempt}.${entry.maxRetries}`;
+        /**
+         * `status`, `live` and the TEXT LENGTH, because all three change the rows the
+         * card draws: `advice` renders a body, everything else renders one line, and
+         * the body's length decides how many rows it wraps to. `durationMs` is in the
+         * header, which is `wrap="truncate"`, so it can never change the height.
+         */
+        case 'fast':
+            return `f${entry.status}.${entry.live ? 1 : 0}.${entry.text?.length ?? 0}.${entry.detail?.length ?? 0}`;
         default:
             return 'x';
     }
@@ -101,6 +138,10 @@ function wrappedRows(text, usable) {
 }
 /** Collapsed preview rows in `ToolCard`; duplicated as a NUMBER, not imported. */
 const TOOL_COLLAPSED_LINES = 8;
+/** Collapsed diff rows in `DiffView`; duplicated for the same reason as above. */
+const DIFF_COLLAPSED_LINES = 12;
+/** Live tail rows in `ToolCard`; duplicated as a NUMBER, for the same reason. */
+const TOOL_LIVE_TAIL_ROWS = 8;
 /**
  * Pure UPPER-BOUND estimate of an entry's height, used until a real measurement
  * exists.
@@ -110,7 +151,7 @@ const TOOL_COLLAPSED_LINES = 8;
  * 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 function estimateEntryRows(entry, cols, density, expanded) {
+export function estimateEntryRows(entry, cols, density, expanded, thinkingVisible = true) {
     const usable = Math.max(1, cols - GUTTER_WIDTH);
     // `separationRows` needs the PRECEDING entry, which a per-entry estimate does
     // not have. One row is its maximum, so charging it unconditionally keeps this
@@ -122,12 +163,60 @@ export function estimateEntryRows(entry, cols, density, expanded) {
         case 'notice':
             return separation + wrappedRows(entry.text, usable);
         case 'assistant': {
-            const thinking = entry.thinking ? 1 + wrappedRows(entry.thinking, usable) : 0;
+            // THE PARAMETER'S `true` DEFAULT IS A FAIL-SAFE FOR A FORGOTTEN CALLER,
+            // NOT THE PLAN FOR THE ONE THERE IS (P1-6a). `Transcript.tsx` holds
+            // `thinkingVisible` as a prop and MUST pass it: with thinking hidden by
+            // default, an unpassed flag inflates every assistant entry that thought by
+            // `1 + wrappedRows(thinking)` — hundreds of rows at `thinkingLevel: high`
+            // against a real height of one. The self-correction argument does not
+            // rescue that, because an entry is only measured once `selectWindow`
+            // mounts it, and an entry estimated at 400 rows is exactly the one that
+            // never gets mounted.
+            const thinking = !entry.thinking
+                ? 0
+                : thinkingVisible
+                    ? 1 + wrappedRows(entry.thinking, usable)
+                    : // The collapsed `thought for Ns` marker is exactly one row, and it is
+                        // suppressed while the entry is still streaming (the activity line is
+                        // the live surface then).
+                        entry.streaming
+                            ? 0
+                            : 1;
             const body = entry.text.length > 0 ? wrappedRows(entry.text, usable) : 1;
             return separation + thinking + body + (entry.aborted ? 1 : 0);
         }
         case 'tool': {
-            if (!entry.preview || (entry.status !== 'done' && entry.status !== 'error')) {
+            const settled = entry.status === 'done' || entry.status === 'error';
+            // WHEN A PATCH IS PRESENT IT, NOT THE PREVIEW, IS WHAT DRAWS (§3.4): the
+            // stored preview is one line by then, so estimating from it would report a
+            // 3-row card for a 12-row diff — an UNDER-estimate, the direction this
+            // file names as unsafe.
+            if (settled && entry.patch) {
+                const rows = entry.patch.lineCount + Math.max(0, entry.patch.hunks.length - 1);
+                const shown = expanded ? rows : Math.min(rows, DIFF_COLLAPSED_LINES);
+                // card header + `+N -M` summary + rows + footer
+                return separation + 1 + 1 + shown + 1;
+            }
+            // THE ONE-LINE `if (!entry.preview || !settled)` THIS REPLACES COVERED TWO
+            // CASES, and both must survive the split (P1-4): not settled, and settled
+            // with nothing to draw (an aborted call, a tool that returned an empty
+            // string). A `!settled` block alone would drop the second into
+            // `wrappedRows(entry.preview, usable)` with `undefined`.
+            if (!settled) {
+                const live = entry.live?.length ?? 0;
+                if (live === 0)
+                    return separation + 1;
+                // Header + tail rows + the unconditional stall/`(running)` footer row.
+                //
+                // ROWS ARE COUNTED, NOT WRAPPED, which is legitimate only because every
+                // live row is rendered `wrap="truncate"` AND clipped at
+                // `LIVE_ROW_MAX_CHARS` on the way into the store -- the same argument
+                // `DiffView.tsx:6-11` makes for itself, and the same coupling: if a
+                // future change lets a live row wrap, this silently UNDER-counts, the
+                // direction this file names as the one the layout cannot absorb.
+                return separation + 1 + Math.min(live, TOOL_LIVE_TAIL_ROWS) + 1;
+            }
+            if (!entry.preview) {
                 return separation + 1;
             }
             const lines = wrappedRows(entry.preview, usable);
@@ -139,6 +228,21 @@ export function estimateEntryRows(entry, cols, density, expanded) {
             return separation + 1 + entry.runs.length + (expanded ? entry.runs.length * 3 + 1 : 1);
         case 'todo':
             return separation + 1 + entry.items.length;
+        // ONE ROW, ALWAYS. The card is `wrap="truncate"` in every phase, so this is an
+        // exact height rather than an upper bound.
+        case 'retry':
+            return separation + 1;
+        // ADDING THE CASE TO ONLY ONE OF THIS FILE'S TWO SWITCHES YIELDS A
+        // TRANSCRIPT WHOSE SCROLL ARITHMETIC DISAGREES WITH WHAT IT DREW, which
+        // manifests as drift rather than as an error (RV-13). Header row, then
+        // either the wrapped critique (clamped to `cardTextRows`) or one status
+        // line — an upper bound, which is what this function owes its caller.
+        case 'fast': {
+            const body = entry.status === 'advice' && entry.text
+                ? Math.min(FAST_LIMITS.cardTextRows, wrappedRows(entry.text, usable))
+                : 1;
+            return separation + 1 + body;
+        }
         default:
             return separation + 1;
     }

package/dist/ui/overlays/HelpOverlay.js

@@ -10,10 +10,10 @@ function keyRows(times) {
         ['Shift+Tab', 'Toggle plan mode (same as /plan)'],
         [`Ctrl+C ${times}2`, 'Exit'],
         ['Ctrl+L', 'Redraw the frame'],
-        ['Ctrl+T', 'Toggle thinking blocks'],
+        ['Ctrl+T', 'Show/hide thinking (off by default)'],
         ['PgUp / PgDn', 'Scroll a page (transcript, or this overlay)'],
         ['Shift+Up / Shift+Down', 'Scroll the transcript a line (full-screen mode)'],
-        ['Wheel', 'Scroll the transcript (over the input box: prompt history)'],
+        ['Wheel', 'Scroll the transcript (or the open overlay)'],
         ['Shift+Wheel', 'Scroll the transcript a page'],
         ['Up / Down', 'Prompt history (empty input)'],
     ];
@@ -27,6 +27,7 @@ const COMMANDS = [
     ['/thinking <level>', 'Set thinking level'],
     ['/max-tokens [n|auto]', 'Output token cap; no argument reports the effective one'],
     ['/team [on|off|max n]', 'Team subagents: status, switch, fan-out width'],
+    ['/fast [on|off|model|review]', 'Fast model tier: status, switch, model, review cadence'],
     [
         '/todo [on|off|panel|follow|clear|continue]',
         'Todo planning: status, switches, the rail, follow-through',
@@ -67,6 +68,16 @@ const TEAM_ROWS = [
     ['--team / --no-team', 'Start a session with team mode on or off (also ARAGON_TEAM=0)'],
     ['team_send / team_wait', 'How subagents message each other; 6 each, one every 15s'],
 ];
+const FAST_ROWS = [
+    ['/fast', 'Status: on/off, the model, the cadence, and this session\'s totals'],
+    ['/fast on | off', 'Switch the tier for this session (and save it)'],
+    ['/fast model <id>', 'Set the fast model; accepts provider:model'],
+    ['/fast same', 'Run the fast tier on the main model'],
+    ['/fast review <n> | off', 'Turns between automatic reviews, or turn them off'],
+    ['/fast delegate on | off', 'Allow model:"fast" on task subagents'],
+    ['--fast / --no-fast', 'Start a session with the tier on or off (also ARAGON_FAST=1)'],
+    ['<fast_review>', 'An automated second opinion from the fast model - advice, not the user'],
+];
 /** Build the overlay's rows. Exported so `app.test.tsx` can count them. */
 export function helpRows(theme, caps) {
     const glyphs = pickGlyphs(caps);
@@ -85,6 +96,9 @@ export function helpRows(theme, caps) {
     rows.push(section('Team subagents'));
     for (const [c, d] of TEAM_ROWS)
         rows.push(pair(c, d));
+    rows.push(section('Fast model tier'));
+    for (const [c, d] of FAST_ROWS)
+        rows.push(pair(c, d));
     rows.push(section('Skills'));
     for (const [c, d] of SKILL_ROWS)
         rows.push(pair(c, d));