@aragon-agent/cli 0.5.8 → 0.5.10

package/dist/ui/BottomStatusRow.d.ts

@@ -0,0 +1,65 @@
+/**
+ * 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: toast > activity > update > blank. A toast wins because a
+ * transient ack is a RESPONSE TO THE USER, and the row nearest the input belongs
+ * to it. The update line is LAST because it is the only one of the three that is
+ * PERSISTENT (cli-auto-update D-2): it loses nothing by waiting for the run to
+ * end, whereas an activity line deferred is an activity line that never renders.
+ * That also means a user who is actively working never sees the updater at all
+ * until they stop, which is the whole of the silence requirement.
+ */
+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;
+    /**
+     * `<UpdateLine>` when the updater has something to say, else `null` — AND THE
+     * CALLER DECIDES WHICH (C-15 / cli-auto-update P0-1).
+     *
+     * `if (update)` below tests a REACT ELEMENT, and an element whose own render
+     * returns `null` is still truthy: that branch would emit a box of ZERO rows,
+     * the frame would keep its fixed height, Yoga would hand the row to the
+     * transcript, and `viewportRows()` would go on reporting the old number to
+     * five consumers. So `UpdateLine` is typed `React.ReactElement` and `App`
+     * gates it with `shouldRenderUpdateLine(snapshot)`.
+     *
+     * OPTIONAL, because `bottom-status-row.test.tsx` and the `App.tsx` fixtures
+     * construct this component without it and the test tree is inside
+     * `tsconfig.test.json` (`typecheck-scope.test.ts`); a required prop turns
+     * `npm run typecheck` red for a reason unrelated to this feature (P2-1).
+     */
+    update?: React.ReactNode;
+    theme: Theme;
+}
+export declare function BottomStatusRow({ mode, toasts, activity, update, theme, }: BottomStatusRowProps): React.ReactElement | null;

package/dist/ui/BottomStatusRow.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box } from 'ink';
+import { ToastStack } from './ToastStack.js';
+export function BottomStatusRow({ mode, toasts, activity, update, theme, }) {
+    // A toast wins the row outright.
+    if (toasts.length > 0)
+        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 these are simply one more
+    // conditional row above it.
+    if (activity)
+        return _jsx(Box, { flexShrink: 0, children: activity });
+    if (update)
+        return _jsx(Box, { flexShrink: 0, children: update });
+    // The blank full-screen row that IS the budget must keep being emitted.
+    return _jsx(ToastStack, { toasts: toasts, theme: theme, mode: mode });
+}

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/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,25 @@ 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.
@@ -101,6 +120,24 @@ interface StatusBarProps {
      * 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,6 +4,8 @@ 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. */
@@ -27,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, ecoRung = 0, } = 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';
@@ -53,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: [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)] }))] })] }));
+                                : `[${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

@@ -30,6 +30,7 @@ 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
@@ -44,6 +45,25 @@ 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;
 }
@@ -55,12 +75,15 @@ export interface EntryViewProps {
     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, theme, caps, liveClampRows, }: EntryViewProps): React.ReactElement | null;
+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).
  *
@@ -96,7 +119,7 @@ export declare const EntryView: React.MemoExoticComponent<typeof EntryViewImpl>;
  * `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, cols, heights, mountedSink, }: 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;
