@aragon-agent/cli 0.4.3

package/dist/ui/PromptInput.js

@@ -0,0 +1,383 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * PromptInput (spec §3.6 / §3.10) — a controlled multiline input on Ink's
+ * `useInput` with: full line editing (Home/End, word jump/delete, kill-line via
+ * `input/keymap`), multi-line vertical cursor navigation, prompt-history recall
+ * at the edges, a slash-command palette, and `@file` path completion.
+ *
+ * The buffer/cursor transforms (`applyEdit`, `moveVertical`) and the suggestion
+ * computations (`slashSuggestions`, `fileTokenAt`) are pure module functions,
+ * exported for `input.test.ts`, so the component itself stays thin.
+ */
+import { useEffect, useRef, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { glob as tinyGlob } from 'tinyglobby';
+import { pickGlyphs } from './glyphs.js';
+import { recognize } from '../input/keymap.js';
+import { AutocompletePopup } from './AutocompletePopup.js';
+// ---------------------------------------------------------------------------
+// Pure editing helpers (unit-tested in input.test.ts)
+// ---------------------------------------------------------------------------
+const isSpace = (ch) => !!ch && /\s/.test(ch);
+function lineStart(buffer, cursor) {
+    const nl = buffer.lastIndexOf('\n', cursor - 1);
+    return nl === -1 ? 0 : nl + 1;
+}
+function lineEnd(buffer, cursor) {
+    const nl = buffer.indexOf('\n', cursor);
+    return nl === -1 ? buffer.length : nl;
+}
+function prevWord(buffer, cursor) {
+    let i = cursor;
+    while (i > 0 && isSpace(buffer[i - 1]))
+        i -= 1;
+    while (i > 0 && !isSpace(buffer[i - 1]))
+        i -= 1;
+    return i;
+}
+function nextWord(buffer, cursor) {
+    let i = cursor;
+    while (i < buffer.length && isSpace(buffer[i]))
+        i += 1;
+    while (i < buffer.length && !isSpace(buffer[i]))
+        i += 1;
+    return i;
+}
+/** Apply an edit intent as a pure buffer/cursor transform. */
+export function applyEdit(buffer, cursor, intent) {
+    switch (intent) {
+        case 'home':
+            return { buffer, cursor: lineStart(buffer, cursor) };
+        case 'end':
+            return { buffer, cursor: lineEnd(buffer, cursor) };
+        case 'wordLeft':
+            return { buffer, cursor: prevWord(buffer, cursor) };
+        case 'wordRight':
+            return { buffer, cursor: nextWord(buffer, cursor) };
+        case 'deleteWordBack': {
+            const start = prevWord(buffer, cursor);
+            return { buffer: buffer.slice(0, start) + buffer.slice(cursor), cursor: start };
+        }
+        case 'killToStart': {
+            const start = lineStart(buffer, cursor);
+            return { buffer: buffer.slice(0, start) + buffer.slice(cursor), cursor: start };
+        }
+        case 'killToEnd': {
+            const end = lineEnd(buffer, cursor);
+            return { buffer: buffer.slice(0, cursor) + buffer.slice(end), cursor };
+        }
+    }
+}
+/**
+ * Move the cursor up/down one line preserving the column. Returns `null` at the
+ * top/bottom edge (or for a single-line buffer) so the caller can fall back to
+ * prompt-history recall.
+ */
+export function moveVertical(buffer, cursor, dir) {
+    const lines = buffer.split('\n');
+    if (lines.length < 2)
+        return null;
+    const before = buffer.slice(0, cursor);
+    const idx = before.split('\n').length - 1;
+    const col = before.length - (before.lastIndexOf('\n') + 1);
+    const target = dir === 'up' ? idx - 1 : idx + 1;
+    if (target < 0 || target >= lines.length)
+        return null;
+    let start = 0;
+    for (let i = 0; i < target; i += 1)
+        start += lines[i].length + 1;
+    return { cursor: start + Math.min(col, lines[target].length) };
+}
+/**
+ * Slash-command suggestions when the buffer is a bare `/word` (no space yet).
+ *
+ * The character class covers `-` and `:` as well as `\w` (D16). Skill names are
+ * kebab-case and the namespaced fallback is `/skill:<name>`; with the original
+ * `^\/(\w*)$` a user typing `/my-sk` got NO popup at all — not an error message,
+ * just silence, which reads as "that command does not exist".
+ */
+export function slashSuggestions(buffer, commands) {
+    const m = /^\/([\w:-]*)$/.exec(buffer);
+    if (!m)
+        return null;
+    const q = m[1].toLowerCase();
+    return commands
+        .filter((c) => c.name.toLowerCase().startsWith(q))
+        .map((c) => ({ label: `/${c.name}`, hint: c.description }));
+}
+/** The `@file` token under the cursor (`@` + non-space run), if any. */
+export function fileTokenAt(buffer, cursor) {
+    let start = cursor;
+    while (start > 0 && !isSpace(buffer[start - 1]))
+        start -= 1;
+    if (buffer[start] !== '@')
+        return null;
+    let end = cursor;
+    while (end < buffer.length && !isSpace(buffer[end]))
+        end += 1;
+    return { start, end, query: buffer.slice(start + 1, end) };
+}
+/** A leading C0 control byte or ESC sequence should never be inserted raw. */
+function isControlSeq(input) {
+    if (input.length === 0)
+        return true;
+    const code = input.charCodeAt(0);
+    return code < 0x20 || code === 0x7f;
+}
+// ---------------------------------------------------------------------------
+// Component
+// ---------------------------------------------------------------------------
+export function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, onSubmit, onHelp, bordered, onDraftChange, }) {
+    const [buffer, setBuffer] = useState('');
+    const [cursor, setCursor] = useState(0);
+    const [historyIndex, setHistoryIndex] = useState(null);
+    const [dismissed, setDismissed] = useState(false);
+    const [sel, setSel] = useState(0);
+    const [fileMatches, setFileMatches] = useState([]);
+    // --- Derived suggestion state (shared by render + input handler). --------
+    const slashSug = dismissed ? null : slashSuggestions(buffer, commands);
+    const fileTok = fileTokenAt(buffer, cursor);
+    const fileQuery = fileTok ? fileTok.query : null;
+    const fileActive = !dismissed && !!fileTok && fileTok.query.length >= 1 && fileMatches.length > 0;
+    const popupKind = slashSug && slashSug.length > 0 ? 'slash' : fileActive ? 'file' : null;
+    const popupItems = popupKind === 'slash'
+        ? slashSug
+        : popupKind === 'file'
+            ? fileMatches.map((p) => ({ label: p }))
+            : [];
+    const clampedSel = popupItems.length > 0 ? Math.min(sel, popupItems.length - 1) : 0;
+    // --- Debounced `@file` scan. ---------------------------------------------
+    useEffect(() => {
+        if (fileQuery === null || fileQuery.length < 1) {
+            setFileMatches([]);
+            return;
+        }
+        let cancelled = false;
+        const id = setTimeout(() => {
+            tinyGlob('**/*', {
+                cwd,
+                dot: false,
+                onlyFiles: true,
+                ignore: ['**/node_modules/**', '**/.git/**'],
+            })
+                .then((matches) => {
+                if (cancelled)
+                    return;
+                const q = fileQuery.toLowerCase();
+                setFileMatches(matches.filter((m) => m.toLowerCase().includes(q)).slice(0, 20));
+            })
+                .catch(() => {
+                if (!cancelled)
+                    setFileMatches([]);
+            });
+        }, 120);
+        return () => {
+            cancelled = true;
+            clearTimeout(id);
+        };
+    }, [fileQuery, cwd]);
+    // --- Draft presence, reported only on the transition. ---------------------
+    // Notifying on every keystroke would re-render the whole App tree per key.
+    const hasDraft = buffer.length > 0;
+    const lastReportedDraft = useRef(null);
+    useEffect(() => {
+        if (!onDraftChange)
+            return;
+        if (lastReportedDraft.current === hasDraft)
+            return;
+        lastReportedDraft.current = hasDraft;
+        onDraftChange(hasDraft);
+    }, [hasDraft, onDraftChange]);
+    // --- Mutators. -----------------------------------------------------------
+    const resetDraftFlags = () => {
+        setHistoryIndex(null);
+        setDismissed(false);
+        setSel(0);
+    };
+    const insert = (text) => {
+        setBuffer(buffer.slice(0, cursor) + text + buffer.slice(cursor));
+        setCursor(cursor + text.length);
+        resetDraftFlags();
+    };
+    const submit = (text) => {
+        onSubmit(text);
+        setBuffer('');
+        setCursor(0);
+        resetDraftFlags();
+    };
+    const recallUp = () => {
+        if (history.length === 0)
+            return;
+        const idx = historyIndex === null ? history.length - 1 : Math.max(0, historyIndex - 1);
+        const value = history[idx] ?? '';
+        setHistoryIndex(idx);
+        setBuffer(value);
+        setCursor(value.length);
+    };
+    const recallDown = () => {
+        if (historyIndex === null)
+            return;
+        const idx = historyIndex + 1;
+        if (idx >= history.length) {
+            setHistoryIndex(null);
+            setBuffer('');
+            setCursor(0);
+        }
+        else {
+            const value = history[idx] ?? '';
+            setHistoryIndex(idx);
+            setBuffer(value);
+            setCursor(value.length);
+        }
+    };
+    const completeSelection = () => {
+        const chosen = popupItems[clampedSel];
+        if (!chosen)
+            return;
+        if (popupKind === 'slash') {
+            const next = `${chosen.label} `;
+            setBuffer(next);
+            setCursor(next.length);
+        }
+        else if (popupKind === 'file' && fileTok) {
+            const next = buffer.slice(0, fileTok.start) + chosen.label + buffer.slice(fileTok.end);
+            setBuffer(next);
+            setCursor(fileTok.start + chosen.label.length);
+        }
+        resetDraftFlags();
+    };
+    const verticalOrHistory = (dir) => {
+        const moved = moveVertical(buffer, cursor, dir);
+        if (moved) {
+            setCursor(moved.cursor);
+            return;
+        }
+        // At an edge: recall history only from an empty buffer or while already
+        // stepping through it — never clobber an in-progress draft (see spec note).
+        if (buffer.length === 0 || historyIndex !== null) {
+            if (dir === 'up')
+                recallUp();
+            else
+                recallDown();
+        }
+    };
+    // --- Input handling. -----------------------------------------------------
+    useInput((input, key) => {
+        // Popup navigation owns Up/Down/Tab/→/Enter/Esc while it is open.
+        if (popupItems.length > 0) {
+            if (key.upArrow) {
+                setSel(Math.max(0, clampedSel - 1));
+                return;
+            }
+            if (key.downArrow) {
+                setSel(Math.min(popupItems.length - 1, clampedSel + 1));
+                return;
+            }
+            if (key.tab || (key.rightArrow && cursor >= buffer.length)) {
+                completeSelection();
+                return;
+            }
+            if (key.return && popupKind === 'slash') {
+                const label = popupItems[clampedSel]?.label;
+                if (label)
+                    submit(label);
+                return;
+            }
+            if (key.escape) {
+                setDismissed(true);
+                return;
+            }
+            // Any other key falls through so typing keeps filtering the popup.
+        }
+        if (key.escape)
+            return; // App owns abort / close-overlay.
+        // Line-editing intents (Home/End/word/kill) recognized from raw keys.
+        const intent = recognize(input, key);
+        if (intent) {
+            const next = applyEdit(buffer, cursor, intent);
+            setBuffer(next.buffer);
+            setCursor(next.cursor);
+            resetDraftFlags();
+            return;
+        }
+        if (key.ctrl)
+            return; // App owns Ctrl+C / L / T / O.
+        if (key.return) {
+            if (key.meta || key.shift) {
+                insert('\n');
+                return;
+            }
+            if (buffer.trim().length === 0)
+                return;
+            submit(buffer);
+            return;
+        }
+        if (key.backspace || key.delete) {
+            if (cursor > 0) {
+                setBuffer(buffer.slice(0, cursor - 1) + buffer.slice(cursor));
+                setCursor(cursor - 1);
+                resetDraftFlags();
+            }
+            return;
+        }
+        if (key.leftArrow) {
+            setCursor(Math.max(0, cursor - 1));
+            return;
+        }
+        if (key.rightArrow) {
+            setCursor(Math.min(buffer.length, cursor + 1));
+            return;
+        }
+        // `!key.shift` is load-bearing: Shift+↑/↓ is the viewport's line-scroll
+        // binding (§4.10). Without the guard the history recall below swallows it
+        // and scrolling appears to be broken for no visible reason.
+        if (key.upArrow && !key.shift) {
+            verticalOrHistory('up');
+            return;
+        }
+        if (key.downArrow && !key.shift) {
+            verticalOrHistory('down');
+            return;
+        }
+        // `?` on an empty idle input opens the help overlay.
+        if (input === '?' && buffer.length === 0 && !running && onHelp) {
+            onHelp();
+            return;
+        }
+        // Printable input — drop any unrecognized control/escape byte.
+        if (input && !key.tab && !isControlSeq(input))
+            insert(input);
+    }, { isActive });
+    const glyphs = pickGlyphs(caps);
+    const marker = running ? glyphs.steer : glyphs.caret;
+    const markerColor = running ? theme.toolRunning : theme.primary;
+    const placeholder = running
+        ? `Type to steer the run, Esc to abort${glyphs.ellipsis}`
+        : `Send a message (/ for commands, @ for files)${glyphs.ellipsis}`;
+    const lines = renderWithCursor(buffer, cursor, isActive);
+    const inputRow = (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: markerColor, bold: true, children: [marker, ' '] }), _jsx(Box, { flexDirection: "column", children: buffer.length === 0 ? (_jsx(Text, { color: theme.muted, children: placeholder })) : (lines.map((line, i) => _jsx(Text, { children: line }, i))) })] }));
+    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [popupItems.length > 0 && (_jsx(AutocompletePopup, { items: popupItems, selected: clampedSel, theme: theme, caps: caps, maxRows: popupMaxRows })), bordered ? (_jsx(Box, { flexDirection: "column", flexShrink: 0, borderStyle: glyphs.boxStyle, borderColor: bordered.color, paddingX: 1, children: inputRow })) : (inputRow)] }));
+}
+/** Split the buffer into lines and render an inverse cursor at `cursor`. */
+function renderWithCursor(buffer, cursor, active) {
+    if (!active)
+        return buffer.split('\n');
+    const before = buffer.slice(0, cursor);
+    const at = buffer[cursor] ?? ' ';
+    const after = buffer.slice(cursor + 1);
+    const beforeLines = before.split('\n');
+    const afterLines = after.split('\n');
+    const nodes = [];
+    const lastBeforeIdx = beforeLines.length - 1;
+    for (let i = 0; i < lastBeforeIdx; i += 1) {
+        nodes.push(_jsx(Text, { children: beforeLines[i] }, `b${i}`));
+    }
+    const cursorChar = at === '\n' ? ' ' : at;
+    const firstAfter = afterLines[0] ?? '';
+    nodes.push(_jsxs(Text, { children: [beforeLines[lastBeforeIdx], _jsx(Text, { inverse: true, children: cursorChar }), at === '\n' ? '' : firstAfter] }, "cursor-line"));
+    const remainingAfter = at === '\n' ? afterLines : afterLines.slice(1);
+    for (let i = 0; i < remainingAfter.length; i += 1) {
+        nodes.push(_jsx(Text, { children: remainingAfter[i] }, `a${i}`));
+    }
+    return nodes;
+}

