@aragon-agent/cli 0.4.3

package/dist/ui/Transcript.js

@@ -0,0 +1,128 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * 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 { useRef } from 'react';
+import { Box, Static, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { pickGlyphs } from './glyphs.js';
+import { separationRows } from './density.js';
+import { EntryFrame } from './entries/EntryFrame.js';
+import { UserEntry } from './entries/UserEntry.js';
+import { AssistantEntry } from './entries/AssistantEntry.js';
+import { ToolCard, statusColor, toolEntryGlyph } from './entries/ToolCard.js';
+/** Keep the last K entries in the live region so a mutating tail stays hot. */
+const LIVE_TAIL = 1;
+/**
+ * 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 function computeSettledCount(entries, expandedToolIds) {
+    const limit = entries.length - LIVE_TAIL;
+    let count = 0;
+    for (let i = 0; i < entries.length; i += 1) {
+        if (i >= limit)
+            break;
+        const e = entries[i];
+        if (expandedToolIds[e.id])
+            break;
+        if (e.kind === 'assistant' && e.streaming)
+            break;
+        if (e.kind === 'tool' && e.status !== 'done' && e.status !== 'error')
+            break;
+        count = i + 1;
+    }
+    return count;
+}
+function noticeColor(level, theme) {
+    if (level === 'error')
+        return theme.noticeError;
+    if (level === 'warn')
+        return theme.noticeWarn;
+    return theme.noticeInfo;
+}
+function noticeSymbol(level, theme) {
+    if (level === 'error')
+        return theme.symbols.error;
+    if (level === 'warn')
+        return theme.symbols.warn;
+    return theme.symbols.info;
+}
+function EntryView({ entry, prev, expanded, thinkingVisible, reducedMotion, density, theme, caps, }) {
+    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 }));
+    switch (entry.kind) {
+        case 'user':
+            return frame(glyphs.user, theme.user, _jsx(UserEntry, { text: entry.text, theme: theme }));
+        case 'assistant': {
+            // While text streams, the spinner IS the role marker. Braille dots are
+            // 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, 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, 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:
+            return null;
+    }
+}
+/**
+ * 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 function TranscriptList({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, theme, caps, windowSize, }) {
+    const size = Math.max(1, Math.floor(windowSize));
+    const visible = entries.length > size ? entries.slice(-size) : entries;
+    const collapsed = entries.length - visible.length;
+    const glyphs = pickGlyphs(caps);
+    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)"] })), visible.map((entry, i) => (_jsx(EntryView, { entry: entry, prev: i > 0 ? visible[i - 1] : undefined, expanded: !!expandedToolIds[entry.id], thinkingVisible: thinkingVisible, reducedMotion: reducedMotion, density: density, theme: theme, caps: caps }, entry.id)))] }));
+}
+export function Transcript({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, theme, caps, }) {
+    const highWater = useRef(0);
+    const prevLen = useRef(0);
+    const raw = computeSettledCount(entries, expandedToolIds);
+    // The transcript shrank (clear / reset / restore) — drop the high-water mark.
+    if (entries.length < prevLen.current)
+        highWater.current = 0;
+    prevLen.current = entries.length;
+    const settled = Math.min(entries.length, Math.max(highWater.current, raw));
+    highWater.current = settled;
+    const settledEntries = entries.slice(0, settled);
+    const liveEntries = entries.slice(settled);
+    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 }, entry.id))) })] }));
+}

package/dist/ui/capabilities.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Terminal capability detection (spec §3.2).
+ *
+ * A *pure* `detectCapabilities(env, stdout)` that reports how much color and
+ * which glyph set the current terminal can render, so the theme engine can
+ * degrade truecolor → 256 → 16 → monochrome and swap Unicode box/round glyphs
+ * for ASCII on legacy terminals (e.g. `cmd.exe`). Keeping it env-in / value-out
+ * makes it unit-testable without a real TTY.
+ */
+export interface TermCapabilities {
+    /** 0 none · 1 basic-16 · 2 ansi-256 · 3 truecolor. */
+    colorLevel: 0 | 1 | 2 | 3;
+    /** May we use box/round glyphs, spinners, and emoji-ish symbols? */
+    unicode: boolean;
+}
+type EnvLike = Record<string, string | undefined>;
+interface StdoutLike {
+    isTTY?: boolean;
+}
+/**
+ * Detect the terminal's color depth and Unicode support. `stdout` is accepted
+ * for future TTY-aware refinements and kept in the signature for callers.
+ */
+export declare function detectCapabilities(env: EnvLike, _stdout?: StdoutLike): TermCapabilities;
+export {};

package/dist/ui/capabilities.js

@@ -0,0 +1,59 @@
+/**
+ * Terminal capability detection (spec §3.2).
+ *
+ * A *pure* `detectCapabilities(env, stdout)` that reports how much color and
+ * which glyph set the current terminal can render, so the theme engine can
+ * degrade truecolor → 256 → 16 → monochrome and swap Unicode box/round glyphs
+ * for ASCII on legacy terminals (e.g. `cmd.exe`). Keeping it env-in / value-out
+ * makes it unit-testable without a real TTY.
+ */
+import chalk from 'chalk';
+/** Resolve the effective color depth from environment signals + chalk. */
+function detectColorLevel(env) {
+    // Explicit opt-outs win (https://no-color.org — any value, even empty).
+    if (env.NO_COLOR !== undefined)
+        return 0;
+    if (env.TERM === 'dumb')
+        return 0;
+    // A truecolor-capable terminal advertises itself.
+    const colorterm = env.COLORTERM?.toLowerCase();
+    if (colorterm === 'truecolor' || colorterm === '24bit')
+        return 3;
+    // FORCE_COLOR is an explicit override of the auto-detected depth.
+    const force = env.FORCE_COLOR;
+    if (force !== undefined) {
+        if (force === '0' || force === 'false')
+            return 0;
+        if (force === '2')
+            return 2;
+        if (force === '3')
+            return 3;
+        return 1; // '1' | 'true' | '' → at least basic color
+    }
+    // Fall back to chalk's own platform detection.
+    const level = chalk.level;
+    return level >= 0 && level <= 3 ? level : 0;
+}
+/** Decide whether Unicode box/round glyphs are safe to emit. */
+function detectUnicode(env) {
+    const locale = [env.LC_ALL, env.LC_CTYPE, env.LANG].filter(Boolean).join(' ').toUpperCase();
+    if (locale.includes('UTF'))
+        return true;
+    if (env.WT_SESSION)
+        return true; // Windows Terminal
+    const program = env.TERM_PROGRAM;
+    if (program === 'vscode' || program === 'iTerm.app' || program === 'Apple_Terminal')
+        return true;
+    // Legacy cmd.exe (no TERM, no WT_SESSION) and unknown terminals fall back to ASCII.
+    return false;
+}
+/**
+ * Detect the terminal's color depth and Unicode support. `stdout` is accepted
+ * for future TTY-aware refinements and kept in the signature for callers.
+ */
+export function detectCapabilities(env, _stdout) {
+    return {
+        colorLevel: detectColorLevel(env),
+        unicode: detectUnicode(env),
+    };
+}

package/dist/ui/console-bridge.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Console bridge — invariant I-4 (spec §4.9).
+ *
+ * `patchConsole: true` makes Ink do `log.clear() → stdout.write(data) →
+ * log(lastOutput)`. Under a fixed frame that write pushes the frame down a row
+ * and permanently corrupts the line accounting described in §4.2: from then on
+ * `eraseLines(previousLineCount)` is off by one and the frame slowly eats the
+ * content above it.
+ *
+ * So full-screen mode runs with `patchConsole: false` and routes `console.*`
+ * into the transcript as notice entries, where the output is actually READABLE
+ * instead of merely being somewhere on screen. Inline mode keeps Ink's patching.
+ */
+import type { NoticeLevel } from '../agent/reducer.js';
+/**
+ * Hijack `console.*` for the lifetime of the returned restore function.
+ * Returns a restore callback; calling it twice is harmless.
+ */
+export declare function installConsoleBridge(sink: (level: NoticeLevel, text: string) => void): () => void;

package/dist/ui/console-bridge.js

@@ -0,0 +1,52 @@
+/**
+ * Console bridge — invariant I-4 (spec §4.9).
+ *
+ * `patchConsole: true` makes Ink do `log.clear() → stdout.write(data) →
+ * log(lastOutput)`. Under a fixed frame that write pushes the frame down a row
+ * and permanently corrupts the line accounting described in §4.2: from then on
+ * `eraseLines(previousLineCount)` is off by one and the frame slowly eats the
+ * content above it.
+ *
+ * So full-screen mode runs with `patchConsole: false` and routes `console.*`
+ * into the transcript as notice entries, where the output is actually READABLE
+ * instead of merely being somewhere on screen. Inline mode keeps Ink's patching.
+ */
+import { format } from 'node:util';
+const LEVEL_BY_METHOD = {
+    log: 'info',
+    info: 'info',
+    warn: 'warn',
+    error: 'error',
+    debug: 'info',
+};
+/**
+ * Hijack `console.*` for the lifetime of the returned restore function.
+ * Returns a restore callback; calling it twice is harmless.
+ */
+export function installConsoleBridge(sink) {
+    const methods = Object.keys(LEVEL_BY_METHOD);
+    const originals = new Map();
+    for (const method of methods) {
+        originals.set(method, console[method].bind(console));
+        console[method] = (...args) => {
+            const text = format(...args);
+            if (text.length === 0)
+                return;
+            try {
+                sink(LEVEL_BY_METHOD[method], text);
+            }
+            catch {
+                // A failing sink must never turn a stray console.log into a crash.
+            }
+        };
+    }
+    let restored = false;
+    return () => {
+        if (restored)
+            return;
+        restored = true;
+        for (const [method, original] of originals) {
+            console[method] = original;
+        }
+    };
+}

package/dist/ui/density.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Entry spacing policy (spec §4.3).
+ *
+ * Replaces four unconditional `marginTop={1}` sites (`UserEntry`,
+ * `AssistantEntry`, `ToolCard`, the notice branch in `Transcript`). Those spent
+ * a blank row on EVERY entry, so a plain "ask -> read a file -> answer" turn was
+ * 17 rows tall against a 13-16 row viewport: the user could only ever see the
+ * current step.
+ *
+ * Blank space now marks the one boundary that means something — the start of a
+ * new user turn. Everything inside a turn stays contiguous, and the left rail
+ * (§4.3) provides the grouping the blank rows used to.
+ *
+ * Pure and free of React so `density.test.ts` can enumerate the whole matrix.
+ */
+import type { Entry } from '../agent/reducer.js';
+import type { DensityMode } from '../config/schema.js';
+export type { DensityMode };
+/**
+ * Blank rows to insert BEFORE `next`. `prev === undefined` means `next` is the
+ * first item in the list.
+ *
+ * This is the ONLY place allowed to decide entry spacing: if a component also
+ * sets its own `marginTop`, the two stack and the turn boundary becomes 2 rows.
+ */
+export declare function separationRows(prev: Entry | undefined, next: Entry, mode: DensityMode): 0 | 1;

package/dist/ui/density.js

@@ -0,0 +1,34 @@
+/**
+ * Entry spacing policy (spec §4.3).
+ *
+ * Replaces four unconditional `marginTop={1}` sites (`UserEntry`,
+ * `AssistantEntry`, `ToolCard`, the notice branch in `Transcript`). Those spent
+ * a blank row on EVERY entry, so a plain "ask -> read a file -> answer" turn was
+ * 17 rows tall against a 13-16 row viewport: the user could only ever see the
+ * current step.
+ *
+ * Blank space now marks the one boundary that means something — the start of a
+ * new user turn. Everything inside a turn stays contiguous, and the left rail
+ * (§4.3) provides the grouping the blank rows used to.
+ *
+ * Pure and free of React so `density.test.ts` can enumerate the whole matrix.
+ */
+/**
+ * Blank rows to insert BEFORE `next`. `prev === undefined` means `next` is the
+ * first item in the list.
+ *
+ * This is the ONLY place allowed to decide entry spacing: if a component also
+ * sets its own `marginTop`, the two stack and the turn boundary becomes 2 rows.
+ */
+export function separationRows(prev, next, mode) {
+    if (!prev)
+        return 0;
+    if (mode === 'compact')
+        return 0;
+    // Consecutive tool calls read as one action; keep them tight.
+    if (prev.kind === 'tool' && next.kind === 'tool')
+        return 0;
+    if (next.kind === 'user')
+        return 1;
+    return 0;
+}

package/dist/ui/entries/AssistantEntry.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Render a streaming assistant entry: an optional collapsible thinking block
+ * above the markdown-rendered answer text. Empty entries render nothing (a turn
+ * that only produced tool calls has no assistant text).
+ *
+ * The role glyph and spacing belong to `EntryFrame` (§4.3) — including the
+ * streaming spinner, which IS the role marker while text is arriving.
+ */
+import React from 'react';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+interface AssistantEntryProps {
+    text: string;
+    thinking?: string;
+    thinkingOpen: boolean;
+    thinkingVisible: boolean;
+    streaming: boolean;
+    aborted?: boolean;
+    theme: Theme;
+    caps: TermCapabilities;
+}
+export declare function AssistantEntry(props: AssistantEntryProps): React.ReactElement | null;
+export {};

package/dist/ui/entries/AssistantEntry.js

@@ -0,0 +1,13 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { pickGlyphs } from '../glyphs.js';
+import { Markdown } from '../Markdown.js';
+export function AssistantEntry(props) {
+    const { text, thinking, thinkingOpen, thinkingVisible, streaming, aborted, theme, caps } = props;
+    const glyphs = pickGlyphs(caps);
+    const hasThinking = !!thinking && thinking.trim().length > 0;
+    const hasText = text.trim().length > 0;
+    if (!hasThinking && !hasText && !streaming)
+        return null;
+    return (_jsxs(Box, { flexDirection: "column", children: [hasThinking && thinkingVisible && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { wrap: "truncate", color: theme.thinking, children: [glyphs.thinking, " thinking", thinkingOpen ? glyphs.ellipsis : ''] }), _jsx(Box, { flexDirection: "column", marginLeft: 2, children: thinking.split('\n').map((line, i) => (_jsx(Text, { color: theme.thinking, dimColor: true, children: line }, i))) })] })), (hasText || streaming) && (_jsxs(Box, { flexDirection: "column", children: [hasText ? (_jsx(Markdown, { text: text, theme: theme, caps: caps })) : (_jsx(Text, { color: theme.muted, children: glyphs.ellipsis })), aborted && _jsx(Text, { color: theme.noticeWarn, children: "[aborted]" })] }))] }));
+}