@@ -110,5 +133,5 @@ export declare function TranscriptList({ entries, expandedToolIds, thinkingVisib
         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 {};

package/dist/ui/Transcript.js

@@ -37,6 +37,8 @@ import { AssistantEntry } from './entries/AssistantEntry.js';
 import { ToolCard, statusColor, toolEntryGlyph } from './entries/ToolCard.js';
 import { TeamCard, teamCardColor } from './entries/TeamCard.js';
 import { TodoCard, todoCardColor } from './entries/TodoCard.js';
+import { RetryCard, retryCardColor } from './entries/RetryCard.js';
+import { FastCard, fastCardColor } from './entries/FastCard.js';
 import { MeasuredEntry } from './layout/MeasuredEntry.js';
 import { useViewportGeometry } from './layout/viewport-geometry.js';
 import { estimateEntryRows, heightKey, selectWindow, VIRTUAL_LIMITS, } from './layout/virtual-window.js';
@@ -83,10 +85,34 @@ export function computeSettledCount(entries, expandedToolIds) {
         // on every frame for the rest of the session.
         if (e.kind === 'todo' && e.live)
             break;
+        // Nor is a retry card that is still counting down or still in flight: it is
+        // rewritten on every `retryScheduled` / `retryAttempt` and once a second by
+        // `retryTick`, and `<Static>` cannot un-print what it has already drawn.
+        // `session/persist.ts` forces a loaded card to `interrupted`, which is the
+        // other half — a card that never settles is re-rendered on every frame for
+        // the rest of the session (R-10).
+        if (e.kind === 'retry' && (e.phase === 'waiting' || e.phase === 'retrying'))
+            break;
+        // A live review card is not settled either: it is rewritten once, when the
+        // call comes back, and `<Static>` cannot un-print what it has already drawn
+        // (C-5). `session/persist.ts` forces `live: false` on load, which is the
+        // other half.
+        if (e.kind === 'fast' && e.live)
+            break;
         count = i + 1;
     }
     return count;
 }
+/**
+ * The value `EntryView` should receive for `nowSec` on THIS entry.
+ *
+ * `undefined` for everything that is not a running tool, which is what keeps
+ * every other card's memo boundary intact — `undefined === undefined` in the
+ * comparator, on every frame, forever.
+ */
+function nowSecFor(entry, nowSec) {
+    return entry.kind === 'tool' && entry.status === 'running' ? nowSec : undefined;
+}
 function noticeColor(level, theme) {
     if (level === 'error')
         return theme.noticeError;
@@ -101,7 +127,7 @@ function noticeSymbol(level, theme) {
         return theme.symbols.warn;
     return theme.symbols.info;
 }
-function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion, density, theme, caps, liveClampRows, }) {
+function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion, density, mode, theme, caps, liveClampRows, nowSec, }) {
     const glyphs = pickGlyphs(caps);
     const separation = separationRows(prev, entry, density);
     const frame = (glyph, color, children) => (_jsx(EntryFrame, { glyph: glyph, color: color, continuation: glyphs.railVertical, separation: separation, spacerColor: theme.border, children: children }));
@@ -113,14 +139,37 @@ function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion,
             // both an animation and a Unicode-only glyph, so reduced motion and an
             // ASCII terminal fall back to the same static marker (P2-11 / A-10).
             const animate = entry.streaming && !reducedMotion && caps.unicode;
-            return frame(animate ? _jsx(Spinner, { type: "dots" }) : glyphs.assistant, theme.primary, _jsx(AssistantEntry, { text: entry.text, thinking: entry.thinking, thinkingOpen: entry.thinkingOpen, thinkingVisible: thinkingVisible, streaming: entry.streaming, aborted: entry.aborted, liveClampRows: liveClampRows, theme: theme, caps: caps }));
+            return frame(animate ? _jsx(Spinner, { type: "dots" }) : glyphs.assistant, theme.primary, _jsx(AssistantEntry, { text: entry.text, thinking: entry.thinking, thinkingOpen: entry.thinkingOpen, thinkingVisible: thinkingVisible, streaming: entry.streaming, aborted: entry.aborted, 
+                // `EntryViewImpl` hands each renderer EXPLICIT SCALAR PROPS, so
+                // nothing on the entry reaches a component by itself (P1-6b).
+                thinkingMs: entry.thinkingMs, revealable: mode === 'fullscreen', liveClampRows: liveClampRows, theme: theme, caps: caps }));
         }
         case 'tool':
