@aragon-agent/tui 0.0.0-stage → 0.0.1

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

@@ -0,0 +1,54 @@
+/**
+ * TodoCard — the transcript checklist entry (todo-plan-execution §6.2;
+ * todo-acceptance-criteria §6.10).
+ *
+ * ASCII ONLY: every glyph comes from `pickGlyphs`.
+ *
+ * ONE CARD PER USER TURN, REWRITTEN IN PLACE. The rail is EPHEMERAL and this is the
+ * HISTORY, exactly as `TeamPanel` and `TeamCard` divide the same work. It renders
+ * through the shared `EntryFrame` supplied by `EntryView`, so a plan reads as one
+ * more step in the transcript rather than a second kind of object.
+ *
+ * THE FULL LIST, NO WINDOWING (the transcript scrolls; the rail does not), and
+ * NEVER ANIMATED even while `live` — a resumed session would otherwise spin forever
+ * on a card whose run ended days ago.
+ *
+ * THE ACCEPTANCE BLOCK ADDS ROWS, NOT A CARD (§6.10): same frame, same marker
+ * column, one block underneath. Only a FAILED criterion gets an evidence line
+ * (D-14), which is what keeps the height exactly `1 + items.length + failedCount`.
+ */
+import React from 'react';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+import type { AcceptanceSnapshot, TodoItem } from '../../model/todo/types.js';
+export interface TodoCardProps {
+    items: TodoItem[];
+    doneCount: number;
+    total: number;
+    /**
+     * The acceptance projection (todo-acceptance-criteria §6.10).
+     *
+     * OPTIONAL, unlike `TodoSnapshot.acceptance` (P1-4): a `TodoSnapshot` has exactly
+     * one writer and can fail closed, while this entry's sources include transcript
+     * entries read back from a session file written before the feature existed. A
+     * required field there would be typed "present" and be `undefined` at runtime.
+     */
+    acceptance?: AcceptanceSnapshot | null;
+    live: boolean;
+    /** Saved mid-run and resumed: the run behind this card died with the process. */
+    interrupted?: boolean;
+    theme: Theme;
+    caps: TermCapabilities;
+}
+/** The card's aggregate colour: complete is done, anything else is in flight. */
+export declare function todoCardColor(doneCount: number, total: number, live: boolean, theme: Theme): string | undefined;
+declare function TodoCardImpl(props: TodoCardProps): React.ReactElement;
+/**
+ * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).
+ * `mapEntry` already preserves object identity for untouched entries, so the array
+ * props below are stable references on a settled card, and `theme` / `caps` are
+ * `useMemo`d in `App.tsx` (I-L2-1). `acceptance` is a NEW object whenever a verdict
+ * lands and the SAME reference otherwise, which is exactly what the comparator wants.
+ */
+export declare const TodoCard: React.MemoExoticComponent<typeof TodoCardImpl>;
+export {};

package/dist/ui/entries/TodoCard.js

