@aiwayds/dsh-tui-pi 0.4.0 → 0.4.3

package/README.md

@@ -319,16 +319,26 @@ dsh-tui-pi avoids both by construction:
 - **Streaming strategy**: deltas accumulate in a plain Text via `setText` on
   the same component (never remove+re-add per token); markdown renders once on
   the assembled `assistant/message` (no per-token markdown parsing).
-- **Configurable think/tool panels** (`dsh-tui.panelHeight`, default `'5'`):
-  `'5'/'7'/'10'` set the total panel rows (top border + header row + body rows
-  + bottom border); `'all'` prints the full body, with bounded on-screen
-  content — a streaming reasoning panel boxes a 200-line live tail while
-  chunks are in flight (the assembled message renders everything) and a
-  settled tool result keeps at most 2000 lines (a `… (+N lines)` marker
-  reports the drop). No inner scroll — pi-tui 0.84.2 never lays out nested
-  components, so a nested ScrollView cannot obtain a viewport. Body lines are
-  clipped to one physical row *before* styling, so long output can never wrap
-  the panel past its configured rows.
+- **Fixed think/tool status panels** (pinned above the chat input, like the
+  Todos panel): think/tool activity never creates transcript blocks — one
+  ThinkPanel and one ToolPanel exist for the whole run, every event refreshes
+  the same panel in place, and a panel with no content renders zero rows
+  (hidden). Delegation spawn tools (`use_agent`, `subagent`, `workflow`,
+  `ralph`) never open a tool block — their children show in the running-agent
+  lines below the editor. The bottom running-agent line shows the child's
+  latest CONTENT line (live-refreshed assistant text/reasoning, never a tool
+  name), truncated at the right edge without wrapping.
+- **Configurable panel height** (`dsh-tui.panelHeight`, default `'1'`):
+  `'1'` renders one borderless row — block identifier + elapsed time + the
+  last content line, right-truncated, never wrapped; `'5'/'7'/'10'` box the
+  panel (top border + header row + body rows + bottom border); `'all'` prints
+  the full body, with bounded on-screen content — a streaming reasoning panel
+  boxes a 200-line live tail while chunks are in flight and a settled tool
+  result keeps at most 2000 lines (a `… (+N lines)` marker reports the drop).
+  No inner scroll — pi-tui 0.84.2 never lays out nested components, so a
+  nested ScrollView cannot obtain a viewport. Body lines are clipped to one
+  physical row *before* styling, so long output can never wrap the panel past
+  its configured rows.
 - **Width safety**: every truncation goes through `clipToWidth` (src/text.ts)
   — CJK full-width characters count 2 columns and graphemes are never split.
   Bare `String.length` clipping is banned.

package/cordis.patch.yml

@@ -3,6 +3,11 @@
 # terminal UI in-process with @earendil-works/pi-tui and talks to the dsh tree
 # directly (ctx.agents / ctx.commands / session events), keeping dsh's slash
 # commands untouched.
+#
+# dsh-dcp is NOT mounted here: it is a dependency of this package and ships
+# its own bundle patch (@aiwayds/dsh-dcp/cordis.patch.yml). Adding dsh-dcp to
+# the profile's bundles mounts it; mounting it here too would duplicate the
+# entry id and crash the loader.
 
 - insert:
     - id: tui-pi

package/lib/activity.d.ts