package/dist/ui/SessionOpener.d.ts

@@ -0,0 +1,30 @@
+/**
+ * SessionOpener (spec §4.2 / §4.8) — the opening wordmark plus the getting
+ * started card, rendered as the FIRST BLOCK OF VIEWPORT CONTENT rather than as
+ * part of the fixed header.
+ *
+ * That relocation is the whole point. As header chrome the wordmark occupied
+ * permanent vertical budget for what is a one-off greeting, so it had to be
+ * yanked away the instant the first message arrived — a 7-row jump and a full
+ * reflow. As content it simply scrolls out of view like anything else, which is
+ * both calmer and what the reference implementation does.
+ *
+ * Absorbs the former `Welcome.tsx`, whose 8-row round-bordered card spent 4 rows
+ * on a border and two blank lines — over half of a short terminal's empty-session
+ * viewport carrying no information.
+ */
+import React from 'react';
+import type { Theme } from './theme.js';
+import type { TermCapabilities } from './capabilities.js';
+import { type OpenerVariant } from './Logo.js';
+export interface SessionOpenerProps {
+    variant: OpenerVariant;
+    version: string;
+    cwd: string;
+    hasKey: boolean;
+    /** Drives the last-ditch squeeze to a single line on very short terminals. */
+    viewportRows: number;
+    theme: Theme;
+    caps: TermCapabilities;
+}
+export declare function SessionOpener({ variant, version, cwd, hasKey, viewportRows, theme, caps, }: SessionOpenerProps): React.ReactElement;