@@ -0,0 +1,98 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * TodoCard — the transcript checklist entry (todo-plan-execution §6.2;
+ * todo-acceptance-criteria §6.10).
+ *
+ * ASCII ONLY: every glyph comes from `pickGlyphs`.
+ *
+ * ONE CARD PER USER TURN, REWRITTEN IN PLACE. The rail is EPHEMERAL and this is the
+ * HISTORY, exactly as `TeamPanel` and `TeamCard` divide the same work. It renders
+ * through the shared `EntryFrame` supplied by `EntryView`, so a plan reads as one
+ * more step in the transcript rather than a second kind of object.
+ *
+ * THE FULL LIST, NO WINDOWING (the transcript scrolls; the rail does not), and
+ * NEVER ANIMATED even while `live` — a resumed session would otherwise spin forever
+ * on a card whose run ended days ago.
+ *
+ * THE ACCEPTANCE BLOCK ADDS ROWS, NOT A CARD (§6.10): same frame, same marker
+ * column, one block underneath. Only a FAILED criterion gets an evidence line
+ * (D-14), which is what keeps the height exactly `1 + items.length + failedCount`.
+ */
+import React from 'react';
+import { Box, Text } from 'ink';
+import { pickGlyphs } from '../glyphs.js';
+import { railBorderProps } from '../layout/Gutter.js';
+import { derivePlanPhase } from '../../model/todo/acceptance.js';
+/** The card's aggregate colour: complete is done, anything else is in flight. */
+export function todoCardColor(doneCount, total, live, theme) {
+    if (live)
+        return theme.toolRunning;
+    if (total > 0 && doneCount === total)
+        return theme.toolDone;
+    return theme.muted;
+}
+function marker(item, glyphs) {
+    if (item.status === 'completed')
+        return glyphs.todoDone;
+    if (item.status === 'in_progress')
+        return glyphs.todoActive;
+    return glyphs.todoPending;
+}
+function rowColor(item, theme) {
+    if (item.status === 'completed')
+        return theme.muted;
+    if (item.status === 'in_progress')
+        return theme.primary;
+    return theme.hintFg ?? theme.muted;
+}
+/** `passed` reuses the done glyph; `failed` is the one new meaning (D-9). */
+function acceptanceMarker(item, glyphs) {
+    if (item.status === 'passed')
+        return glyphs.todoDone;
+    if (item.status === 'failed')
+        return glyphs.todoFail;
+    if (item.status === 'in_progress')
+        return glyphs.todoActive;
+    return glyphs.todoPending;
+}
+function acceptanceRowColor(item, theme) {
+    if (item.status === 'failed')
+        return theme.toolError;
+    if (item.status === 'passed')
+        return theme.muted;
+    if (item.status === 'in_progress')
+        return theme.primary;
+    return theme.hintFg ?? theme.muted;
+}
+/**
+ * All passed reads as done, any failure as an error, otherwise muted; while the run
+ * is live and the plan is in VERIFY it reads as running - the same expression family
+ * `todoCardColor` uses one level up.
+ */
+function acceptanceTitleColor(acceptance, items, live, theme) {
+    if (acceptance.failedCount > 0)
+        return theme.toolError;
+    if (live && derivePlanPhase(items, acceptance.items) === 'verify')
+        return theme.toolRunning;
+    if (acceptance.total > 0 && acceptance.checkedCount === acceptance.total)
+        return theme.toolDone;
+    return theme.muted;
+}
+function TodoCardImpl(props) {
+    const { items, doneCount, total, acceptance, live, interrupted, theme, caps } = props;
+    const glyphs = pickGlyphs(caps);
+    const criteria = acceptance && acceptance.total > 0 ? acceptance : null;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: theme.accent, bold: true, children: "Todos" }), _jsxs(Text, { color: todoCardColor(doneCount, total, live, theme), children: ['  ', doneCount, "/", total] }), interrupted && (
+                    // A resumed `2/7` would otherwise read as a run still in flight (P2-6).
+                    // Saying so plainly is the same fix `TeamCard` makes for a dispatch that
+                    // never got a duration.
+                    _jsxs(Text, { color: theme.muted, children: ['  ', "interrupted (session resumed)"] }))] }), _jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: items.map((item, index) => (_jsxs(Text, { wrap: "truncate", color: rowColor(item, theme), children: [marker(item, glyphs).padEnd(3), item.status === 'in_progress' ? item.activeForm : item.content] }, `${index}-${item.content}`))) }), criteria && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: theme.accent, bold: true, children: "Acceptance" }), _jsxs(Text, { color: acceptanceTitleColor(criteria, items, live, theme), children: ['  ', criteria.checkedCount, "/", criteria.total, " checked", criteria.failedCount > 0 ? `  !${criteria.failedCount} failed` : ''] })] }), _jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: criteria.items.map((item, index) => (_jsxs(React.Fragment, { children: [_jsxs(Text, { wrap: "truncate", color: acceptanceRowColor(item, theme), children: [acceptanceMarker(item, glyphs).padEnd(3), item.content] }), item.status === 'failed' && item.evidence.length > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['      ', item.evidence] }))] }, `acc-${index}-${item.content}`))) })] }))] }));
+}
+/**
+ * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).
+ * `mapEntry` already preserves object identity for untouched entries, so the array
+ * props below are stable references on a settled card, and `theme` / `caps` are
+ * `useMemo`d in `App.tsx` (I-L2-1). `acceptance` is a NEW object whenever a verdict
+ * lands and the SAME reference otherwise, which is exactly what the comparator wants.
+ */
+export const TodoCard = React.memo(TodoCardImpl);

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