-            return frame(toolEntryGlyph(entry.name, caps), statusColor(entry.status, theme), _jsx(ToolCard, { name: entry.name, label: entry.label, argsRaw: entry.argsRaw, args: entry.args, status: entry.status, preview: entry.preview, durationMs: entry.durationMs, isError: entry.isError, expanded: expanded, reducedMotion: reducedMotion, liveClampRows: liveClampRows, theme: theme, caps: caps }));
+            return frame(toolEntryGlyph(entry.name, caps), statusColor(entry.status, theme), _jsx(ToolCard, { name: entry.name, label: entry.label, argsRaw: entry.argsRaw, args: entry.args, status: entry.status, preview: entry.preview, patch: entry.patch, durationMs: entry.durationMs, isError: entry.isError, expanded: expanded, reducedMotion: reducedMotion, liveClampRows: liveClampRows, 
+                // `entry.live` AND NOT `entry.live ?? []` (P2-4): `ToolCard`'s default
+                // comparator sees a fresh `[]` as a changed prop, which is why that
+                // file already keeps a shared `EMPTY_LINES`.
+                live: entry.live, lastOutputAt: entry.lastOutputAt, nowSec: nowSec, theme: theme, caps: caps }));
         case 'team':
             return frame(glyphs.teamAgent, teamCardColor(entry.runs, entry.active, entry.aborted, theme), _jsx(TeamCard, { requested: entry.requested, runs: entry.runs, aborted: entry.aborted, durationMs: entry.durationMs, active: entry.active, expanded: expanded, reducedMotion: reducedMotion, theme: theme, caps: caps }));
         case 'todo':
             return frame(toolGlyph(glyphs, 'todo_write'), todoCardColor(entry.doneCount, entry.total, entry.live, theme), _jsx(TodoCard, { items: entry.items, doneCount: entry.doneCount, total: entry.total, live: entry.live, interrupted: entry.interrupted, theme: theme, caps: caps }));
+        case 'retry':
+            return frame(entry.phase === 'exhausted' ? glyphs.error : glyphs.retry, retryCardColor(entry.phase, theme), _jsx(RetryCard, { attempt: entry.attempt, maxRetries: entry.maxRetries, errorType: entry.errorType, phase: entry.phase, resumeAt: entry.resumeAt, totalRetries: entry.totalRetries, elapsedMs: entry.elapsedMs, 
+                // READ HERE, not threaded from `App`, and that is what keeps the memo
+                // boundary intact: a `now` prop on every `EntryView` would change on
+                // every frame and re-render the whole transcript. The `retryTick` action
+                // refreshes THIS entry's identity once a second, which re-renders this
+                // one card and gives it a fresh clock; nothing else moves.
+                now: Date.now(), 
+                // NOT THREADED FROM `App`: reaching this renderer means a TUI is
+                // mounted, and the TUI always binds Esc to abort. Headless mode writes
+                // its retry lines to stderr and never mounts an entry component, and the
+                // exit replay goes through `transcript-text.ts`. `RetryCard` keeps the
+                // prop so the render tests can assert the suppressed form.
+                reducedMotion: reducedMotion, theme: theme, caps: caps }));
+        case 'fast':
+            return frame(entry.status === 'failed' ? glyphs.toolError : glyphs.teamAgent, fastCardColor(entry.status, theme), _jsx(FastCard, { reviewIndex: entry.reviewIndex, model: entry.model, status: entry.status, text: entry.text, detail: entry.detail, turn: entry.turn, durationMs: entry.durationMs, live: entry.live, reducedMotion: reducedMotion, theme: theme, caps: caps }));
         case 'notice':
             return frame(noticeSymbol(entry.level, theme), noticeColor(entry.level, theme), _jsx(Text, { color: noticeColor(entry.level, theme), children: entry.text }));
         default:
@@ -148,9 +197,21 @@ export const EntryView = React.memo(EntryViewImpl, (a, b) => {
         a.thinkingVisible === b.thinkingVisible &&
         a.reducedMotion === b.reducedMotion &&
         a.density === b.density &&
+        a.mode === b.mode &&
         a.theme === b.theme &&
         a.caps === b.caps &&
-        a.liveClampRows === b.liveClampRows);
+        a.liveClampRows === b.liveClampRows &&
+        /*
+         * ELEVENTH TERM, AND OMITTING IT IS THE TRAP I-L2-1 DESCRIBES ONE COMMENT UP
+         * (P1-3). This comparator is a CLOSED LIST: a prop absent from it changes
+         * without invalidating the boundary, so `ToolCard` is never re-rendered and
+         * the stall row freezes at whatever second it first drew — AC-26's "and the
+         * seconds advance" failing with nothing reporting it.
+         *
+         * It is free: `nowSecFor` returns `undefined` for every entry that is not a
+         * running tool, and `undefined === undefined` on every frame.
+         */
+        a.nowSec === b.nowSec);
 });
 /**
  * Full-screen transcript body — the same entry renderers with NO `<Static>`.
@@ -172,7 +233,7 @@ export const EntryView = React.memo(EntryViewImpl, (a, b) => {
  * `selectWindow`, and the two spacers are what keep the scroll maths honest
  * while they are absent.
  */