package/dist/ui/SessionOpener.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { pickGlyphs } from './glyphs.js';
+import { Logo } from './Logo.js';
+const EXAMPLE = 'Explain what this repository does';
+/** Below this the opener keeps only the safety warning. */
+const TERSE_VIEWPORT_ROWS = 10;
+export function SessionOpener({ variant, version, cwd, hasKey, viewportRows, theme, caps, }) {
+    const glyphs = pickGlyphs(caps);
+    const terse = viewportRows < TERSE_VIEWPORT_ROWS;
+    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [!terse && variant !== 'none' && _jsx(Logo, { variant: variant, theme: theme, caps: caps }), !terse && (_jsx(Text, { wrap: "truncate", children: _jsxs(Text, { color: theme.muted, children: ["v", version, '  ', cwd] }) })), _jsxs(Text, { wrap: "truncate", color: theme.noticeWarn, children: [glyphs.warn, " Full permission, no sandbox: bash runs and files are written directly."] }), !hasKey && (_jsxs(Text, { wrap: "truncate", color: theme.noticeWarn, children: [glyphs.arrowRight, " Run /settings (or set ANTHROPIC_API_KEY) to get started."] })), !terse && hasKey && (_jsxs(Text, { wrap: "truncate", children: [_jsxs(Text, { color: theme.accent, children: [glyphs.bullet, " "] }), _jsx(Text, { color: theme.hintFg ?? theme.muted, children: EXAMPLE })] }))] }));
+}