@@ -0,0 +1,175 @@
+/**
+ * Live activity panels — the single fixed think/tool status surfaces pinned
+ * ABOVE the chat input (live-widgets.ts mounts them; index.ts routes session
+ * events through LiveWidgets.applyEvent). One ThinkPanel and one ToolPanel
+ * instance exist for the whole TUI run: think/tool activity NEVER creates
+ * transcript blocks — every event refreshes the same panel in place, and a
+ * panel with no content renders zero rows (hidden until the next burst).
+ *
+ * Height modes (`dsh-tui.panelHeight`):
+ *  - '1' (default): ONE borderless row — block identifier + elapsed time +
+ *    the last content line (live-refreshed), right-truncated at the terminal
+ *    width, never wrapped.
+ *  - '5'/'7'/'10': the boxed panel (top border + header row + content rows +
+ *    bottom border) at the configured displayed-row budget.
+ *  - 'all': the boxed panel without a row cap (a streaming reasoning burst
+ *    still boxes only a bounded live tail; settled tool results cap at
+ *    ALL_TOOL_RESULT_LINES with a drop marker).
+ *
+ * Panels are self-drawing Components (render(width) per frame, no cached
+ * rows — the TodosPanel pattern): a terminal resize re-lays the box out
+ * automatically and a theme hot-switch needs only a repaint, never a replay.
+ * Plain text is clipped BEFORE styling everywhere (clipToWidth counts SGR
+ * fragments as visible columns — see clipRow's contract).
+ */
+import type { Component } from '@earendil-works/pi-tui';
+import { type TuiTheme } from './theme/index.ts';
+/**
+ * Configurable think/tool panel height. '1' is a single borderless row;
+ * fixed values count the DISPLAYED rows of the box — the header line plus
+ * the content rows (the two box borders are not counted); 'all' prints the
+ * full body with no row cap.
+ */
+export type PanelHeight = '1' | '5' | '7' | '10' | 'all';
+/**
+ * Default think/tool panel height: ONE row — block identifier, elapsed time
+ * and the last content line. The single default for every '1' fallback (the
+ * settings schema default/entry/narrowing, the LiveWidgets constructor);
+ * other heights are set through the `panelHeight` setting.
+ */
+export declare const DEFAULT_PANEL_HEIGHT: PanelHeight;
+/**
+ * 'all' streaming cap: while a reasoning stream is in flight, the boxed panel
+ * keeps only this many trailing rows (per-frame cost stays O(tail), never
+ * O(accumulated)). Fixed heights are tail-bounded by their row budget.
+ */
+export declare const STREAMING_TAIL_LINES = 200;
+/**
+ * 'all' settle cap: a settled tool panel keeps at most this many body rows,
+ * with a `… (+N lines)` marker for the drop.
+ */
+export declare const ALL_TOOL_RESULT_LINES = 2000;
+/**
+ * Terminal columns a panel body row's CONTENT may occupy so the whole
+ * bordered row renders on exactly one physical line: the body wraps at
+ * `width - paddingX*2` (paddingX = 1), every row carries 4 columns of box
+ * chrome (`│ ` … ` │`), and tool rows add a 2-column indent — hence the -6
+ * (think) and -8 (tool, indent = 2) headroom.
+ */
+export declare function panelLineCap(columns: number | undefined, indent?: number): number;
+/** Full visible width of one bordered panel row, box chrome included. */
+export declare function panelBoxWidth(columns: number | undefined): number;
+/**
+ * One bordered panel row of exactly `boxWidth` visible columns: side borders
+ * in `borderFg`, `inner` (already styled, already clipped) left-aligned and
+ * padded with spaces to the full box width. No trailing RESET — the caller
+ * wraps the row in the panel background SGR and terminates it.
+ */
+export declare function borderedRow(boxWidth: number, borderFg: string, inner: string): string;
+/** Top border line (`┌─…─┐`), `boxWidth` columns wide, in `borderFg`. */
+export declare function panelTopBorder(boxWidth: number, borderFg: string): string;
+/** Bottom border line (`└─…─┘`), `boxWidth` columns wide, in `borderFg`. */
+export declare function panelBottomBorder(boxWidth: number, borderFg: string): string;
+/**
+ * Clip an unstyled line to one physical panel row at the CURRENT render
+ * width. Must run BEFORE styling: clipToWidth counts per grapheme, so the
+ * ASCII fragments of an SGR code would count as visible columns — clipping
+ * plain text first, then applying ANSI, keeps the accounting exact.
+ * `indent` is the leading content indent the row carries (2 for tool rows).
+ * Carriage returns are stripped first: a bare \r (progress bars, CRLF tool
+ * output) would break the fixed panel rows just like a wrap would — the
+ * panel line is one row, not a line record.
+ */
+export declare function clipRow(text: string, width: number, indent?: number): string;
+/**
+ * Clip an unstyled line against the process terminal width (the historical
+ * clipPanelLine contract — kept for callers outside a render(width) frame,
+ * e.g. the running-agent line's label).
+ */
+export declare function clipPanelLine(text: string, indent?: number): string;
+/**
+ * Compose the bordered body rows (plus the bottom border) from
+ * already-styled, already-clipped lines: keep the tail — newest rows win —
+ * pad short content with empty boxed rows, then append the bottom border.
+ * `bodyRows` is the panel's body-row budget or 'all': with 'all' every line
+ * is kept verbatim, nothing is padded. Pad rows carry the box characters so
+ * they survive Text's empty-row fast path. Callers clip each line BEFORE
+ * styling — otherwise a styled line that outgrows its budget wraps and the
+ * panel exceeds its configured rows.
+ */
+export declare function panelBodyText(lines: readonly string[], boxWidth: number, borderFg: string, bodyRows?: number | 'all'): string;
+/**
+ * The tool header's subject word: the file path for read/write-style tools,
+ * the command's first word for cli-style tools ('git', 'python') — the first
+ * whitespace token of the highest-priority string argument (same key
+ * priority as callDetail's summary). '' when the arguments carry no usable
+ * string (the header then shows the bare tool name).
+ */
+export declare function toolSubject(rawArguments: string): string;
+/** One-line summary of the call arguments, per common tool shape. */
+export declare function callDetail(rawArguments: string, limit?: number): string;
+/** First text content of a tool result, raw lines. */
+export declare function resultTextLines(content: readonly {
+    type: string;
+    text?: string;
+}[]): string[];
+/**
+ * The live thinking panel: one fixed surface for the WHOLE run, refreshed in
+ * place by every reasoning delta. Visible while a reasoning burst streams
+ * (feed); hidden by the next phase event (text delta, tool call, message
+ * assembly, turn end — LiveWidgets.applyEvent drives those).
+ */
+export declare class ThinkPanel implements Component {
+    private state;
+    private height;
+    private readonly getTheme;
+    constructor(getTheme: () => TuiTheme);
+    invalidate(): void;
+    /** Whether the panel currently has content (drives the live tick). */
+    isVisible(): boolean;
+    setHeight(height: PanelHeight): void;
+    /** One reasoning delta; the first delta of a burst opens the panel. */
+    feed(delta: string): void;
+    hide(): void;
+    render(width: number): string[];
+}
+/** The settle payload ToolPanel.settle accepts (structural, event-shape). */
+export interface ToolSettleData {
+    error?: {
+        name: string;
+        code?: string;
+    };
+    block?: {
+        isError?: boolean;
+        content: readonly {
+            type: string;
+            text?: string;
+        }[];
+    };
+}
+/**
+ * The live tool panel: one fixed surface refreshed by every tool call — a
+ * new call replaces the tracked tool (sequential/parallel calls all refresh
+ * this same panel), a matching result settles it (icon/status/time freeze,
+ * body shows the result tail), and any later phase event hides it.
+ */
+export declare class ToolPanel implements Component {
+    private state;
+    private height;
+    private readonly getTheme;
+    constructor(getTheme: () => TuiTheme);
+    invalidate(): void;
+    /** Whether the panel currently has content (drives the live tick). */
+    isVisible(): boolean;
+    setHeight(height: PanelHeight): void;
+    /** A new tool call: replaces the tracked tool with a pending one. */
+    begin(callId: string, name: string, rawArguments: string): void;
+    /**
+     * Settle the tracked tool. Results for a callId other than the tracked
+     * one (parallel calls; a result racing a newer begin) are ignored.
+     * @returns whether the tracked tool settled.
+     */
+    settle(callId: string, data: ToolSettleData): boolean;
+    hide(): void;
+    render(width: number): string[];
+}