-export function TranscriptList({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, theme, caps, windowSize, cols, heights, mountedSink, }) {
+export function TranscriptList({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, mode, nowSec, theme, caps, windowSize, cols, heights, mountedSink, }) {
     const size = Math.max(1, Math.floor(windowSize));
     const visible = entries.length > size ? entries.slice(-size) : entries;
     const collapsed = entries.length - visible.length;
@@ -190,7 +251,12 @@ export function TranscriptList({ entries, expandedToolIds, thinkingVisible, redu
     const { resolve, report } = heights;
     const heightOf = useCallback((index) => {
         const entry = visible[index];
-        return resolve(keyOf(entry), () => estimateEntryRows(entry, cols, density, !!expandedToolIds[entry.id]));
+        // `thinkingVisible` IS PASSED, not left to the parameter's conservative
+        // default (P1-6a / condition 5). With thinking hidden the default would
+        // inflate every assistant entry that thought by its whole wrapped length,
+        // and an entry estimated at 400 rows against a real height of 1 is exactly
+        // the one `selectWindow` then never mounts and never re-measures.
+        return resolve(keyOf(entry), () => estimateEntryRows(entry, cols, density, !!expandedToolIds[entry.id], thinkingVisible));
     }, 
     // Memoised only incidentally: `visible` IS `entries` while the session is
     // shorter than the horizon and a fresh slice once it is past it, so this
@@ -199,7 +265,7 @@ export function TranscriptList({ entries, expandedToolIds, thinkingVisible, redu
     // `keyOf` is omitted from the list because every input it closes over is
     // already in it.
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [visible, expandedToolIds, cols, density, flags, resolve]);
+    [visible, expandedToolIds, cols, density, flags, resolve, thinkingVisible]);
     const selection = selectWindow({
         entries: visible,
         heightOf,
@@ -212,10 +278,10 @@ export function TranscriptList({ entries, expandedToolIds, thinkingVisible, redu
         mountedSink.current = slice.length;
     return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [collapsed > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.hintFg ?? theme.muted, children: [glyphs.ellipsis, " ", collapsed, " earlier ", collapsed === 1 ? 'entry' : 'entries', " collapsed (/save exports the full session)"] })), selection.leadingRows > 0 && (_jsx(Box, { flexShrink: 0, height: selection.leadingRows })), slice.map((entry, i) => {
                 const index = selection.startIndex + i;
-                return (_jsx(MeasuredEntry, { heightKey: keyOf(entry), onMeasure: report, children: _jsx(EntryView, { entry: entry, prev: index > 0 ? visible[index - 1] : undefined, expanded: !!expandedToolIds[entry.id], thinkingVisible: thinkingVisible, reducedMotion: reducedMotion, density: density, theme: theme, caps: caps }) }, entry.id));
+                return (_jsx(MeasuredEntry, { heightKey: keyOf(entry), onMeasure: report, children: _jsx(EntryView, { entry: entry, prev: index > 0 ? visible[index - 1] : undefined, expanded: !!expandedToolIds[entry.id], thinkingVisible: thinkingVisible, reducedMotion: reducedMotion, density: density, mode: mode, nowSec: nowSecFor(entry, nowSec), theme: theme, caps: caps }) }, entry.id));
             }), selection.trailingRows > 0 && (_jsx(Box, { flexShrink: 0, height: selection.trailingRows }))] }));
 }
-export function Transcript({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, theme, caps, }) {
+export function Transcript({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, mode, nowSec, theme, caps, }) {
     const highWater = useRef(0);
     const prevLen = useRef(0);
     const { rows } = useTerminalSize();
@@ -246,5 +312,5 @@ export function Transcript({ entries, expandedToolIds, thinkingVisible, reducedM
     // a live entry at all, which is worse than a tall frame.
     const liveBudget = Math.max(INLINE_LIVE_MIN_ROWS, rows - INLINE_LIVE_MARGIN);
     const liveClampRows = Math.max(1, Math.floor(liveBudget / Math.max(1, liveEntries.length)) - 1);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: settledEntries, children: (entry, index) => (_jsx(EntryView, { entry: entry, prev: index > 0 ? settledEntries[index - 1] : undefined, expanded: !!expandedToolIds[entry.id], thinkingVisible: thinkingVisible, reducedMotion: reducedMotion, density: density, theme: theme, caps: caps }, entry.id)) }), _jsx(Box, { flexDirection: "column", children: liveEntries.map((entry, i) => (_jsx(EntryView, { entry: entry, prev: i > 0 ? liveEntries[i - 1] : entries[settled - 1], expanded: !!expandedToolIds[entry.id], thinkingVisible: thinkingVisible, reducedMotion: reducedMotion, density: density, theme: theme, caps: caps, liveClampRows: liveClampRows }, entry.id))) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: settledEntries, children: (entry, index) => (_jsx(EntryView, { entry: entry, prev: index > 0 ? settledEntries[index - 1] : undefined, expanded: !!expandedToolIds[entry.id], thinkingVisible: thinkingVisible, reducedMotion: reducedMotion, density: density, mode: mode, theme: theme, caps: caps }, entry.id)) }), _jsx(Box, { flexDirection: "column", children: liveEntries.map((entry, i) => (_jsx(EntryView, { entry: entry, prev: i > 0 ? liveEntries[i - 1] : entries[settled - 1], expanded: !!expandedToolIds[entry.id], thinkingVisible: thinkingVisible, reducedMotion: reducedMotion, density: density, mode: mode, theme: theme, caps: caps, liveClampRows: liveClampRows, nowSec: nowSecFor(entry, nowSec) }, entry.id))) })] }));
 }