package/dist/ui/StatusBar.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Status bar (spec §4.8). Width-aware, borderless, EXACTLY one row: a left
+ * cluster (run status, model, thinking level) and a right cluster (context
+ * gauge, tokens, cost, tokens/sec + elapsed while running, off-bottom `↑N`).
+ * Clusters drop out gracefully on narrow terminals.
+ *
+ * Dropping the round border here buys back 3 rows of a 24-row terminal — an
+ * eighth of the screen was being spent framing a single line of text.
+ */
+import React from 'react';
+import type { Theme } from './theme.js';
+import type { TermCapabilities } from './capabilities.js';
+import type { UsageTotal } from '../agent/reducer.js';
+interface StatusBarProps {
+    model: string;
+    provider: string;
+    usageTotal: UsageTotal;
+    contextTokens: number;
+    contextWindow: number;
+    contextWindowKnown: boolean;
+    status: 'idle' | 'running';
+    elapsedMs: number;
+    thinkingLevel: string;
+    tokPerSec: number;
+    theme: Theme;
+    caps: TermCapabilities;
+    /**
+     * Lines scrolled off the bottom; > 0 renders `↑N`. Inline mode has no
+     * self-drawn viewport, so it simply never sends anything but 0 — the bar
+     * needs no render-mode branch of its own.
+     */
+    scrolledLines?: number;
+    /**
+     * Ctrl+L redraw carrier — invariant I-5 (spec §4.13). See `redrawChar`.
+     */
+    redrawNonce?: number;
+}
+export declare function StatusBar(props: StatusBarProps): React.ReactElement;
+export {};