package/lib/activity.js

@@ -0,0 +1,426 @@
+/**
+ * Live activity panels — the single fixed think/tool status surfaces pinned
+ * ABOVE the chat input (live-widgets.ts mounts them; index.ts routes session
+ * events through LiveWidgets.applyEvent). One ThinkPanel and one ToolPanel
+ * instance exist for the whole TUI run: think/tool activity NEVER creates
+ * transcript blocks — every event refreshes the same panel in place, and a
+ * panel with no content renders zero rows (hidden until the next burst).
+ *
+ * Height modes (`dsh-tui.panelHeight`):
+ *  - '1' (default): ONE borderless row — block identifier + elapsed time +
+ *    the last content line (live-refreshed), right-truncated at the terminal
+ *    width, never wrapped.
+ *  - '5'/'7'/'10': the boxed panel (top border + header row + content rows +
+ *    bottom border) at the configured displayed-row budget.
+ *  - 'all': the boxed panel without a row cap (a streaming reasoning burst
+ *    still boxes only a bounded live tail; settled tool results cap at
+ *    ALL_TOOL_RESULT_LINES with a drop marker).
+ *
+ * Panels are self-drawing Components (render(width) per frame, no cached
+ * rows — the TodosPanel pattern): a terminal resize re-lays the box out
+ * automatically and a theme hot-switch needs only a repaint, never a replay.
+ * Plain text is clipped BEFORE styling everywhere (clipToWidth counts SGR
+ * fragments as visible columns — see clipRow's contract).
+ */
+import { ansiBg, ansiFg, RESET } from "./theme/index.js";
+import { clipToWidth, lastNonBlankLine, visibleWidth } from "./text.js";
+/**
+ * Default think/tool panel height: ONE row — block identifier, elapsed time
+ * and the last content line. The single default for every '1' fallback (the
+ * settings schema default/entry/narrowing, the LiveWidgets constructor);
+ * other heights are set through the `panelHeight` setting.
+ */
+export const DEFAULT_PANEL_HEIGHT = '1';
+/** Content rows inside the default boxed panel (a '5' box minus the header row). */
+const PANEL_BODY_LINES = 4;
+/**
+ * 'all' streaming cap: while a reasoning stream is in flight, the boxed panel
+ * keeps only this many trailing rows (per-frame cost stays O(tail), never
+ * O(accumulated)). Fixed heights are tail-bounded by their row budget.
+ */
+export const STREAMING_TAIL_LINES = 200;
+/**
+ * 'all' settle cap: a settled tool panel keeps at most this many body rows,
+ * with a `… (+N lines)` marker for the drop.
+ */
+export const ALL_TOOL_RESULT_LINES = 2000;
+/** Thinking panel identifier (icon + label), 11 visible columns. */
+const THINKING_HEADER = '💭 thinking';
+/**
+ * Fallback terminal columns when the real width is unknown (non-TTY
+ * contexts, e.g. tests): conservative so no sane terminal wraps.
+ */
+const PANEL_LINE_CAP_FALLBACK = 200;
+/**
+ * Bound of the accumulated reasoning tail a ThinkPanel keeps — enough for
+ * the 'all' live tail (STREAMING_TAIL_LINES rows) plus slack, so a runaway
+ * stream cannot grow the panel state unboundedly. Trimmed at line
+ * boundaries; each delta does amortized O(1) trim work.
+ */
+const THINK_TAIL_CAP = 32_768;
+/**
+ * Terminal columns a panel body row's CONTENT may occupy so the whole
+ * bordered row renders on exactly one physical line: the body wraps at
+ * `width - paddingX*2` (paddingX = 1), every row carries 4 columns of box
+ * chrome (`│ ` … ` │`), and tool rows add a 2-column indent — hence the -6
+ * (think) and -8 (tool, indent = 2) headroom.
+ */
+export function panelLineCap(columns, indent = 0) {
+    return Math.max(1, (columns === undefined ? PANEL_LINE_CAP_FALLBACK : columns) - 6 - indent);
+}
+/** Full visible width of one bordered panel row, box chrome included. */
+export function panelBoxWidth(columns) {
+    return panelLineCap(columns) + 4;
+}
+/**
+ * One bordered panel row of exactly `boxWidth` visible columns: side borders
+ * in `borderFg`, `inner` (already styled, already clipped) left-aligned and
+ * padded with spaces to the full box width. No trailing RESET — the caller
+ * wraps the row in the panel background SGR and terminates it.
+ */
+export function borderedRow(boxWidth, borderFg, inner) {
+    const pad = Math.max(0, boxWidth - 4 - visibleWidth(inner));
+    return `${borderFg}│ ${inner}${' '.repeat(pad)}${borderFg} │`;
+}
+/** Top border line (`┌─…─┐`), `boxWidth` columns wide, in `borderFg`. */
+export function panelTopBorder(boxWidth, borderFg) {
+    return `${borderFg}┌${'─'.repeat(Math.max(0, boxWidth - 2))}┐`;
+}
+/** Bottom border line (`└─…─┘`), `boxWidth` columns wide, in `borderFg`. */
+export function panelBottomBorder(boxWidth, borderFg) {
+    return `${borderFg}└${'─'.repeat(Math.max(0, boxWidth - 2))}┘`;
+}
+/**
+ * Clip an unstyled line to one physical panel row at the CURRENT render
+ * width. Must run BEFORE styling: clipToWidth counts per grapheme, so the
+ * ASCII fragments of an SGR code would count as visible columns — clipping
+ * plain text first, then applying ANSI, keeps the accounting exact.
+ * `indent` is the leading content indent the row carries (2 for tool rows).
+ * Carriage returns are stripped first: a bare \r (progress bars, CRLF tool
+ * output) would break the fixed panel rows just like a wrap would — the
+ * panel line is one row, not a line record.
+ */
+export function clipRow(text, width, indent = 0) {
+    return clipToWidth(text.replace(/\r/g, ''), panelLineCap(width, indent));
+}
+/**
+ * Clip an unstyled line against the process terminal width (the historical
+ * clipPanelLine contract — kept for callers outside a render(width) frame,
+ * e.g. the running-agent line's label).
+ */
+export function clipPanelLine(text, indent = 0) {
+    return clipToWidth(text.replace(/\r/g, ''), panelLineCap(process.stdout.columns, indent));
+}
+/**
+ * Compose the bordered body rows (plus the bottom border) from
+ * already-styled, already-clipped lines: keep the tail — newest rows win —
+ * pad short content with empty boxed rows, then append the bottom border.
+ * `bodyRows` is the panel's body-row budget or 'all': with 'all' every line
+ * is kept verbatim, nothing is padded. Pad rows carry the box characters so
+ * they survive Text's empty-row fast path. Callers clip each line BEFORE
+ * styling — otherwise a styled line that outgrows its budget wraps and the
+ * panel exceeds its configured rows.
+ */
+export function panelBodyText(lines, boxWidth, borderFg, bodyRows = PANEL_BODY_LINES) {
+    const visible = bodyRows === 'all'
+        ? [...lines]
+        : lines.length > bodyRows ? lines.slice(-bodyRows) : [...lines];
+    if (bodyRows !== 'all') {
+        while (visible.length < bodyRows)
+            visible.push('');
+    }
+    return [...visible.map(line => borderedRow(boxWidth, borderFg, line)), panelBottomBorder(boxWidth, borderFg)].join('\n');
+}
+// ------------------------------------------------------------ tool summary --
+/**
+ * The tool header's subject word: the file path for read/write-style tools,
+ * the command's first word for cli-style tools ('git', 'python') — the first
+ * whitespace token of the highest-priority string argument (same key
+ * priority as callDetail's summary). '' when the arguments carry no usable
+ * string (the header then shows the bare tool name).
+ */
+export function toolSubject(rawArguments) {
+    const firstWord = (value) => value.trim().split(/\s+/u)[0] ?? '';
+    try {
+        const parsed = JSON.parse(rawArguments);
+        for (const key of ['command', 'file_path', 'path', 'query', 'url', 'pattern', 'description']) {
+            const value = parsed[key];
+            if (typeof value === 'string' && value.trim() !== '')
+                return firstWord(value);
+        }
+        for (const value of Object.values(parsed)) {
+            if (typeof value === 'string' && value.trim() !== '')
+                return firstWord(value);
+        }
+    }
+    catch {
+        // Model-controlled rawArguments; non-JSON yields no subject.
+    }
+    return '';
+}
+/** One-line summary of the call arguments, per common tool shape. */
+export function callDetail(rawArguments, limit = 120) {
+    try {
+        const parsed = JSON.parse(rawArguments);
+        const parts = [];
+        if (typeof parsed.command === 'string')
+            parts.push(`$ ${parsed.command}`);
+        if (typeof parsed.file_path === 'string')
+            parts.push(parsed.file_path);
+        if (typeof parsed.path === 'string' && parts.length === 0)
+            parts.push(parsed.path);
+        if (typeof parsed.pattern === 'string')
+            parts.push(`pattern: ${parsed.pattern}`);
+        if (typeof parsed.query === 'string')
+            parts.push(`query: ${parsed.query}`);
+        if (typeof parsed.url === 'string')
+            parts.push(parsed.url);
+        if (typeof parsed.description === 'string' && parts.length === 0)
+            parts.push(parsed.description);
+        if (parts.length === 0) {
+            const flat = rawArguments.replace(/\s+/g, ' ');
+            parts.push(flat);
+        }
+        const joined = parts.join('  ').replace(/\n/g, ' ⏎ ');
+        return clipToWidth(joined, limit);
+    }
+    catch {
+        return '';
+    }
+}
+/** First text content of a tool result, raw lines. */
+export function resultTextLines(content) {
+    for (const block of content) {
+        if (block.type === 'text' && block.text !== undefined) {
+            return block.text.replace(/\s+$/u, '').split('\n');
+        }
+    }
+    return [];
+}
+// ------------------------------------------------------------ panel pieces --
+/**
+ * Append `delta` to the bounded tail buffer, trimming whole head lines past
+ * THINK_TAIL_CAP (amortized O(1) per delta — the trim only fires when the
+ * buffer outgrows the cap, and each firing drops at least one whole line).
+ */
+function boundTail(buffer, delta) {
+    let next = buffer + delta;
+    while (next.length > THINK_TAIL_CAP) {
+        const nl = next.indexOf('\n');
+        if (nl === -1) {
+            next = next.slice(-Math.floor(THINK_TAIL_CAP / 2));
+            break;
+        }
+        next = next.slice(nl + 1);
+    }
+    return next;
+}
+/**
+ * Assemble one borderless status row from plain pieces: identifier, meta
+ * (elapsed), and an optional ` · <tail>` suffix. The tail gets whatever the
+ * row has left and is truncated at the right edge (never wrapped); when the
+ * pieces do not fit even without a tail, the assembled plain row is clipped
+ * and returned in a single muted style so no styled segment can push past
+ * the width. Pieces are styled only after every clip — the repo rule.
+ */
+function statusRow(width, theme, id, meta, tail, idStyle) {
+    const p = theme.palette;
+    const subtle = (text) => ansiFg(p.fgSubtle) + text + RESET;
+    const muted = (text) => ansiFg(p.fgMuted) + text + RESET;
+    const idW = visibleWidth(id);
+    const metaW = visibleWidth(meta);
+    let tailText = '';
+    if (tail !== undefined && tail !== '') {
+        const tailBudget = width - idW - metaW - 3;
+        if (tailBudget >= 4)
+            tailText = ` · ${clipToWidth(tail, tailBudget - 3)}`;
+    }
+    const plain = id + meta + tailText;
+    if (visibleWidth(plain) > width) {
+        return muted(clipToWidth(plain, width));
+    }
+    return idStyle(id) + subtle(meta) + muted(tailText);
+}
+/** Panel background wrapper: prefixes the bg SGR, terminates with RESET. */
+function bgRow(bgPrefix, row) {
+    return bgPrefix + row + RESET;
+}
+// ------------------------------------------------------------- ThinkPanel --
+/**
+ * The live thinking panel: one fixed surface for the WHOLE run, refreshed in
+ * place by every reasoning delta. Visible while a reasoning burst streams
+ * (feed); hidden by the next phase event (text delta, tool call, message
+ * assembly, turn end — LiveWidgets.applyEvent drives those).
+ */
+export class ThinkPanel {
+    state;
+    height = DEFAULT_PANEL_HEIGHT;
+    getTheme;
+    constructor(getTheme) {
+        this.getTheme = getTheme;
+    }
+    invalidate() { }
+    /** Whether the panel currently has content (drives the live tick). */
+    isVisible() {
+        return this.state !== undefined;
+    }
+    setHeight(height) {
+        this.height = height;
+    }
+    /** One reasoning delta; the first delta of a burst opens the panel. */
+    feed(delta) {
+        if (delta === '')
+            return;
+        const state = this.state;
+        if (state === undefined) {
+            this.state = { startedAt: Date.now(), tail: boundTail('', delta) };
+        }
+        else {
+            state.tail = boundTail(state.tail, delta);
+        }
+    }
+    hide() {
+        this.state = undefined;
+    }
+    render(width) {
+        const state = this.state;
+        if (state === undefined)
+            return [];
+        const theme = this.getTheme();
+        const p = theme.palette;
+        const elapsed = `${((Date.now() - state.startedAt) / 1000).toFixed(1)}s`;
+        if (this.height === '1') {
+            const id = THINKING_HEADER;
+            const row = statusRow(width, theme, id, ` · ${elapsed}`, lastNonBlankLine(state.tail), text => `\x1b[3m${ansiFg(p.thinking)}${text}\x1b[23m`);
+            return [row];
+        }
+        // Boxed panel: top border + header + content rows + bottom border, every
+        // row on the thinking panel background.
+        const boxWidth = panelBoxWidth(width);
+        const borderFg = ansiFg(p.panelBorder);
+        const bgPrefix = ansiBg(p.thinkingPanelBg);
+        const bodyRows = this.height === 'all' ? 'all' : Number(this.height) - 1;
+        const thinkStyle = (text) => `\x1b[3m${ansiFg(p.thinking)}${text}\x1b[23m`;
+        const headerInner = thinkStyle(clipRow(`${THINKING_HEADER} · ${elapsed}`, width));
+        let lines = state.tail.trim().split('\n');
+        // Bounded live tail while streaming in 'all' mode — per-frame cost stays
+        // O(tail), never O(accumulated).
+        if (bodyRows === 'all' && lines.length > STREAMING_TAIL_LINES) {
+            lines = lines.slice(-STREAMING_TAIL_LINES);
+        }
+        const body = panelBodyText(lines.map(line => thinkStyle(clipRow(line, width))), boxWidth, borderFg, bodyRows);
+        return [
+            bgRow(bgPrefix, panelTopBorder(boxWidth, borderFg)),
+            bgRow(bgPrefix, borderedRow(boxWidth, borderFg, headerInner)),
+            ...body.split('\n').map(row => bgRow(bgPrefix, row)),
+        ];
+    }
+}
+/**
+ * The live tool panel: one fixed surface refreshed by every tool call — a
+ * new call replaces the tracked tool (sequential/parallel calls all refresh
+ * this same panel), a matching result settles it (icon/status/time freeze,
+ * body shows the result tail), and any later phase event hides it.
+ */
+export class ToolPanel {
+    state;
+    height = DEFAULT_PANEL_HEIGHT;
+    getTheme;
+    constructor(getTheme) {
+        this.getTheme = getTheme;
+    }
+    invalidate() { }
+    /** Whether the panel currently has content (drives the live tick). */
+    isVisible() {
+        return this.state !== undefined;
+    }
+    setHeight(height) {
+        this.height = height;
+    }
+    /** A new tool call: replaces the tracked tool with a pending one. */
+    begin(callId, name, rawArguments) {
+        const detail = callDetail(rawArguments);
+        this.state = {
+            callId,
+            name,
+            subject: toolSubject(rawArguments),
+            startedAt: Date.now(),
+            status: 'pending',
+            bodyLines: detail === '' ? [] : [detail],
+        };
+    }
+    /**
+     * Settle the tracked tool. Results for a callId other than the tracked
+     * one (parallel calls; a result racing a newer begin) are ignored.
+     * @returns whether the tracked tool settled.
+     */
+    settle(callId, data) {
+        const state = this.state;
+        if (state === undefined || state.callId !== callId || state.status !== 'pending')
+            return false;
+        const isError = data.error !== undefined || (data.block?.isError ?? false);
+        state.status = isError ? 'error' : 'success';
+        state.endedAt = Date.now();
+        const body = [...state.bodyLines];
+        if (data.error !== undefined) {
+            body.push(`${data.error.name}: ${data.error.code ?? ''}`.replace(/: $/, ''));
+        }
+        if (data.block !== undefined) {
+            for (const line of resultTextLines(data.block.content))
+                body.push(line);
+        }
+        state.bodyLines = body;
+        return true;
+    }
+    hide() {
+        this.state = undefined;
+    }
+    render(width) {
+        const state = this.state;
+        if (state === undefined)
+            return [];
+        const theme = this.getTheme();
+        const p = theme.palette;
+        const icon = state.status === 'pending' ? '⚙' : state.status === 'success' ? '✔' : '✘';
+        const statusColor = state.status === 'pending'
+            ? p.fgMuted
+            : state.status === 'success' ? p.success : p.danger;
+        const end = state.endedAt ?? Date.now();
+        const elapsed = `${((end - state.startedAt) / 1000).toFixed(1)}s`;
+        const idPlain = clipRow(state.subject === '' ? state.name : `${state.name} ${state.subject}`, width, 2);
+        if (this.height === '1') {
+            const row = statusRow(width, theme, `${icon} ${idPlain}`, ` · ${elapsed}`, lastNonBlankLine(state.bodyLines.join('\n')), text => ansiFg(statusColor) + text + RESET);
+            return [row];
+        }
+        // Boxed panel: top border + status-colored header + body tail + bottom
+        // border, on the pending/success/error tool surface.
+        const boxWidth = panelBoxWidth(width);
+        const borderFg = ansiFg(p.panelBorder);
+        const bg = state.status === 'pending'
+            ? p.toolPanelBg
+            : state.status === 'success' ? p.successMuted : p.dangerMuted;
+        const bgPrefix = ansiBg(bg);
+        const bodyRows = this.height === 'all' ? 'all' : Number(this.height) - 1;
+        const headerText = state.subject === '' ? `${state.name} · ${elapsed}` : `${state.name} ${state.subject} · ${elapsed}`;
+        const headerInner = ansiFg(statusColor) + `${icon} ${clipRow(headerText, width, 2)}`;
+        // Body tail + drop marker at the row budget ('all' keeps up to
+        // ALL_TOOL_RESULT_LINES rows); the marker replaces the first visible row.
+        const cap = bodyRows === 'all' ? ALL_TOOL_RESULT_LINES : bodyRows;
+        let lines = state.bodyLines;
+        let marker = false;
+        if (lines.length > cap) {
+            const dropped = lines.length - cap;
+            lines = lines.slice(-cap);
+            lines[0] = `… (+${dropped} lines)`;
+            marker = true;
+        }
+        const styled = lines.map((line, i) => ansiFg(marker && i === 0 ? p.fgSubtle : p.fgMuted) + `  ${clipRow(line, width, 2)}`);
+        const body = panelBodyText(styled, boxWidth, borderFg, bodyRows);
+        return [
+            bgRow(bgPrefix, panelTopBorder(boxWidth, borderFg)),
+            bgRow(bgPrefix, borderedRow(boxWidth, borderFg, headerInner)),
+            ...body.split('\n').map(row => bgRow(bgPrefix, row)),
+        ];
+    }
+}
+//# sourceMappingURL=activity.js.map