package/dist/ui/entries/EntryFrame.d.ts

@@ -0,0 +1,23 @@
+/**
+ * EntryFrame (spec §4.3) — the single shell every transcript entry renders
+ * inside, and the ONLY place entry spacing is applied.
+ *
+ * Keeping both the rail and the spacing here is what makes `density.ts` a real
+ * policy rather than a suggestion: an entry component that also set its own
+ * `marginTop` would silently double the gap at turn boundaries.
+ */
+import React from 'react';
+export interface EntryFrameProps {
+    /** Role marker shown on the entry's first row (may be a live spinner). */
+    glyph: React.ReactNode;
+    /** Rail / glyph colour — for tool cards this is the status colour (§5.3). */
+    color?: string;
+    /** Rail character drawn on the turn-boundary spacer row (`separation === 1`). */
+    continuation: string;
+    /** From `separationRows()`. Rendered as a rail stub, never a bare margin. */
+    separation: 0 | 1;
+    /** Muted colour for the spacer row so it recedes behind real content. */
+    spacerColor?: string;
+    children: React.ReactNode;
+}
+export declare function EntryFrame({ glyph, color, continuation, separation, spacerColor, children, }: EntryFrameProps): React.ReactElement;

package/dist/ui/entries/EntryFrame.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box } from 'ink';
+import { Gutter, RailSpacer } from '../layout/Gutter.js';
+export function EntryFrame({ glyph, color, continuation, separation, spacerColor, children, }) {
+    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [separation === 1 && _jsx(RailSpacer, { continuation: continuation, color: spacerColor }), _jsx(Gutter, { glyph: glyph, color: color, children: children })] }));
+}