@@ -0,0 +1,81 @@
+/**
+ * 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 '../../model/agent/reducer.js';
+import type { FilePatch } from '../../model/tools/patch.js';
+interface ToolCardProps {
+    name: string;
+    label: string;
+    argsRaw: string;
+    args?: Record<string, unknown>;
+    status: ToolStatus;
+    preview?: string;
+    /**
+     * The structured file diff, when the tool produced one (§3.4). Present it and
+     * `DiffView` draws INSTEAD of `ToolPreview`; absent — a session saved by an
+     * older build, an entry the store's 64-write ring evicted, or a toolset built
+     * without a recorder — and the text preview renders exactly what it does
+     * today. Nothing ever renders blank.
+     */
+    patch?: FilePatch;
+    durationMs?: number;
+    isError?: boolean;
+    expanded?: boolean;
+    reducedMotion?: boolean;
+    /**
+     * The sanitised live tail while the tool runs
+     * (agent-activity-presentation-live §3.3.4).
+     *
+     * PASSED AS `live={entry.live}` AND NEVER `live={entry.live ?? []}` (P2-4).
+     * This component is `React.memo` with the DEFAULT comparator, so a fresh `[]`
+     * per render is a changed prop and defeats the boundary for every settled card
+     * in the transcript — which is exactly why `EMPTY_LINES` above exists.
+     */
+    live?: readonly string[];
+    /** Epoch ms of the last output row; with `nowSec`, the stall row's clock. */
+    lastOutputAt?: number;
+    /**
+     * Wall-clock SECONDS, passed ONLY to running entries (D-29 / D-36).
+     *
+     * Seconds and not milliseconds, and `undefined` on every other card, for the
+     * same reason: a prop that changed five times a second on every entry would
+     * defeat this memo boundary transcript-wide. The value is wall-clock rather
+     * than the ticker's `elapsedMs` because the stall is `now - lastOutputAt` and
+     * `lastOutputAt` is epoch ms; the ticker's job is to cause the render.
+     */
+    nowSec?: number;
+    theme: Theme;
+    caps: TermCapabilities;
+}
+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;
+declare function ToolCardImpl(props: ToolCardProps): React.ReactElement;
+/**
+ * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).
+ * Every prop is a scalar except `args` (a stable reference on a settled entry),
+ * `patch` and `theme` / `caps` (both `useMemo`d in `App.tsx` — I-L2-1).
+ *
+ * `patch` QUALIFIES ONLY BECAUSE THE REDUCER WRITES IT ONCE, at `toolExecEnd`,
+ * and never rebuilds it — `mapEntry` preserves object identity for untouched
+ * entries. A future action that recomputed or normalized a patch would turn this
+ * boundary into a no-op WITH NOTHING FAILING, which is the same trap I-L2-1
+ * exists to catch for `theme` and `caps` (P2-9).
+ */
+export declare const ToolCard: React.MemoExoticComponent<typeof ToolCardImpl>;
+export {};

package/dist/ui/entries/ToolCard.js