package/dist/ui/UpdateLine.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The update line (cli-auto-update section 6.2) - the THIRD occupant of the
+ * already-budgeted bottom row, after the toast stack and the activity line.
+ *
+ * ONE ROW, ALWAYS, AND NEVER `null` (C-15 / P0-1 / D-19). The return type is
+ * `React.ReactElement` rather than `React.ReactElement | null`, so the compiler
+ * refuses the shortcut: `BottomStatusRow` decides presence with `if (update)`,
+ * which tests a REACT ELEMENT, and an element whose render returns `null` is
+ * still truthy. Taking that branch would emit a box of ZERO rows - the frame
+ * keeps its fixed height, Yoga hands the row to the transcript, and
+ * `viewportRows()` goes on reporting the old number to `ScrollViewport`,
+ * `selectWindow`, `overlayMaxRows`, `popupMaxRows` and `todoRailRows`. The
+ * transcript would gain a row while the updater is idle and lose it the moment
+ * it has news. Presence is the CALLER's decision, through
+ * `shouldRenderUpdateLine`, exactly as `App.tsx` already decides the activity
+ * line's with `running && !overlayNode`.
+ *
+ * PURE: a function of `snapshot + compact + theme + caps`. No state, no timer,
+ * no clock. `<Text wrap="truncate">` so a narrow terminal degrades by truncation
+ * rather than by wrapping into a second row the fixed frame cannot afford.
+ *
+ * ASCII ONLY, and every user-visible character comes from `pickGlyphs(caps)`
+ * (C-3). No literal `...`, `+` or `~` may be spelled inline - `ActivityLine`'s
+ * routing of even the ellipsis through `pickGlyphs` is the precedent.
+ *
+ * `compact` RATHER THAN `cols` (IF-1). Section 6.2 describes the width tiers in
+ * terms of `cols`, but resolving them here would mean importing
+ * `UPDATE_LIMITS.statusCompactCols` - a VALUE - from `update/`, and section 3.1
+ * rule 1 requires this module's only edge into that tree to be erasable by tsc.
+ * The caller owns `UPDATE_LIMITS` already (it computes presence from it), so it
+ * resolves the threshold too. Same rule as presence: the call site decides.
+ */
+import React from 'react';
+import type { Theme } from './theme.js';
+import type { TermCapabilities } from './capabilities.js';
+import type { UpdateSnapshot } from '../update/types.js';
+export interface UpdateLineProps {
+    snapshot: UpdateSnapshot;
+    /** `cols < UPDATE_LIMITS.statusCompactCols`, resolved by the caller. */
+    compact: boolean;
+    theme: Theme;
+    caps: TermCapabilities;
+}
+export declare function UpdateLine({ snapshot, compact, theme, caps }: UpdateLineProps): React.ReactElement;