package/dist/ui/entries/ToolCard.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Tool-call card (spec §3.5): a per-tool glyph, the tool name, a compact args
+ * summary, a colored status badge, and a duration, over a collapsible rich
+ * preview delegated to `<ToolPreview>`. Collapsed to the first 8 lines with a
+ * `+M lines (Ctrl+O)` footer; `Ctrl+O` / `/expand` toggle the full preview.
+ *
+ * Two v0.4.0 changes (§4.1 / §4.3):
+ *  - capabilities arrive as a prop. This used to infer Unicode support by
+ *    comparing `theme.symbols.gaugeFull` against a literal block character, so
+ *    editing an unrelated gauge glyph would have silently sent every tool icon
+ *    back to ASCII;
+ *  - the preview's round border is gone. It cost 2 rows and 4 columns per card,
+ *    and nested visibly inside markdown code blocks. A left rail carries the
+ *    same grouping in 1 column and 0 rows.
+ */
+import React from 'react';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+import type { ToolStatus } from '../../agent/reducer.js';
+interface ToolCardProps {
+    name: string;
+    label: string;
+    argsRaw: string;
+    args?: Record<string, unknown>;
+    status: ToolStatus;
+    preview?: string;
+    durationMs?: number;
+    isError?: boolean;
+    expanded?: boolean;
+    reducedMotion?: boolean;
+    theme: Theme;
+    caps: TermCapabilities;
+}
+export declare function statusColor(status: ToolStatus, theme: Theme): string | undefined;
+/** The tool's own glyph, used by `EntryView` as the entry's rail marker. */
+export declare function toolEntryGlyph(name: string, caps: TermCapabilities): string;
+export declare function ToolCard(props: ToolCardProps): React.ReactElement;
+export {};

