@aragon-agent/cli 0.6.8 → 0.6.9

package/dist/ui/Composer.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";
 /**
  * Composer (spec §4.7) — the thin shell around the existing `PromptInput`.
  *
@@ -15,11 +15,30 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  */
 import { useCallback, useState } from 'react';
 import { Box, Text } from 'ink';
+import stringWidth from 'string-width';
 import { pickGlyphs } from './glyphs.js';
 import { HINT_FADE_AFTER } from '../config/schema.js';
 import { PromptInput } from './PromptInput.js';
-import { ModeChip } from './ModeChip.js';
+import { ModeChip, modeChipCols } from './ModeChip.js';
+import { ActivityLabel, resolveActivityLabel } from './ActivityLine.js';
+import { RUN_ROW_LEAD, planRunRow } from './run-status-row.js';
 import { MODE_LABEL, MODE_TOGGLE_KEYS, nextMode } from '../agent/agent-mode.js';
+/**
+ * The running-state hint as separate clauses, most urgent first.
+ *
+ * `hintText` joins them (its output is pinned by AC-43), and the run status row
+ * consumes the SAME array so it can drop whole clauses from the tail on a narrow
+ * terminal instead of cutting `interrupt` in half. One source, two consumers.
+ */
+export function runningHintClauses(opts) {
+    const { glyphs, services } = opts;
+    const clauses = [`${glyphs.enterKey} steer`, `esc${glyphs.times}2 interrupt`];
+    // Confirmation is named even when service controls also need space.
+    if (services > 0)
+        clauses.push(`ctrl+c stop ${services}`);
+    clauses.push(`ctrl+c${glyphs.times}2 exit`);
+    return clauses;
+}
 /**
  * Build the hint row.
  *
@@ -40,18 +59,8 @@ function hintText(opts) {
     // clauses are shown; the row is `wrap="truncate"` and they are ordered
     // most-urgent-first, so a terminal too narrow for all of them drops the exit
     // clause last rather than the abort key.
-    if (running) {
-        if (services > 0) {
-            return [
-                `${glyphs.enterKey} steer`,
-                // Confirmation is named even when service controls also need space.
-                `esc${glyphs.times}2 interrupt`,
-                `ctrl+c stop ${services}`,
-                `ctrl+c${glyphs.times}2 exit`,
-            ].join(dot);
-        }
-        return [`${glyphs.enterKey} steer`, `esc${glyphs.times}2 interrupt`, `ctrl+c${glyphs.times}2 exit`].join(dot);
-    }
+    if (running)
+        return runningHintClauses({ glyphs, services }).join(dot);
     // The hint names the DESTINATION, not the current state — the correct label
     // for a toggle affordance, and the reason the mode word here is the OPPOSITE
     // of the one on the chip beside it.
@@ -86,7 +95,21 @@ function hintText(opts) {
  * than fishing the string out of a rendered frame.
  */
 export const hintTextForTest = hintText;
