@hheei/pi-ext-ui 0.0.0-stage → 0.2.0

package/dist/tool-view.d.ts

@@ -0,0 +1,100 @@
+import { type Theme } from "@earendil-works/pi-coding-agent";
+import { type Component, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";
+export type FoldLevel = 0 | 1 | 2;
+export type ToolStatusKind = "streaming" | "running" | "ok" | "warn" | "error" | "none";
+export type RailColorToken = "muted" | "dim" | "accent" | "success" | "warning" | "error";
+export interface RailSection {
+    readonly railToken: RailColorToken;
+    readonly content: string | readonly string[] | Component;
+    readonly maxLines?: number | undefined;
+}
+export interface ToolViewHeaderSpec {
+    readonly title: string;
+    readonly status?: ToolStatusKind | undefined;
+    readonly summary?: string | undefined;
+    readonly unstyledSummary?: boolean | undefined;
+}
+export interface ToolViewCopySpec {
+    readonly primary: string;
+    readonly full?: string | undefined;
+}
+/** Micro-contract for child views that can reset their internal expansion. */
+export interface Collapsible {
+    collapseAll(): void;
+}
+export declare function isCollapsible(value: unknown): value is Collapsible;
+export interface ToolViewSpec {
+    readonly theme: Theme;
+    readonly header: ToolViewHeaderSpec;
+    readonly collapsedRows?: readonly string[] | Component | (Component & Collapsible) | undefined;
+    readonly sections?: readonly RailSection[] | undefined;
+    readonly collapsibleChildren?: readonly Collapsible[] | undefined;
+    readonly copy?: ToolViewCopySpec | undefined;
+    readonly stateHolder?: unknown;
+    readonly outputPad?: number | undefined;
+    readonly defaultLevel?: FoldLevel | undefined;
+    readonly controlledLevel?: FoldLevel | undefined;
+    readonly globalExpanded?: boolean | undefined;
+    readonly invalidate?: (() => void) | undefined;
+    readonly copyToClipboard?: ((text: string) => Promise<void>) | undefined;
+    readonly copyFeedbackDurationMs?: number | undefined;
+    readonly noRail?: boolean | undefined;
+    readonly railToken?: RailColorToken | undefined;
+}
+/** Public composition entry point for extensions that need the shared view behavior. */
+export declare function createToolView(spec: ToolViewSpec): ToolView;
+export declare function transitionFoldLevel(current: FoldLevel, ctrlKey: boolean): FoldLevel;
+export declare function formatStatusGlyph(status: ToolStatusKind | undefined, theme: Theme): string;
+/**
+ * The glyph, name, and summary of one tool execution, colored the way every tool row colors them.
+ *
+ * A container tool draws one of these per child call, and so does the row of a tool that ran on its
+ * own. Both must agree, so the token assignment lives here rather than in each board: a board that
+ * assembled its own row painted the child's summary as a title, which read as one bright run and
+ * made a nested call look unlike the same call at top level. The caller owns the fold pin, the
+ * right-aligned action, and the width budget, which are the parts that actually differ.
+ */
+export declare function formatToolHeaderText(parts: {
+    readonly status?: ToolStatusKind | undefined;
+    readonly title: string;
+    readonly summary?: string | undefined;
+    readonly unstyledSummary?: boolean | undefined;
+}, theme: Theme): string;
+/**
+ * Collapses text that must occupy one row: header titles and summaries, board rows, and inline
+ * labels. A break inside one of them is a contract violation, because Pi writes one array element
+ * as one terminal row: `\n` moves to the next row without clearing it, and a lone `\r` returns to
+ * column 0 so later text overwrites the row's start. `visibleWidth` counts both as zero-width, so
+ * the host's per-row width guard cannot catch either, and the frame would silently grow taller
+ * than the rows it reports.
+ */
+export declare function toSingleRow(text: string): string;
+/**
+ * Splits multi-line content into rows. A lone `\r` is dropped rather than treated as a break so
+ * CRLF and progress-style output stay cell-safe, and tabs expand to two spaces so indentation does
+ * not depend on the terminal's tab stops.
+ */
+export declare function toContentRows(text: string): readonly string[];
+export declare class ToolView implements Component {
+    #private;
+    constructor(spec: ToolViewSpec);
+    get foldLevel(): FoldLevel;
+    get effectiveLevel(): FoldLevel;
+    get collapsed(): boolean;
+    setFoldLevel(next: FoldLevel): void;
+    setCollapsed(collapsed: boolean): void;
+    toggle(ctrlKey?: boolean): void;
+    /** The result renderer of the same tool execution hides this row in place. */
+    hide(): void;
+    /**
+     * Renders only the interior content of the view without the header row.
+     * When `noRail: true` is specified, outer rail glyphs are omitted, allowing
+     * clean embedding inside composite parent components without regex text scraping.
+     */
+    renderBody(width: number, options?: {
+        noRail?: boolean;
+    }): string[];
+    render(width: number): string[];
+    handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined;
+    invalidate(): void;
+}

package/dist/tool-view.js

@@ -0,0 +1,424 @@
+import { copyToClipboard as copyToSystemClipboard, } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth, } from "@earendil-works/pi-tui";
+export function isCollapsible(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "collapseAll" in value &&
+        typeof value.collapseAll === "function");
+}
+/** Public composition entry point for extensions that need the shared view behavior. */
+export function createToolView(spec) {
+    return new ToolView(spec);
+}
+const FOLD_LEVEL_STATE_KEY = "__piExtUiFoldLevel";
+const COPIED_UNTIL_STATE_KEY = "__piExtUiCopiedUntil";
+const COPY_FEEDBACK_TIMER_KEY = "__piExtUiCopyTimer";
+const DEFAULT_MAX_SECTION_LINES = 9;
+const DEFAULT_COPY_FEEDBACK_MS = 1200;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function transitionFoldLevel(current, ctrlKey) {
+    if (current === 0) {
+        return ctrlKey ? 2 : 1;
+    }
+    if (current === 1) {
+        return ctrlKey ? 2 : 0;
+    }
+    return 0;
+}
+function readFoldLevel(stateHolder, fallback) {
+    if (!isRecord(stateHolder))
+        return fallback;
+    const raw = stateHolder[FOLD_LEVEL_STATE_KEY];
+    return raw === 0 || raw === 1 || raw === 2 ? raw : fallback;
+}
+function writeFoldLevel(stateHolder, level) {
+    if (!isRecord(stateHolder))
+        return;
+    stateHolder[FOLD_LEVEL_STATE_KEY] = level;
+}
+function isCopiedActive(stateHolder, localCopiedUntil) {
+    const now = Date.now();
+    if (localCopiedUntil > now)
+        return true;
+    if (!isRecord(stateHolder))
+        return false;
+    const until = stateHolder[COPIED_UNTIL_STATE_KEY];
+    return typeof until === "number" && until > now;
+}
+export function formatStatusGlyph(status, theme) {
+    switch (status ?? "ok") {
+        case "streaming":
+            return theme.fg("muted", "⋯");
+        case "running":
+            return theme.fg("accent", "◐");
+        case "ok":
+            return theme.fg("success", "✓");
+        case "warn":
+            return theme.fg("warning", "!");
+        case "error":
+            return theme.fg("error", "✗");
+        case "none":
+            return "";
+    }
+}
+/**
+ * The glyph, name, and summary of one tool execution, colored the way every tool row colors them.
+ *
+ * A container tool draws one of these per child call, and so does the row of a tool that ran on its
+ * own. Both must agree, so the token assignment lives here rather than in each board: a board that
+ * assembled its own row painted the child's summary as a title, which read as one bright run and
+ * made a nested call look unlike the same call at top level. The caller owns the fold pin, the
+ * right-aligned action, and the width budget, which are the parts that actually differ.
+ */
+export function formatToolHeaderText(parts, theme) {
+    const statusPart = formatStatusGlyph(parts.status, theme);
+    const title = toSingleRow(parts.title);
+    const titlePart = theme.fg("toolTitle", theme.bold(title));
+    const summaryRaw = parts.summary === undefined ? "" : toSingleRow(parts.summary);
+    const isUnstyled = parts.unstyledSummary === true || title === "bash";
+    const summaryPart = summaryRaw === "" ? "" : isUnstyled ? ` ${summaryRaw}` : ` ${theme.fg("dim", summaryRaw)}`;
+    return `${statusPart === "" ? "" : `${statusPart} `}${titlePart}${summaryPart}`;
+}
+const truncate = (text, width) => truncateToWidth(text, width, "…");
+/**
+ * Collapses text that must occupy one row: header titles and summaries, board rows, and inline
+ * labels. A break inside one of them is a contract violation, because Pi writes one array element
+ * as one terminal row: `\n` moves to the next row without clearing it, and a lone `\r` returns to
+ * column 0 so later text overwrites the row's start. `visibleWidth` counts both as zero-width, so
+ * the host's per-row width guard cannot catch either, and the frame would silently grow taller
+ * than the rows it reports.
+ */
+export function toSingleRow(text) {
+    if (!text.includes("\r") && !text.includes("\n") && !text.includes("\t")) {
+        return text.trim();
+    }
+    return text.replace(/[\r\n\t]+/g, " ").trim();
+}
+/**
+ * Splits multi-line content into rows. A lone `\r` is dropped rather than treated as a break so
+ * CRLF and progress-style output stay cell-safe, and tabs expand to two spaces so indentation does
+ * not depend on the terminal's tab stops.
+ */
+export function toContentRows(text) {
+    if (!text.includes("\r") && !text.includes("\t") && !text.includes("\n")) {
+        return [text];
+    }
+    return text.replace(/\r/g, "").replace(/\t/g, "  ").split("\n");
+}
+/**
+ * Resolves a row source into rows that are safe to hand to the host. A string element is one
+ * caller-provided label, so `normalize` decides whether it stays a single row or becomes several. A
+ * component returns rows it already laid out, so only its breaks are removed and its indentation is
+ * preserved.
+ */
+function resolveRows(source, width, normalize) {
+    if (typeof source === "string") {
+        return source === "" ? [] : normalize(source);
+    }
+    if (Array.isArray(source)) {
+        return source.flatMap((item) => (typeof item === "string" ? normalize(item) : []));
+    }
+    return source.render(width).flatMap((row) => toContentRows(row));
+}
+export class ToolView {
+    #spec;
+    #localLevel;
+    #localCopiedUntil = 0;
+    #localTimer;
+    #lastWidth = 80;
+    #lastHeight = 0;
+    #cache;
+    constructor(spec) {
+        this.#spec = spec;
+        const initial = spec.controlledLevel ?? spec.defaultLevel ?? 0;
+        this.#localLevel =
+            spec.controlledLevel !== undefined
+                ? spec.controlledLevel
+                : readFoldLevel(spec.stateHolder, initial);
+        if (isRecord(spec.stateHolder)) {
+            const until = spec.stateHolder[COPIED_UNTIL_STATE_KEY];
+            if (typeof until === "number" && until > Date.now()) {
+                this.#localCopiedUntil = until;
+                const remaining = until - Date.now();
+                if (!spec.stateHolder[COPY_FEEDBACK_TIMER_KEY]) {
+                    const timer = setTimeout(() => {
+                        this.#localCopiedUntil = 0;
+                        if (isRecord(this.#spec.stateHolder)) {
+                            this.#spec.stateHolder[COPIED_UNTIL_STATE_KEY] = 0;
+                            this.#spec.stateHolder[COPY_FEEDBACK_TIMER_KEY] = undefined;
+                        }
+                        this.#localTimer = undefined;
+                        this.#cache = undefined;
+                        this.#spec.invalidate?.();
+                    }, remaining);
+                    timer.unref?.();
+                    this.#localTimer = timer;
+                    spec.stateHolder[COPY_FEEDBACK_TIMER_KEY] = timer;
+                }
+            }
+        }
+    }
+    get foldLevel() {
+        if (this.#spec.controlledLevel !== undefined) {
+            return this.#spec.controlledLevel;
+        }
+        return readFoldLevel(this.#spec.stateHolder, this.#localLevel);
+    }
+    get effectiveLevel() {
+        const base = this.foldLevel;
+        if (base === 0)
+            return 0;
+        if (this.#spec.globalExpanded === true)
+            return 2;
+        return base;
+    }
+    get collapsed() {
+        return this.foldLevel === 0;
+    }
+    #collapseChildren() {
+        const { collapsedRows, collapsibleChildren } = this.#spec;
+        if (collapsibleChildren !== undefined) {
+            for (const child of collapsibleChildren) {
+                child.collapseAll();
+            }
+        }
+        if (isCollapsible(collapsedRows)) {
+            collapsedRows.collapseAll();
+        }
+    }
+    setFoldLevel(next) {
+        const prev = this.foldLevel;
+        this.#localLevel = next;
+        if (this.#spec.controlledLevel === undefined) {
+            writeFoldLevel(this.#spec.stateHolder, next);
+        }
+        if (prev !== next) {
+            this.#cache = undefined;
+            this.#collapseChildren();
+            this.#spec.invalidate?.();
+        }
+    }
+    setCollapsed(collapsed) {
+        this.setFoldLevel(collapsed ? 0 : 1);
+    }
+    toggle(ctrlKey = false) {
+        this.setFoldLevel(transitionFoldLevel(this.foldLevel, ctrlKey));
+    }
+    #triggerCopy(shiftKey) {
+        const copySpec = this.#spec.copy;
+        if (copySpec === undefined)
+            return;
+        const payload = shiftKey && copySpec.full !== undefined && copySpec.full !== ""
+            ? copySpec.full
+            : copySpec.primary;
+        const writeClip = this.#spec.copyToClipboard ?? copyToSystemClipboard;
+        const durationMs = this.#spec.copyFeedbackDurationMs ?? DEFAULT_COPY_FEEDBACK_MS;
+        const until = Date.now() + durationMs;
+        this.#localCopiedUntil = until;
+        if (isRecord(this.#spec.stateHolder)) {
+            const prevTimer = this.#spec.stateHolder[COPY_FEEDBACK_TIMER_KEY];
+            if (prevTimer !== undefined) {
+                clearTimeout(prevTimer);
+            }
+            this.#spec.stateHolder[COPIED_UNTIL_STATE_KEY] = until;
+        }
+        if (this.#localTimer !== undefined) {
+            clearTimeout(this.#localTimer);
+        }
+        void writeClip(payload).catch(() => { });
+        this.#spec.invalidate?.();
+        const timer = setTimeout(() => {
+            this.#localCopiedUntil = 0;
+            if (isRecord(this.#spec.stateHolder)) {
+                this.#spec.stateHolder[COPIED_UNTIL_STATE_KEY] = 0;
+                this.#spec.stateHolder[COPY_FEEDBACK_TIMER_KEY] = undefined;
+            }
+            this.#localTimer = undefined;
+            this.#cache = undefined;
+            this.#spec.invalidate?.();
+        }, durationMs);
+        timer.unref?.();
+        this.#localTimer = timer;
+        if (isRecord(this.#spec.stateHolder)) {
+            this.#spec.stateHolder[COPY_FEEDBACK_TIMER_KEY] = timer;
+        }
+    }
+    #renderHeader(width, level) {
+        const { theme, header, copy } = this.#spec;
+        const safeWidth = Math.max(1, width);
+        const pinGlyph = level === 0 ? "▸" : "▾";
+        const pin = theme.fg("dim", pinGlyph);
+        const leftContent = `${pin} ${formatToolHeaderText(header, theme)}`;
+        if (copy === undefined || safeWidth < 6) {
+            return truncate(leftContent, safeWidth);
+        }
+        const copied = isCopiedActive(this.#spec.stateHolder, this.#localCopiedUntil);
+        const copyIcon = copied ? theme.fg("success", "✓") : theme.fg("dim", "󰆏");
+        // Leave 1 column on the right for Pi's fullscreen scrollbar so the copy icon doesn't collide
+        const rightMargin = 1;
+        const copySlotWidth = 2 + rightMargin;
+        const maxLeftWidth = Math.max(1, safeWidth - copySlotWidth);
+        const truncatedLeft = truncate(leftContent, maxLeftWidth);
+        const leftVis = visibleWidth(truncatedLeft);
+        const gap = " ".repeat(Math.max(1, safeWidth - leftVis - rightMargin - 1));
+        return truncate(truncatedLeft + gap + copyIcon + " ".repeat(rightMargin), safeWidth);
+    }
+    #hidden = false;
+    /** The result renderer of the same tool execution hides this row in place. */
+    hide() {
+        this.#hidden = true;
+        this.#cache = undefined;
+    }
+    /**
+     * Renders only the interior content of the view without the header row.
+     * When `noRail: true` is specified, outer rail glyphs are omitted, allowing
+     * clean embedding inside composite parent components without regex text scraping.
+     */
+    renderBody(width, options) {
+        if (this.#hidden)
+            return [];
+        const pad = Math.max(0, this.#spec.outputPad ?? 0);
+        const safeWidth = Math.max(1, width - pad * 2);
+        const level = this.effectiveLevel;
+        const { theme, collapsedRows, sections } = this.#spec;
+        const noRail = options?.noRail ?? this.#spec.noRail ?? false;
+        const innerWidth = noRail ? safeWidth : Math.max(1, safeWidth - 2);
+        const output = [];
+        if (level === 0) {
+            if (collapsedRows !== undefined) {
+                const railColor = this.#spec.header.status === "error" ? "error" : "dim";
+                const rail = noRail ? "" : `${theme.fg(railColor, "▎")} `;
+                const rows = resolveRows(collapsedRows, innerWidth, (row) => [toSingleRow(row)]);
+                for (const row of rows) {
+                    output.push(truncate(rail + row, safeWidth));
+                }
+            }
+            return output;
+        }
+        if (sections === undefined || sections.length === 0) {
+            return output;
+        }
+        for (const section of sections) {
+            const rail = noRail ? "" : `${theme.fg(section.railToken, "▎")} `;
+            const rawLines = resolveRows(section.content, innerWidth, toContentRows);
+            const cap = level === 1 ? (section.maxLines ?? DEFAULT_MAX_SECTION_LINES) : Number.POSITIVE_INFINITY;
+            const visibleLines = Number.isFinite(cap) && rawLines.length > cap ? rawLines.slice(0, cap) : rawLines;
+            const omittedCount = rawLines.length - visibleLines.length;
+            for (const line of visibleLines) {
+                output.push(truncate(rail + line, safeWidth));
+            }
+            if (omittedCount > 0) {
+                const hint = theme.fg("dim", `… (${String(omittedCount)} more lines)`);
+                output.push(truncate(rail + hint, safeWidth));
+            }
+        }
+        return output;
+    }
+    render(width) {
+        if (this.#hidden)
+            return [];
+        const level = this.effectiveLevel;
+        const copied = isCopiedActive(this.#spec.stateHolder, this.#localCopiedUntil);
+        if (this.#cache !== undefined &&
+            this.#cache.width === width &&
+            this.#cache.level === level &&
+            this.#cache.copied === copied) {
+            return this.#cache.lines;
+        }
+        const pad = Math.max(0, this.#spec.outputPad ?? 0);
+        const safeWidth = Math.max(1, width - pad * 2);
+        this.#lastWidth = width;
+        if (level !== 0) {
+            this.#collapseChildren();
+        }
+        const rawLines = [this.#renderHeader(safeWidth, level), ...this.renderBody(width)];
+        const safeLines = [];
+        const leftPad = pad > 0 ? " ".repeat(pad) : "";
+        for (const rawLine of rawLines) {
+            if (rawLine.includes("\r") || rawLine.includes("\n")) {
+                for (const line of toContentRows(rawLine)) {
+                    const truncated = truncate(line, safeWidth);
+                    safeLines.push(leftPad !== "" ? `${leftPad}${truncated}` : truncated);
+                }
+            }
+            else {
+                safeLines.push(leftPad !== "" ? `${leftPad}${rawLine}` : rawLine);
+            }
+        }
+        this.#lastHeight = safeLines.length;
+        this.#cache = { width, level, copied, lines: safeLines };
+        return safeLines;
+    }
+    handleMouse(event) {
+        if (event.type === "wheel" || this.#hidden) {
+            return undefined;
+        }
+        if (event.type !== "click" || event.button !== "left") {
+            return undefined;
+        }
+        const effectiveWidth = event.width > 0 ? event.width : this.#lastWidth;
+        const pad = Math.max(0, this.#spec.outputPad ?? 0);
+        const innerX = event.x - pad;
+        const innerWidth = Math.max(1, effectiveWidth - pad * 2);
+        if (innerX < 0 || innerX >= innerWidth) {
+            return undefined;
+        }
+        // The last render's row count bounds the clickable area; a view that has not rendered yet has no
+        // extent to test against, and Pi always renders before it dispatches a mouse event.
+        if (this.#lastHeight > 0 && (event.y < 0 || event.y >= this.#lastHeight)) {
+            return undefined;
+        }
+        if (event.y === 0) {
+            if (this.#spec.copy !== undefined &&
+                innerWidth >= 6 &&
+                innerX >= innerWidth - 3 &&
+                innerX < innerWidth) {
+                this.#triggerCopy(event.shift === true);
+                return { handled: true, render: true };
+            }
+            this.toggle(event.ctrl === true);
+            return { handled: true, render: true };
+        }
+        const level = this.effectiveLevel;
+        if (level === 0 && this.#spec.collapsedRows !== undefined) {
+            const rows = this.#spec.collapsedRows;
+            if (typeof rows === "object" &&
+                rows !== null &&
+                "handleMouse" in rows &&
+                typeof rows.handleMouse === "function") {
+                const handler = rows.handleMouse;
+                const railOffset = this.#spec.noRail ? 0 : 2;
+                const subEvent = {
+                    ...event,
+                    y: event.y - 1,
+                    x: Math.max(0, innerX - railOffset),
+                    width: Math.max(1, innerWidth - railOffset),
+                };
+                const res = handler.call(rows, subEvent);
+                if (res?.handled) {
+                    this.#cache = undefined;
+                    return res;
+                }
+            }
+        }
+        return { handled: true };
+    }
+    invalidate() {
+        this.#cache = undefined;
+        const { collapsedRows, sections } = this.#spec;
+        if (collapsedRows !== undefined &&
+            typeof collapsedRows === "object" &&
+            "invalidate" in collapsedRows) {
+            collapsedRows.invalidate();
+        }
+        if (sections !== undefined) {
+            for (const section of sections) {
+                if (typeof section.content === "object" && "invalidate" in section.content) {
+                    section.content.invalidate();
+                }
+            }
+        }
+    }
+}

package/dist/tracker.d.ts

@@ -0,0 +1,26 @@
+import type { AgentToolResult } from "@earendil-works/pi-coding-agent";
+export interface CapturedToolCall {
+    readonly id: string;
+    readonly toolName: string;
+    readonly args?: unknown;
+    readonly result?: AgentToolResult<unknown> | undefined;
+    readonly isError?: boolean | undefined;
+    readonly durationMs?: number | undefined;
+    readonly cost?: number | undefined;
+}
+export declare function recordToolExecutionStart(event: {
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+    parentToolCallId?: string | undefined;
+}): void;
+export declare function recordToolExecutionEnd(event: {
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    isError: boolean;
+    durationMs?: number | undefined;
+    parentToolCallId?: string | undefined;
+}): void;
+export declare function getCapturedNestedCalls(parentToolCallId: string | undefined): readonly CapturedToolCall[] | undefined;
+export declare function clearCapturedNestedCalls(): void;

package/dist/tracker.js

@@ -0,0 +1,81 @@
+const capturedByParentId = new Map();
+const MAX_STORED_PARENTS = 200;
+const MAX_CAPTURED_PAYLOAD_CHARS = 32_768;
+function boundCapturedValue(val) {
+    if (typeof val === "string") {
+        return val.length > MAX_CAPTURED_PAYLOAD_CHARS
+            ? `${val.slice(0, MAX_CAPTURED_PAYLOAD_CHARS)}… (truncated)`
+            : val;
+    }
+    return val;
+}
+export function recordToolExecutionStart(event) {
+    if (!event.parentToolCallId)
+        return;
+    let list = capturedByParentId.get(event.parentToolCallId);
+    if (!list) {
+        if (capturedByParentId.size >= MAX_STORED_PARENTS) {
+            const firstKey = capturedByParentId.keys().next().value;
+            if (firstKey !== undefined)
+                capturedByParentId.delete(firstKey);
+        }
+        list = [];
+        capturedByParentId.set(event.parentToolCallId, list);
+    }
+    const idx = list.findIndex((c) => c.id === event.toolCallId);
+    const entry = {
+        id: event.toolCallId,
+        toolName: event.toolName,
+        args: boundCapturedValue(event.args),
+    };
+    if (idx >= 0) {
+        list[idx] = { ...list[idx], ...entry };
+    }
+    else {
+        list.push(entry);
+    }
+}
+export function recordToolExecutionEnd(event) {
+    if (!event.parentToolCallId)
+        return;
+    let list = capturedByParentId.get(event.parentToolCallId);
+    if (!list) {
+        if (capturedByParentId.size >= MAX_STORED_PARENTS) {
+            const firstKey = capturedByParentId.keys().next().value;
+            if (firstKey !== undefined)
+                capturedByParentId.delete(firstKey);
+        }
+        list = [];
+        capturedByParentId.set(event.parentToolCallId, list);
+    }
+    const idx = list.findIndex((c) => c.id === event.toolCallId);
+    const typedResult = event.result;
+    if (idx >= 0) {
+        const prev = list[idx];
+        if (!prev)
+            return;
+        list[idx] = {
+            ...prev,
+            result: typedResult,
+            isError: event.isError,
+            durationMs: event.durationMs,
+        };
+    }
+    else {
+        list.push({
+            id: event.toolCallId,
+            toolName: event.toolName,
+            result: typedResult,
+            isError: event.isError,
+            durationMs: event.durationMs,
+        });
+    }
+}
+export function getCapturedNestedCalls(parentToolCallId) {
+    if (!parentToolCallId)
+        return undefined;
+    return capturedByParentId.get(parentToolCallId);
+}
+export function clearCapturedNestedCalls() {
+    capturedByParentId.clear();
+}

package/dist/turn-copy.d.ts

@@ -0,0 +1,11 @@
+export interface TurnToolCallSummary {
+    readonly toolName: string;
+    readonly commandOrArgs?: string | undefined;
+    readonly summary: string;
+}
+export interface TurnFlowData {
+    readonly userPrompt: string;
+    readonly toolCalls?: readonly TurnToolCallSummary[] | undefined;
+    readonly assistantReply: string;
+}
+export declare function formatTurnFlow(data: TurnFlowData): string;

package/dist/turn-copy.js

@@ -0,0 +1,20 @@
+import { stripTerminalSequences } from "@earendil-works/pi-tui";
+export function formatTurnFlow(data) {
+    const blocks = [];
+    const cleanUser = stripTerminalSequences(data.userPrompt).trim();
+    blocks.push(`[User]\n${cleanUser}`);
+    if (data.toolCalls !== undefined && data.toolCalls.length > 0) {
+        const toolLines = [];
+        for (const call of data.toolCalls) {
+            const header = call.commandOrArgs !== undefined && call.commandOrArgs.trim() !== ""
+                ? `${call.toolName} ${stripTerminalSequences(call.commandOrArgs).trim()}`
+                : call.toolName;
+            const detail = stripTerminalSequences(call.summary).trim();
+            toolLines.push(detail !== "" ? `${header}\n${detail}` : header);
+        }
+        blocks.push(`[Tools]\n${toolLines.join("\n\n")}`);
+    }
+    const cleanAssistant = stripTerminalSequences(data.assistantReply).trim();
+    blocks.push(`[Assistant]\n${cleanAssistant}`);
+    return blocks.join("\n\n");
+}