package/dist/ui/entries/ToolCard.js

@@ -0,0 +1,72 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { pickGlyphs, toolGlyph } from '../glyphs.js';
+import { railBorderProps } from '../layout/Gutter.js';
+import { formatDuration } from '../../agent/usage.js';
+import { ToolPreview, bashBadge } from './ToolPreview.js';
+/** Number of preview lines shown before collapse. */
+const COLLAPSED_LINES = 8;
+export function statusColor(status, theme) {
+    switch (status) {
+        case 'pending':
+            return theme.toolPending;
+        case 'running':
+            return theme.toolRunning;
+        case 'done':
+            return theme.toolDone;
+        case 'error':
+            return theme.toolError;
+    }
+}
+/** One-line summary of the tool arguments for the card header. */
+function summarizeArgs(name, ellipsis, args, argsRaw) {
+    if (args) {
+        if (name === 'bash' && typeof args.command === 'string')
+            return args.command;
+        if (typeof args.path === 'string')
+            return args.path;
+        if (typeof args.pattern === 'string')
+            return args.pattern;
+        const keys = Object.keys(args);
+        if (keys.length > 0)
+            return keys.map((k) => `${k}=${short(args[k], ellipsis)}`).join(' ');
+    }
+    return (argsRaw ?? '').slice(0, 60);
+}
+function short(v, ellipsis) {
+    const s = typeof v === 'string' ? v : JSON.stringify(v);
+    return s.length > 40 ? `${s.slice(0, 40)}${ellipsis}` : s;
+}
+/** The badge label shown to the right of the tool name. */
+function badgeLabel(name, status, preview) {
+    if (name === 'bash' && (status === 'done' || status === 'error')) {
+        return bashBadge(status, preview).text;
+    }
+    switch (status) {
+        case 'pending':
+            return 'queued';
+        case 'running':
+            return 'running';
+        case 'done':
+            return 'done';
+        case 'error':
+            return 'failed';
+    }
+}
+/** The tool's own glyph, used by `EntryView` as the entry's rail marker. */
+export function toolEntryGlyph(name, caps) {
+    return toolGlyph(pickGlyphs(caps), name);
+}
+export function ToolCard(props) {
+    const { name, argsRaw, args, status, preview, durationMs, isError, expanded, reducedMotion, theme, caps, } = props;
+    const glyphs = pickGlyphs(caps);
+    const color = statusColor(status, theme);
+    const previewText = preview ?? '';
+    const previewLines = previewText.length > 0 ? previewText.split('\n') : [];
+    const visibleLines = expanded ? previewLines : previewLines.slice(0, COLLAPSED_LINES);
+    const hidden = previewLines.length - visibleLines.length;
+    const showBody = previewLines.length > 0 && (status === 'done' || status === 'error');
+    const badge = status === 'running' && !reducedMotion && caps.unicode ? (_jsxs(Text, { color: color, children: [_jsx(Spinner, { type: "dots" }), " running"] })) : (_jsxs(Text, { color: color, children: [status === 'running' ? `${glyphs.spinnerStill} ` : '', badgeLabel(name, status, previewText)] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: theme.accent, bold: true, children: name }), _jsxs(Text, { color: theme.muted, children: [" ", summarizeArgs(name, glyphs.ellipsis, args, argsRaw), "  "] }), badge, durationMs !== undefined && (_jsxs(Text, { color: theme.muted, children: [" (", formatDuration(durationMs), ")"] }))] }), showBody && (_jsxs(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, isError ? theme.toolError : theme.border), children: [_jsx(ToolPreview, { name: name, lines: visibleLines, theme: theme, isError: isError }), !expanded && hidden > 0 && (_jsxs(Text, { color: theme.muted, children: ["+", hidden, " ", hidden === 1 ? 'line' : 'lines', " (Ctrl+O)"] })), expanded && previewLines.length > COLLAPSED_LINES && (_jsx(Text, { color: theme.muted, children: "(Ctrl+O to collapse)" }))] }))] }));
+}