package/dist/ui/StatusBar.js

@@ -0,0 +1,43 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text, useStdout } from 'ink';
+import { pickGlyphs } from './glyphs.js';
+import { formatCost, formatTokens, formatDuration } from '../agent/usage.js';
+import { buildGauge } from './gauge.js';
+/**
+ * I-5 — DO NOT "CLEAN THIS UP". Ink short-circuits identical output at TWO
+ * gates (`ink.js:132` and `log-update.js:13`), so a fixed frame whose React
+ * output has not changed is never repainted. `Ctrl+L` therefore cannot work by
+ * writing an escape sequence; it works by making the rendered STRING differ.
+ * This alternates the status bar's left gutter between U+0020 and U+00A0: both
+ * render one invisible column, so there is zero visual or layout difference,
+ * but the bytes differ and both gates open.
+ *
+ * It must sit at the START of the line: Ink `trimEnd()`s every row (output.js),
+ * and JS `trimEnd` strips U+00A0 too — a trailing carrier would be deleted and
+ * Ctrl+L would degrade to a silent no-op.
+ */
+/** Built by code point so no formatter can normalize it back to a plain space. */
+const NBSP = String.fromCharCode(0x00a0);
+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, } = props;
+    const { stdout } = useStdout();
+    const cols = stdout?.columns ?? 80;
+    const running = status === 'running';
+    const glyphs = pickGlyphs(caps);
+    const pct = contextWindow > 0 ? Math.min(100, Math.round((contextTokens / contextWindow) * 100)) : 0;
+    const gauge = buildGauge(pct, cols < 72 ? 8 : 12, theme, caps);
+    const pctLabel = `${contextWindowKnown ? '' : '~'}${gauge.pct}%`;
+    const tokens = `${formatTokens(usageTotal.inputTokens)}${glyphs.arrowUp} ${formatTokens(usageTotal.outputTokens)}${glyphs.arrowDown}`;
+    const statusGlyph = running ? theme.symbols.toolRunning : theme.symbols.toolPending;
+    return (
+    // `flexShrink={0}` on the left cluster is not cosmetic. When the two clusters
+    // over-subscribe the row, yoga shrinks the flexible children and Ink's text
+    // measurement drops a character from EACH of them — the bar renders "idl"
+    // and "? hel" rather than truncating cleanly at one end. Pinning the left
+    // cluster keeps the run status and model intact and makes the degradation
+    // 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'] }), cols >= 60 && (_jsxs(Text, { color: theme.muted, children: ['  ', provider, ":", model] })), thinkingLevel !== 'off' && cols >= 72 && (_jsxs(Text, { color: theme.accent, children: ["  think:", thinkingLevel] }))] }), _jsxs(Box, { flexDirection: "row", children: [scrolledLines > 0 && (_jsxs(Text, { color: theme.noticeWarn, children: [glyphs.arrowUp, scrolledLines, '  '] })), cols >= 60 && (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: "[" }), _jsx(Text, { color: gauge.fillColor, children: gauge.filled }), _jsx(Text, { color: gauge.trackColor, children: gauge.empty }), _jsx(Text, { color: theme.muted, children: "] " })] })), _jsx(Text, { color: theme.muted, children: pctLabel }), cols >= 72 && _jsxs(Text, { color: theme.muted, children: ["  ", tokens] }), _jsxs(Text, { color: theme.muted, children: ["  ", formatCost(usageTotal.costUsd)] }), running && (_jsxs(Text, { color: theme.muted, children: [tokPerSec > 0 && cols >= 72 ? `  ${tokPerSec} tok/s` : '', "  ", formatDuration(elapsedMs)] }))] })] }));
+}