-export function Composer({ cols, cursorVisible, onInteraction, measureRef, isActive, reducedMotion, onEscape, onEscapeDismiss, running, history, commands, cwd, showHint, submitCount, hintsEnabled, agentMode, services = 0, modeToggleKey = MODE_TOGGLE_KEYS.primary, popupMaxRows, popupMaxHeight, onPopupRowsChange, scrolledLines = 0, onDraftRows, onNotice, theme, caps, onSubmit, onHelp, }) {
+function RunRow({ runRow, cols, services, agentMode, theme, caps, }) {
+    const glyphs = pickGlyphs(caps);
+    const separator = ` ${glyphs.midDot} `;
+    const clauses = runningHintClauses({ glyphs, services });
+    const plan = planRunRow({
+        cols,
+        // Spinner glyph + the space after it, then the label.
+        labelCols: 2 + stringWidth(resolveActivityLabel(runRow.activity, glyphs)),
+        hintClauseCols: clauses.map((clause) => stringWidth(clause)),
+        separatorCols: stringWidth(separator),
+        chipCols: modeChipCols(agentMode),
+    });
+    return (_jsxs(Box, { ref: runRow.rowRef, flexDirection: "row", flexShrink: 0, children: [_jsx(Box, { width: RUN_ROW_LEAD, flexShrink: 0, children: _jsx(Text, { children: ' ' }) }), _jsx(Box, { width: plan.labelCols, flexShrink: 0, children: _jsx(ActivityLabel, { ...runRow.activity, spinnerLive: runRow.live, theme: theme, caps: caps }) }), plan.hintClauses > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.hintFg ?? theme.muted, children: [separator, clauses.slice(0, plan.hintClauses).join(separator)] })), plan.chip && (_jsxs(_Fragment, { children: [_jsx(Box, { flexGrow: 1 }), _jsx(ModeChip, { mode: agentMode, theme: theme, caps: caps })] }))] }));
+}
+export function Composer({ runRow, cols, cursorVisible, onInteraction, measureRef, isActive, reducedMotion, onEscape, onEscapeDismiss, running, history, commands, cwd, showHint, submitCount, hintsEnabled, agentMode, services = 0, modeToggleKey = MODE_TOGGLE_KEYS.primary, popupMaxRows, popupMaxHeight, onPopupRowsChange, scrolledLines = 0, onDraftRows, onNotice, theme, caps, onSubmit, onHelp, }) {
     const [hasDraft, setHasDraft] = useState(false);
     const onDraftChange = useCallback((next) => {
         setHasDraft(next.hasDraft);
@@ -105,8 +128,11 @@ export function Composer({ cols, cursorVisible, onInteraction, measureRef, isAct
                     ? theme.focusBorder ?? theme.primary
                     : theme.idleBorder ?? theme.border;
     const glyphs = pickGlyphs(caps);
-    const visible = showHint && hintsEnabled;
-    return (_jsxs(Box, { ref: measureRef, flexDirection: "column", flexShrink: 0, children: [_jsx(PromptInput, { cols: cols, cursorVisible: cursorVisible, onInteraction: onInteraction, isActive: isActive, reducedMotion: reducedMotion, onEscape: onEscape, onEscapeDismiss: onEscapeDismiss, running: running, history: history, commands: commands, cwd: cwd, theme: theme, caps: caps, popupMaxRows: popupMaxRows, popupMaxHeight: popupMaxHeight, onPopupRowsChange: onPopupRowsChange, onSubmit: onSubmit, onHelp: onHelp, agentMode: agentMode, bordered: { color: borderColor }, onDraftChange: onDraftChange, onNotice: onNotice, scrolledLines: scrolledLines }), visible && (
+    // While the run row is up it REPLACES the hint row below the input (same row
+    // count, so starting a run never moves the layout).
+    const runRowActive = running && !!runRow;
+    const visible = showHint && hintsEnabled && !runRowActive;
+    return (_jsxs(Box, { ref: measureRef, flexDirection: "column", flexShrink: 0, children: [runRowActive && (_jsx(RunRow, { runRow: runRow, cols: cols ?? process.stdout.columns ?? 80, services: services, agentMode: agentMode, theme: theme, caps: caps })), _jsx(PromptInput, { cols: cols, cursorVisible: cursorVisible, onInteraction: onInteraction, isActive: isActive, reducedMotion: reducedMotion, onEscape: onEscape, onEscapeDismiss: onEscapeDismiss, running: running, history: history, commands: commands, cwd: cwd, theme: theme, caps: caps, popupMaxRows: popupMaxRows, popupMaxHeight: popupMaxHeight, onPopupRowsChange: onPopupRowsChange, onSubmit: onSubmit, onHelp: onHelp, agentMode: agentMode, borderColor: borderColor, onDraftChange: onDraftChange, onNotice: onNotice, scrolledLines: scrolledLines }), 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({

package/dist/ui/Header.d.ts

@@ -1,23 +1,9 @@
-/**
- * Header (spec §4.2) — the always-present brand bar.
- *
- * In full-screen this is EXACTLY ONE ROW at every size, which is what makes the
- * viewport height monotonic in `rows` and the first submit jump-free. The 6-row
- * wordmark it used to host now lives in `SessionOpener`, inside the viewport.
- *
- * `banner` survives for the inline path only (`App.tsx` picks it with a local
- * ternary and never calls `pickHeaderVariant`), so inline keeps its v0.3.0
- * geometry. `art` is no longer reachable from here.
- *
- * Every line is `wrap="truncate"`: a long cwd silently costing a second row
- * would push the bottom chrome off-frame and break R2.
- */
+/** One-row brand bar, with a compact variant for narrow terminals. */
 import React from 'react';
 import type { Theme } from './theme.js';
 import type { TermCapabilities } from './capabilities.js';
 import { type HeaderVariant } from './Logo.js';
 interface HeaderProps {
-    version: string;
     cwd: string;
     provider: string;
     model: string;
@@ -26,5 +12,5 @@ interface HeaderProps {
     theme: Theme;
     caps: TermCapabilities;
 }
-export declare function Header({ version, cwd, provider, model, hasKey, variant, theme, caps, }: HeaderProps): React.ReactElement;
+export declare function Header({ cwd, provider, model, hasKey, variant, theme, caps, }: HeaderProps): React.ReactElement;
 export {};

package/dist/ui/Header.js

@@ -1,25 +1,10 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { homedir } from 'node:os';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { basename } from 'node:path';
 import { Box, Text } from 'ink';
 import { Logo } from './Logo.js';
-/** Collapse the home directory to `~` for a shorter path display. */
-function tildeCwd(cwd) {
-    const home = homedir();
-    if (home && cwd.startsWith(home))
-        return `~${cwd.slice(home.length)}`;
-    return cwd;
-}
-function KeyDot({ hasKey, theme }) {
-    return (_jsxs(Text, { color: hasKey ? theme.toolDone : theme.toolRunning, children: [hasKey ? theme.symbols.keyOn : theme.symbols.keyOff, " ", hasKey ? 'key set' : 'no key'] }));
-}
-export function Header({ version, cwd, provider, model, hasKey, variant, theme, caps, }) {
+export function Header({ cwd, provider, model, hasKey, variant, theme, caps, }) {
     if (variant === 'mini') {
         return (_jsx(Box, { flexDirection: "column", flexShrink: 0, children: _jsx(Text, { wrap: "truncate", children: _jsx(Logo, { variant: "mini", theme: theme, caps: caps }) }) }));
     }
-    if (variant === 'bar') {
-        return (_jsx(Box, { flexDirection: "column", flexShrink: 0, children: _jsxs(Text, { wrap: "truncate", children: [_jsx(Logo, { variant: "bar", theme: theme, caps: caps }), _jsxs(Text, { color: theme.accent, children: ['  ', provider, ":", model] }), _jsxs(Text, { color: theme.muted, children: ['  ', basename(cwd) || cwd] }), _jsxs(Text, { color: hasKey ? theme.toolDone : theme.toolRunning, children: ['  ', hasKey ? theme.symbols.keyOn : theme.symbols.keyOff] })] }) }));
-    }
-    // `banner` (inline only): wordmark row + meta row.
-    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsx(Logo, { variant: variant, theme: theme, caps: caps }), _jsxs(Text, { wrap: "truncate", children: [_jsxs(Text, { color: theme.muted, children: ["v", version] }), _jsxs(Text, { color: theme.accent, children: ['   ', provider, ":", model] }), _jsx(Text, { children: '   ' }), _jsx(KeyDot, { hasKey: hasKey, theme: theme }), _jsxs(Text, { color: theme.muted, children: ['   ', tildeCwd(cwd)] })] })] }));
+    return (_jsx(Box, { flexDirection: "column", flexShrink: 0, children: _jsxs(Text, { wrap: "truncate", children: [_jsx(Logo, { variant: "bar", theme: theme, caps: caps }), _jsxs(Text, { color: theme.accent, children: ['  ', provider, ":", model] }), _jsxs(Text, { color: theme.muted, children: ['  ', basename(cwd) || cwd] }), _jsxs(Text, { color: hasKey ? theme.toolDone : theme.toolRunning, children: ['  ', hasKey ? theme.symbols.keyOn : theme.symbols.keyOff] })] }) }));
 }

package/dist/ui/Logo.d.ts

@@ -8,25 +8,9 @@ import type { TermCapabilities } from './capabilities.js';
 /** 6 rows × 52 columns, every row equal width (pinned by logo.test.ts). */
 export declare const LOGO_ART: readonly string[];
 export declare const LOGO_ART_WIDTH = 52;
-export type HeaderVariant = 'art' | 'banner' | 'bar' | 'mini';
+export type HeaderVariant = 'bar' | 'mini';
 /** How the one-off opening wordmark renders inside the viewport (§4.2). */
 export type OpenerVariant = 'art' | 'banner' | 'none';
-/**
- * Pick the header tier (spec §4.2).
- *
- * `cols` is the only input, and that is the point. The old signature also took
- * `empty` and `rows` and could return `art`, so the brand region was 8 rows tall
- * on an empty session and 1 row afterwards: sending the first message made the
- * viewport jump by 7 rows, and widening a 27-row terminal to 28 rows made the
- * visible content SHRINK. A constant-height brand bar removes both, which is
- * what lets `budget.ts::viewportRows` be monotonic (A-3/A-4/A-9).
- *
- * The wordmark did not disappear — it moved into the viewport as
- * `SessionOpener`, where it scrolls away like any other content.
- *
- * NOTE: `Header` still renders `banner`; the inline path picks it directly at
- * `App.tsx` and does not call this function.
- */
 export declare function pickHeaderVariant(cols: number): HeaderVariant;
 /**
  * Pick the opening wordmark tier.

package/dist/ui/Logo.js

@@ -22,22 +22,6 @@ const ART_MIN_VIEWPORT_ROWS = 14;
 const ART_MIN_COLS = LOGO_ART_WIDTH + 4;
 const BANNER_MIN_COLS = 48;
 const BAR_MIN_COLS = 40;
-/**
- * Pick the header tier (spec §4.2).
- *
- * `cols` is the only input, and that is the point. The old signature also took
- * `empty` and `rows` and could return `art`, so the brand region was 8 rows tall
- * on an empty session and 1 row afterwards: sending the first message made the
- * viewport jump by 7 rows, and widening a 27-row terminal to 28 rows made the
- * visible content SHRINK. A constant-height brand bar removes both, which is
- * what lets `budget.ts::viewportRows` be monotonic (A-3/A-4/A-9).
- *
- * The wordmark did not disappear — it moved into the viewport as
- * `SessionOpener`, where it scrolls away like any other content.
- *
- * NOTE: `Header` still renders `banner`; the inline path picks it directly at
- * `App.tsx` and does not call this function.
- */
 export function pickHeaderVariant(cols) {
     return cols >= BAR_MIN_COLS ? 'bar' : 'mini';
 }

package/dist/ui/ModeChip.d.ts

@@ -1,21 +1,3 @@
-/**
- * ModeChip — the `PLAN` badge on the composer's hint row (plan-mode §6.1).
- *
- * `theme.chip = { fg, bg }` exists in every palette and was, until now, unused.
- * A mode badge is what it was for.
- *
- * SHOWN ONLY IN PLAN MODE. `BUILD` is the default, and a badge that is always on
- * is furniture rather than signal; it also means the Build-mode composer renders
- * exactly as it did before this feature existed.
- *
- * THE CHIP IS AN ENHANCEMENT, NOT THE GUARANTEE (P1-6). It rides the hint row,
- * which disappears on a short terminal (`showHint`), under `hints: false`, and
- * in inline render mode (which mounts a bare `PromptInput` and never mounts
- * `Composer` at all). The GUARANTEED carrier is the status-bar word, which
- * renders in both `AppShell` branches and has no opt-out. If you ever move the
- * mode indicator, that is the constraint to preserve: the status bar must always
- * name a non-default mode; the chip may.
- */
 import React from 'react';
 import type { Theme } from './theme.js';
 import type { TermCapabilities } from './capabilities.js';
@@ -25,5 +7,12 @@ interface ModeChipProps {
     theme: Theme;
     caps: TermCapabilities;
 }
+/**
+ * Columns `ModeChip` occupies, including its trailing gap (plan => label + 3, any
+ * other mode 0). Both render branches (padded background chip, bracketed text)
+ * come to the same width, which is what lets the run status row budget for it
+ * without measuring a rendered element.
+ */
+export declare function modeChipCols(mode: AgentMode): number;
 export declare function ModeChip({ mode, theme, caps }: ModeChipProps): React.ReactElement | null;
 export {};

package/dist/ui/ModeChip.js

@@ -1,6 +1,15 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { MODE_LABEL } from '../agent/agent-mode.js';
+/**
+ * Columns `ModeChip` occupies, including its trailing gap (plan => label + 3, any
+ * other mode 0). Both render branches (padded background chip, bracketed text)
+ * come to the same width, which is what lets the run status row budget for it
+ * without measuring a rendered element.
+ */
+export function modeChipCols(mode) {
+    return mode === 'plan' ? MODE_LABEL[mode].length + 3 : 0;
+}
 export function ModeChip({ mode, theme, caps }) {
     if (mode !== 'plan')
         return null;

package/dist/ui/PromptInput.d.ts

@@ -62,15 +62,7 @@ interface PromptInputProps {
      * (see the first statement of the input handler).
      */
     agentMode?: AgentMode;
-    /**
-     * Set by `Composer` in full-screen mode: draw the rounded frame around the
-     * input row only, so the autocomplete popup lands OUTSIDE it (spec §4.7)
-     * without lifting the editor's buffer/cursor state out of this component.
-     * Unset ⇒ the v0.2.0 borderless inline rendering.
-     */
-    bordered?: {
-        color?: string;
-    };
+    borderColor?: string;
     /**
      * Fires when the draft flips empty ⇄ non-empty (for the border color) OR when
      * its ROW COUNT changes (for `layout/budget.ts`) — never per keystroke.
@@ -95,24 +87,6 @@ interface PromptInputProps {
      * component is the only place that holds both facts.
      */
     onNotice?: (level: 'warn' | 'error', text: string) => void;
-    /**
-     * Rows of newer output hidden BELOW the viewport — `ScrollViewport`'s offset
-     * (tui-selection-and-scroll-follow §4.2 / G7).
-     *
-     * Rendered as a right-aligned chip ON THE INPUT ROW, INSIDE THE BORDER, which
-     * is what the requirement asks for (输入框内部) and what makes the hint cost
-     * zero rows. It used to take the viewport's own last row, which spent a line of
-     * the user's content exactly when the transcript was longest AND fed the number
-     * back into its own derivation (§3.3).
-     *
-     * IT IS STATE, NOT A HINT. It deliberately ignores `showHint` / `hintsEnabled`
-     * — those govern the teaching row BELOW the box, which fades with experience
-     * and is dropped on a short terminal. "You are 12 rows behind the newest
-     * output" must survive both (T-23).
-     *
-     * Only meaningful in full-screen mode, so it renders only when `bordered` is
-     * set: inline mode has no self-drawn viewport and this is always 0 there.
-     */
     scrolledLines?: number;
 }
 export interface ScrollChip {
@@ -179,5 +153,5 @@ export declare function fileTokenAt(buffer: string, cursor: number): {
     end: number;
     query: string;
 } | null;
-export declare function PromptInput({ cols: colsProp, cursorVisible, onInteraction, isActive, running, history, commands, cwd, theme, caps, popupMaxRows, popupMaxHeight, onPopupRowsChange, agentMode, onSubmit, onHelp, onEscape, onEscapeDismiss, reducedMotion, bordered, onDraftChange, onNotice, scrolledLines, }: PromptInputProps): React.ReactElement;
+export declare function PromptInput({ cols: colsProp, cursorVisible, onInteraction, isActive, running, history, commands, cwd, theme, caps, popupMaxRows, popupMaxHeight, onPopupRowsChange, agentMode, onSubmit, onHelp, onEscape, onEscapeDismiss, reducedMotion, borderColor, onDraftChange, onNotice, scrolledLines, }: PromptInputProps): React.ReactElement;
 export {};

package/dist/ui/PromptInput.js

@@ -248,7 +248,7 @@ function isControlSeq(input) {
 // ---------------------------------------------------------------------------
 // Component
 // ---------------------------------------------------------------------------
-export function PromptInput({ cols: colsProp, cursorVisible = true, onInteraction, isActive, running, history, commands, cwd, theme, caps, popupMaxRows, popupMaxHeight, onPopupRowsChange, agentMode, onSubmit, onHelp, onEscape, onEscapeDismiss, reducedMotion = false, bordered, onDraftChange, onNotice, scrolledLines = 0, }) {
+export function PromptInput({ cols: colsProp, cursorVisible = true, onInteraction, isActive, running, history, commands, cwd, theme, caps, popupMaxRows, popupMaxHeight, onPopupRowsChange, agentMode, onSubmit, onHelp, onEscape, onEscapeDismiss, reducedMotion = false, borderColor, onDraftChange, onNotice, scrolledLines = 0, }) {
     const { stdout } = useStdout();
     const [editor, dispatch] = useReducer(editorReducer, INITIAL_EDITOR_STATE);
     const { buffer, cursor, historyIndex, dismissed, sel } = editor;
@@ -317,14 +317,11 @@ export function PromptInput({ cols: colsProp, cursorVisible = true, onInteractio
     const glyphs = pickGlyphs(caps);
     const cols = colsProp ?? stdout?.columns ?? 80;
     const terminalRows = stdout?.rows ?? 24;
-    // Full-screen only: inline mode has no self-drawn viewport, so `scrolledLines`
-    // is always 0 there and the branch is unreachable rather than merely unused.
-    // The guard is explicit so it stays that way.
-    const chip = bordered ? scrollChip(scrolledLines, cols, glyphs) : null;
+    const chip = scrollChip(scrolledLines, cols, glyphs);
     // Err NARROW. Wrapping wider than the box Ink gives us would make Ink wrap a
     // second time, and then `layout.rows.length` is a lie — which is the one thing
     // this module may not be.
-    const chromeCols = bordered ? 2 /* border */ + 2 /* paddingX */ + 2 /* marker */ : 2;
+    const chromeCols = 2 /* border */ + 2 /* paddingX */ + 2 /* marker */;
     const baseCols = Math.max(8, cols - chromeCols - (chip ? chip.cells + 1 : 0));
     const measure = (wrapCols) => layoutComposer({
         buffer,
@@ -599,5 +596,5 @@ export function PromptInput({ cols: colsProp, cursorVisible = true, onInteractio
             // the user is typing — `↓ 9` becomes `↓ 10` becomes `↓ 100` — and every
             // change would otherwise re-wrap a draft that fills the line.
             _jsx(Box, { flexShrink: 0, alignSelf: "flex-start", marginLeft: 1, width: chip.cells, justifyContent: "flex-end", children: _jsx(Text, { wrap: "truncate", color: theme.hintFg ?? theme.muted, children: chip.text }) }))] }));
-    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [popupVisible && (_jsx(AutocompletePopup, { items: popupItems, selected: clampedSel, theme: theme, caps: caps, maxRows: popupMaxRows, layout: popupLayout })), bordered ? (_jsx(Box, { flexDirection: "column", flexShrink: 0, borderStyle: glyphs.boxStyle, borderColor: bordered.color, paddingX: 1, children: inputRow })) : (inputRow)] }));
+    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [popupVisible && (_jsx(AutocompletePopup, { items: popupItems, selected: clampedSel, theme: theme, caps: caps, maxRows: popupMaxRows, layout: popupLayout })), (_jsx(Box, { flexDirection: "column", flexShrink: 0, borderStyle: glyphs.boxStyle, borderColor: borderColor, paddingX: 1, children: inputRow }))] }));
 }

package/dist/ui/StatusBar.d.ts

@@ -52,17 +52,6 @@ interface StatusBarProps {
      * Ctrl+L redraw carrier — invariant I-5 (spec §4.13). See `redrawChar`.
      */
     redrawNonce?: number;
-    /**
-     * The session mode. THIS IS THE GUARANTEED MODE INDICATOR (plan-mode §6.4 /
-     * P1-6): the composer chip disappears on a short terminal, under
-     * `hints: false`, and in inline render mode, but `StatusBar` renders in both
-     * `AppShell` branches and its left cluster has no opt-out and no width gate.
-     *
-     * Design intent, stated here so it survives a later refactor: the status bar
-     * must ALWAYS name a non-default mode; the chip may. Do not give this a
-     * `cols >= N` breakpoint, and do not move it into the right cluster — those
-     * children are flexible and drop characters under pressure.
-     */
     agentMode?: AgentMode;
     /** Non-null while a deferred `plan -> build` waits for `agent_end`. */
     pendingAgentMode?: AgentMode | null;

package/dist/ui/ToastStack.d.ts

@@ -1,24 +1,8 @@
-/**
- * Toast strip (spec §4.8). Ephemeral acks created by App/commands and
- * auto-dismissed by App's TTL effect; the reducer stays timer-free.
- *
- * 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.
- * There is deliberately no `rows` threshold: jitter is a layout property, not a
- * space property, and a short terminal suffers it proportionally MORE, so the
- * tier that most needs the fixed row is exactly the one a threshold would skip.
- * Only the newest toast is shown; older ones collapse into a `+N` counter.
- *
- * `inline` keeps the v0.2.0 conditional 0–3 row stack: without a fixed frame,
- * growing and shrinking is just normal document flow.
- */
+/** Fixed one-row toast strip; only the newest toast is shown. */
 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 declare function ToastStack({ toasts, theme, mode, }: {
+export declare function ToastStack({ toasts, theme, }: {
     toasts: Toast[];
     theme: Theme;
-    mode?: RenderMode;
 }): React.ReactElement | null;

package/dist/ui/ToastStack.js

@@ -1,6 +1,5 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
-const MAX_VISIBLE = 3;
 function toastColor(level, theme) {
     switch (level) {
         case 'success':
@@ -25,14 +24,8 @@ function toastGlyph(level, theme) {
             return theme.symbols.info;
     }
 }
-export function ToastStack({ toasts, theme, mode = 'inline', }) {
-    if (mode === 'fullscreen') {
-        const latest = toasts[toasts.length - 1];
-        const extra = Math.max(0, toasts.length - 1);
-        return (_jsx(Box, { flexShrink: 0, children: latest ? (_jsxs(Text, { wrap: "truncate", color: toastColor(latest.level, theme), children: [' ', toastGlyph(latest.level, theme), " ", latest.text, extra > 0 ? `  +${extra}` : ''] })) : (_jsx(Text, { children: " " })) }));
-    }
-    const shown = toasts.slice(-MAX_VISIBLE);
-    if (shown.length === 0)
-        return null;
-    return (_jsx(Box, { flexDirection: "column", marginTop: 1, children: shown.map((t) => (_jsxs(Text, { color: toastColor(t.level, theme), children: [toastGlyph(t.level, theme), " ", t.text] }, t.id))) }));
+export function ToastStack({ toasts, theme, }) {
+    const latest = toasts[toasts.length - 1];
+    const extra = Math.max(0, toasts.length - 1);
+    return (_jsx(Box, { flexShrink: 0, children: latest ? (_jsxs(Text, { wrap: "truncate", color: toastColor(latest.level, theme), children: [' ', toastGlyph(latest.level, theme), " ", latest.text, extra > 0 ? `  +${extra}` : ''] })) : (_jsx(Text, { children: " " })) }));
 }

package/dist/ui/Transcript.d.ts

@@ -1,65 +1,23 @@
-/**
- * Transcript (spec §3.8). Splits the entry list into a settled prefix rendered
- * once into Ink's `<Static>` (native terminal scrollback, never re-rendered)
- * and a live tail rendered normally. This kills per-token full re-renders and
- * flicker on long/fast sessions.
- *
- * `computeSettledCount` is pure and exported for `transcript-static.test.ts`.
- * The settled boundary is held MONOTONIC at render time: a previously-settled
- * entry never leaves `<Static>` (which cannot un-print it) even if it later
- * becomes expanded, so the live tail can never duplicate a scrolled-off entry.
- *
- * `EntryView` is shared by both render paths ON PURPOSE (§4.3 / §12). Forking it
- * to freeze inline's v0.2.0 output would mean writing every future entry-layer
- * change twice and watching the two drift; inline is a degradation path, not a
- * parallel product. What inline still guarantees is its GEOMETRY contract — no
- * fixed frame, `<Static>` keeps the settled history, no private ANSI — not its
- * pixel-for-pixel appearance.
- *
- * Two things changed with tui-render-performance:
- *   - `EntryView` is `React.memo`'d with an explicit comparator (L2 / R3), which
- *     is only worth anything because `mapEntry` already preserves object
- *     identity for untouched entries;
- *   - `TranscriptList` (the FULL-SCREEN body) mounts only the entries inside the
- *     viewport and replaces the rest with two spacer boxes (L3 / R1), and the
- *     inline `Transcript` clamps its live region so `ink.js:121` is unreachable
- *     (L5 / R6).
- */
+/** Virtualized full-screen transcript and entry cards. */
+/** Virtualized full-screen transcript and shared entry cards. */
 import React from 'react';
 import { type Theme } from './theme.js';
 import type { TermCapabilities } from './capabilities.js';
 import { type DensityMode } from './density.js';
 import type { Entry } from '../agent/reducer.js';
-import type { RenderMode } from './layout/frame.js';
 import { type TailSink } from './layout/follow-state.js';
 import type { HeightStore } from './use-height-store.js';
-/**
- * Largest prefix length P such that `entries[0..P)` are all terminal, none is
- * within the last `LIVE_TAIL` entries, and none is currently expanded. Pure and
- * non-decreasing as entries terminalize (expanding a card can lower it — the
- * component clamps with a monotonic high-water mark to avoid Static duplication).
- */
-export declare function computeSettledCount(entries: Entry[], expandedToolIds: Record<string, true>): number;
 interface TranscriptProps {
     entries: Entry[];
     expandedToolIds: Record<string, true>;
     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
+     * The entry map decides per entry whether to pass it on, and it
      * 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.
@@ -76,15 +34,12 @@ 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, mode, theme, caps, liveClampRows, nowSec, }: EntryViewProps): React.ReactElement | null;
+declare function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion, density, theme, caps, nowSec, }: EntryViewProps): React.ReactElement | null;
 /**
  * THE memo boundary that makes a long transcript cheap (L2 / R3).
  *
@@ -100,27 +55,7 @@ declare function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reduced
  * test rather than a silent regression.
  */
 export declare const EntryView: React.MemoExoticComponent<typeof EntryViewImpl>;
-/**
- * Full-screen transcript body — the same entry renderers with NO `<Static>`.
- *
- * `<Static>` prints above the live frame; once the frame is `rows - 1` tall
- * there is exactly one visible line up there, so the mechanism stops being a
- * history view and starts being a leak. Full-screen therefore owns its history
- * inside `ScrollViewport` instead.
- *
- * `computeSettledCount` is deliberately NOT called here: its only job is to keep
- * an entry that already reached `<Static>` from flowing back into the live
- * region, and with no Static there is nothing to protect. The settled high-water
- * mark feeds nothing else — `/save` serializes `entries` in full — so leaving it
- * un-advanced has no side effect.
- *
- * VIRTUALISED (L3 / R1). `windowSize` is now the SCROLL HORIZON — how far back
- * the user can scroll — and no longer the rendering budget, because entries
- * outside the viewport are not mounted at all. What bounds the frame is
- * `selectWindow`, and the two spacers are what keep the scroll maths honest
- * while they are absent.
- */
-export declare function TranscriptList({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, mode, nowSec, theme, caps, windowSize, cols, heights, mountedSink, tailSink, }: TranscriptProps & {
+export declare function TranscriptList({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, nowSec, theme, caps, windowSize, cols, heights, mountedSink, tailSink, }: TranscriptProps & {
     windowSize: number;
     /** The viewport's own width — narrower than the terminal when the rail is up. */
     cols: number;
@@ -153,5 +88,4 @@ export declare function TranscriptList({ entries, expandedToolIds, thinkingVisib
      */
     tailSink?: TailSink;
 }): React.ReactElement;
-export declare function Transcript({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, mode, nowSec, theme, caps, }: TranscriptProps): React.ReactElement;
 export {};