package/dist/ui/entries/ToolPreview.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Per-tool rich preview (spec §3.5). Selects a renderer by tool name: colored
+ * unified diffs (`edit_file`), a byte/path summary (`write_file`), a dimmed
+ * line-number gutter (`read_file`), a status-authoritative exit badge with a
+ * best-effort footer parse (`bash`), a dir/file/size listing (`list_dir`), a
+ * flat path list (`glob`), and a plain fallback (`grep` / default).
+ *
+ * The classification helpers are pure and exported so they are unit-testable
+ * without Ink.
+ */
+import React from 'react';
+import type { Theme } from '../theme.js';
+import { type ToolStatus } from '../../agent/reducer.js';
+export type DiffClass = 'add' | 'remove' | 'meta' | 'context';
+/**
+ * Classify a unified-diff line. Meta prefixes (`@@`, `---`, `+++`) are tested
+ * FIRST so a `--- path` header is not mis-read as a single-char removal (P2-8);
+ * the `Applied edit to <path>:` lead-in falls through to `context`.
+ */
+export declare function classifyDiffLine(line: string): DiffClass;
+/**
+ * Derive the bash badge. The exit status is authoritative (the tool returns an
+ * error result iff the exit code is non-zero), so the label is `exit 0` /
+ * `failed` from `status`; a real `[exit code N]` / `[signal X]` last line is
+ * parsed best-effort for the exact number, falling back to the status label
+ * when the footer was truncated out of the stored preview (P1-2).
+ */
+export declare function bashBadge(status: ToolStatus, preview: string): {
+    text: string;
+    ok: boolean;
+};
+/** Parse the real `Wrote <n> bytes to <path>` result — bytes+path only (P2-7). */
+export declare function parseWriteFile(text: string): {
+    bytes: number;
+    path: string;
+} | null;
+export interface ListRow {
+    kind: 'dir' | 'file';
+    name: string;
+    size?: string;
+}
+/** Parse a real `list_dir` row (`dir <name>/` / `file <name> (<n>b)`) (P2-9). */
+export declare function parseListRow(line: string): ListRow | null;
+/**
+ * No `caps` here on purpose. The only glyph this component ever spelled was the
+ * preview truncation marker, and that now comes from the constant its producer
+ * writes (`PREVIEW_TRUNCATION_MARK`), so there is nothing left to degrade — and
+ * a prop no body reads is exactly the kind of dead weight the last round removed.
+ */
+interface ToolPreviewProps {
+    name: string;
+    lines: string[];
+    theme: Theme;
+    isError?: boolean;
+}
+export declare function ToolPreview({ name, lines, theme, isError }: ToolPreviewProps): React.ReactElement;
+export {};