package/dist/ui/ToastStack.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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.
+ */
+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, }: {
+    toasts: Toast[];
+    theme: Theme;
+    mode?: RenderMode;
+}): React.ReactElement | null;

package/dist/ui/ToastStack.js

@@ -0,0 +1,38 @@
+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':
+            return theme.toast.success;
+        case 'warn':
+            return theme.toast.warn;
+        case 'error':
+            return theme.toast.error;
+        default:
+            return theme.toast.info;
+    }
+}
+function toastGlyph(level, theme) {
+    switch (level) {
+        case 'success':
+            return theme.symbols.toolDone;
+        case 'warn':
+            return theme.symbols.warn;
+        case 'error':
+            return theme.symbols.error;
+        default:
+            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))) }));
+}

package/dist/ui/Transcript.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 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.
+ */
+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';
+/**
+ * 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;
+    theme: Theme;
+    caps: TermCapabilities;
+}
+/**
+ * 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.
+ *
+ * Rendering budget (I-3): yoga lays out every child even when `overflow: hidden`
+ * clips it, so cost grows linearly with the entry count. Only the last
+ * `windowSize` entries are rendered; the reducer and `/save` keep everything.
+ */
+export declare function TranscriptList({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, theme, caps, windowSize, }: TranscriptProps & {
+    windowSize: number;
+}): React.ReactElement;
+export declare function Transcript({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, theme, caps, }: TranscriptProps): React.ReactElement;
+export {};