@@ -0,0 +1,169 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * Tool-call card (spec §3.5): a per-tool glyph, the tool name, a compact args
+ * summary, a colored status badge, and a duration, over a collapsible rich
+ * 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 { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { pickGlyphs, toolGlyph } from '../glyphs.js';
+import { railBorderProps } from '../layout/Gutter.js';
+import { splitLinesCached } from '../render-cache.js';
+import { formatDuration } from '../../model/agent/usage.js';
+import { ToolPreview, bashBadge } from './ToolPreview.js';
+import { DiffView } from './DiffView.js';
+import { STALL_AFTER_MS } from '../../model/tools/tool-output-store.js';
+import { shortDuration } from '../layout/status-layout.js';
+/** Number of preview lines shown before collapse. */
+const COLLAPSED_LINES = 8;
+/** Shared empty slice, so an argument-less card allocates nothing per frame. */
+const EMPTY_LINES = [];
+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, midDot = '-') {
+    if (args) {
+        // `t3 - up to 10m00s` reads better in the settled history row than
+        // `job=t3 timeoutSeconds=600` (extended-job-wait P2). Needs both fields.
+        if (name === 'job_wait' && typeof args.job === 'string') {
+            const seconds = args.timeoutSeconds;
+            return typeof seconds === 'number' && Number.isFinite(seconds) && seconds > 0
+                ? `${args.job} ${midDot} up to ${shortDuration(seconds * 1000)}`
+                : args.job;
+        }
+        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);
+}
+function ToolCardImpl(props) {
+    const { name, argsRaw, args, status, preview, patch, durationMs, isError, expanded, reducedMotion, live, lastOutputAt, nowSec, theme, caps, } = props;
+    const glyphs = pickGlyphs(caps);
+    const color = statusColor(status, theme);
+    const previewText = preview ?? '';
+    // `splitLinesCached` rather than `previewText.split('\n')`: a stored preview
+    // is immutable once written, and this used to reallocate up to 200 strings per
+    // card per frame (R3).
+    const previewLines = previewText.length > 0 ? splitLinesCached(previewText) : EMPTY_LINES;
+    const ceiling = expanded ? previewLines.length : COLLAPSED_LINES;
+    const visibleLines = ceiling >= previewLines.length ? previewLines : previewLines.slice(0, ceiling);
+    const hidden = previewLines.length - visibleLines.length;
+    const settled = status === 'done' || status === 'error';
+    const showPatch = !!patch && settled;
+    // The live tail (agent-activity-presentation-live §3.3.4). `expanded` is
+    // deliberately ABSENT from this arithmetic: `Ctrl+O` is inert on a live card
+    // (D-26), because expansion is a promise about STORED content and the store
+    // deliberately holds eight rows. A key that silently does nothing is better
+    // than a key that promises the rest of a 400 MB stream.
+    //
+    // THE TAIL IS THE **LAST** ROWS, and the settled preview above keeps its
+    // head-first slice (E-21). Two different ends because they answer two
+    // different questions — "what did this command do" versus "what is it doing
+    // NOW" (D-25). Head-first while live would freeze on the first eight lines a
+    // build ever printed and then never change again.
+    const liveRows = live ?? EMPTY_LINES;
+    const liveCeiling = COLLAPSED_LINES;
+    const visibleLive = liveRows.length > liveCeiling ? liveRows.slice(-Math.max(1, liveCeiling)) : liveRows;
+    const showLive = !settled && visibleLive.length > 0;
+    // THE OUTER GUARD WIDENS WITH THE BRANCH (P2-2). It was `previewLines.length >
+    // 0 && ...`, and the reducer now truncates the stored preview to ONE LINE when
+    // a patch is attached (D-19) — so a card whose preview were ever empty would
+    // render its header and swallow the diff, silently. It widens a second time
+    // here, for the third branch: without `|| showLive` the tail would be computed
+    // and never drawn.
+    const showBody = ((previewLines.length > 0 || showPatch) && settled) || showLive;
+    // ONE FOOTER ROW, ALWAYS, matching `estimateEntryRows`'s arithmetic exactly: a
+    // CONSTANT row count is what lets the estimate be exact rather than an upper
+    // bound. `nowSec` is absent until the first tick, which reads as "not stalled".
+    const stalledFor = nowSec !== undefined && lastOutputAt !== undefined
+        ? nowSec * 1000 - lastOutputAt
+        : 0;
+    const liveFooter = stalledFor >= STALL_AFTER_MS
+        ? `no output for ${Math.floor(stalledFor / 1000)}s`
+        : '(running)';
+    const badge = status === 'running' && !reducedMotion && caps.unicode ? (_jsxs(Text, { color: color, children: [_jsx(Spinner, { type: "dots" }), " running"] })) : (_jsxs(Text, { color: color, children: [status === 'running' ? `${glyphs.spinnerStill} ` : '', badgeLabel(name, status, previewText)] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: theme.accent, bold: true, children: name }), _jsxs(Text, { color: theme.muted, children: [" ", summarizeArgs(name, glyphs.ellipsis, args, argsRaw, glyphs.midDot), "  "] }), badge, durationMs !== undefined && (_jsxs(Text, { color: theme.muted, children: [" (", formatDuration(durationMs), ")"] }))] }), showBody && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, isError ? theme.toolError : theme.border), children: showLive ? (_jsxs(_Fragment, { children: [visibleLive.map((row, i) => (
+                        // The row is already terminal-safe and clipped at
+                        // `LIVE_ROW_MAX_CHARS` by `sanitizeChunk`, so `wrap="truncate"`
+                        // is an exact height rather than a hope — which is the coupling
+                        // `estimateEntryRows`'s live branch relies on.
+                        //
+                        // The index IS the key: these rows are positional slots in a
+                        // ring, not identities, and the whole array is replaced on every
+                        // chunk anyway.
+                        //
+                        // AN EMPTY ROW RENDERS AS A SPACE, and that is not cosmetic:
+                        // Ink measures a `<Text>` with an empty child as ZERO rows, so a
+                        // blank separator line — which `npm test`, `cargo` and every
+                        // build tool print — would make the card shorter than
+                        // `estimateEntryRows` charged for it. That is an over-estimate,
+                        // the safe direction, but it would quietly cost §3.3.4's
+                        // "constant row count" the exactness its arithmetic claims. A
+                        // space is also what the terminal itself shows for a blank line.
+                        // eslint-disable-next-line react/no-array-index-key
+                        _jsx(Text, { wrap: "truncate", color: theme.muted, children: row.length > 0 ? row : ' ' }, i))), _jsx(Text, { color: theme.muted, children: liveFooter })] })) : showPatch ? (_jsx(DiffView, { patch: patch, expanded: expanded, theme: theme })) : (_jsxs(_Fragment, { children: [_jsx(ToolPreview, { name: name, lines: visibleLines, theme: theme, isError: isError }), !expanded && hidden > 0 && (_jsxs(Text, { color: theme.muted, children: ["+", hidden, " ", hidden === 1 ? 'line' : 'lines', " (Ctrl+O)"] })), expanded && hidden > 0 && (_jsxs(Text, { color: theme.muted, children: ["+", hidden, " ", hidden === 1 ? 'line' : 'lines', " ", glyphs.midDot, " shown in full when this entry finishes"] })), expanded && previewLines.length > COLLAPSED_LINES && (_jsx(Text, { color: theme.muted, children: "(Ctrl+O to collapse)" }))] })) }))] }));
+}
+/**
+ * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).
+ * Every prop is a scalar except `args` (a stable reference on a settled entry),
+ * `patch` and `theme` / `caps` (both `useMemo`d in `App.tsx` — I-L2-1).
+ *
+ * `patch` QUALIFIES ONLY BECAUSE THE REDUCER WRITES IT ONCE, at `toolExecEnd`,
+ * and never rebuilds it — `mapEntry` preserves object identity for untouched
+ * entries. A future action that recomputed or normalized a patch would turn this
+ * boundary into a no-op WITH NOTHING FAILING, which is the same trap I-L2-1
+ * exists to catch for `theme` and `caps` (P2-9).
+ */
+export const ToolCard = React.memo(ToolCardImpl);

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

@@ -0,0 +1,59 @@
+/**
+ * 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 '../../model/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;
+/** `3 questions · Postgres · REST` — or `dismissed`. */
+export declare function summarizeAskUser(lines: readonly string[]): 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: readonly string[];
+    theme: Theme;
+    isError?: boolean;
+}
+export declare function ToolPreview({ name, lines, theme, isError }: ToolPreviewProps): React.ReactElement;
+export {};