@falkenslab/agent-kit 0.10.1

package/dist/tui/ink/sessionModel.d.ts

@@ -0,0 +1,85 @@
+import type { AgentEvent, SessionUsage } from "../../core/runner.js";
+import { type ConsoleRenderer } from "../consoleRenderer.js";
+import { type ToolPhrase } from "./toolGroup.js";
+export interface HistoryItem {
+    id: number;
+    text: string;
+    /** What it is: the view draws the human's lines as a bar, and the spacing follows it. */
+    kind?: OutputKind;
+    /** A folded group of tool calls: the lines it unfolds into with Ctrl+O. */
+    expanded?: string[];
+}
+/**
+ * What a block of output is: the human's line, the agent's words, a group of its tool
+ * calls, a notice (welcome, info, warnings), an error, or a note (header, checkpoints,
+ * the turn summary).
+ */
+export type OutputKind = "user" | "agent" | "action" | "notice" | "error" | "note";
+export interface SessionSnapshot {
+    /** Finished lines: in Ink's `<Static>` inline, in the scrollable history in full screen. */
+    items: HistoryItem[];
+    /** What is still being written, one or more lines: the reply in progress or the open tool group. */
+    live: string;
+    /** The live block starts a new kind of output: shown with a blank line above it. */
+    liveGap: boolean;
+    /** A turn is in flight. */
+    busy: boolean;
+    /** When the turn in flight started (ms), for the spinner's elapsed time. */
+    turnStartedAt: number | null;
+    /** Label of the main agent's latest action in this turn. */
+    activity: string | null;
+    /** Label of the latest action taken inside a subagent in this turn. */
+    subagentActivity: string | null;
+    /** Tool calls shown one by one with their results (the default); Ctrl+O folds them into a summary line. */
+    expanded: boolean;
+    turns: number;
+    usage: SessionUsage | null;
+    /** How full the context window is (0-100), after the latest turn; null until known. */
+    contextPercent: number | null;
+}
+export interface SessionModelOptions {
+    formatAction?: (toolName: string, toolInput: unknown) => string;
+    /** How a tool counts in a folded group's summary ("read 2 files"); built-in tools have their own. */
+    toolPhrase?: (toolName: string) => ToolPhrase | undefined;
+    agentLabel?: string;
+    /** Called with everything the console renderer writes, e.g. to mirror a session log. */
+    onWrite?: (text: string) => void;
+    /** Columns the live area may use (see liveWidth()); 80 if not given. */
+    width?: () => number;
+}
+/**
+ * Columns the live area may use: short of the edge, where the Windows console wraps early
+ * (see lineBuffer.ts). Read on every use, so a resized terminal is picked up.
+ */
+export declare function liveWidth(columns: number | undefined): number;
+export interface SessionModel {
+    /** The console renderer behind the session log, for writes that aren't events. */
+    renderer: ConsoleRenderer;
+    render(event: AgentEvent): void;
+    /** A line shown and passed to `onWrite` (the log), as the console would print it. */
+    writeLine(text: string, kind?: OutputKind): void;
+    /** Lines shown in the history but not passed to `onWrite` (the human's line, checkpoints, the header). */
+    note(text: string, kind?: OutputKind): void;
+    /** One blank line before what comes next (not logged), unless the history is empty or already ends on one. */
+    separate(): void;
+    startTurn(): void;
+    endTurn(): void;
+    /** Ctrl+O: folds or unfolds the tool groups. */
+    toggleExpanded(): void;
+    subscribe(listener: () => void): () => void;
+    getSnapshot(): SessionSnapshot;
+    /** The agent's text in the latest turn, plain (for /copy). */
+    lastReply(): string;
+    setContextPercent(percent: number | null): void;
+}
+/**
+ * The state behind the Ink views, in the look of the Claude Code CLI: the agent's words
+ * behind a `●` with their markdown rendered, consecutive tool calls folded into one summary
+ * line (unfolded with Ctrl+O into `●` calls with `⎿` results), a summary when a turn ends,
+ * and one blank line between blocks of different kinds.
+ *
+ * The screen is built from the events here; the session log still comes from
+ * `createConsoleRenderer()` through `onWrite`, so it reads exactly as the plain console
+ * (and runChatTui()) would print it.
+ */
+export declare function createSessionModel(options?: SessionModelOptions): SessionModel;

package/dist/tui/ink/sessionModel.js

@@ -0,0 +1,262 @@
+import { createFriendlyToolLabel } from "../../core/toolLabels.js";
+import { createConsoleRenderer } from "../consoleRenderer.js";
+import { fitWidth, stripAnsi } from "./lineBuffer.js";
+import { finishedLength, renderMarkdown } from "./markdown.js";
+import { toolGroupExpanded, toolGroupSummary } from "./toolGroup.js";
+import * as ui from "../ui.js";
+/**
+ * Columns the live area may use: short of the edge, where the Windows console wraps early
+ * (see lineBuffer.ts). Read on every use, so a resized terminal is picked up.
+ */
+export function liveWidth(columns) {
+    return Math.max(1, (columns || 80) - 4);
+}
+// The reply in progress keeps at most this many rows live; older ones go to the history.
+const LIVE_ROWS = 6;
+const BULLET = "● ";
+const INDENT = "  ";
+const isBlank = (line) => stripAnsi(line).trim() === "";
+/**
+ * The state behind the Ink views, in the look of the Claude Code CLI: the agent's words
+ * behind a `●` with their markdown rendered, consecutive tool calls folded into one summary
+ * line (unfolded with Ctrl+O into `●` calls with `⎿` results), a summary when a turn ends,
+ * and one blank line between blocks of different kinds.
+ *
+ * The screen is built from the events here; the session log still comes from
+ * `createConsoleRenderer()` through `onWrite`, so it reads exactly as the plain console
+ * (and runChatTui()) would print it.
+ */
+export function createSessionModel(options = {}) {
+    const formatAction = options.formatAction ?? createFriendlyToolLabel();
+    const width = () => Math.max(20, options.width?.() ?? 80);
+    const listeners = new Set();
+    let nextId = 0;
+    let snapshot = {
+        items: [],
+        live: "",
+        liveGap: false,
+        busy: false,
+        turnStartedAt: null,
+        activity: null,
+        subagentActivity: null,
+        expanded: true,
+        turns: 0,
+        usage: null,
+        contextPercent: null,
+    };
+    function update(changes) {
+        snapshot = { ...snapshot, ...changes };
+        for (const listener of listeners)
+            listener();
+    }
+    // The session log: the console renderer's text, never shown here.
+    const renderer = createConsoleRenderer({ formatAction, agentLabel: options.agentLabel, output: () => { }, onWrite: options.onWrite });
+    let lastKind = null;
+    // A blank line asked for by `separate()`, not yet in the history. Ink's <Static> drops a
+    // render whose only new item is a blank line (confirmed with ink-testing-library), so a
+    // separator always goes into the history together with the line after it, and until then
+    // is drawn as a margin above the live area.
+    let gapPending = false;
+    let reply = "";
+    // The agent's text since its last tool call: `segmentDone` characters of it already
+    // rendered as finished blocks, plus `rowsCommitted` rows of the block still growing
+    // (moved out of the live area when it grew past LIVE_ROWS).
+    let segment = "";
+    let segmentDone = 0;
+    let rowsCommitted = 0;
+    let segmentShown = false;
+    let group = null;
+    function lastIsBlank(items) {
+        const last = items.at(-1);
+        return !last || isBlank(last.text);
+    }
+    /** Adds a block's lines, with a blank line before it when the kind of output changes. */
+    function push(lines, kind, extra = {}) {
+        const items = [...snapshot.items];
+        if (lines.length === 0)
+            return;
+        if ((gapPending || (lastKind !== null && kind !== lastKind)) && !lastIsBlank(items))
+            items.push({ id: nextId++, text: "" });
+        gapPending = false;
+        lines.forEach((text, i) => items.push({ id: nextId++, text, kind, ...(i === 0 ? extra : {}) }));
+        lastKind = kind;
+        snapshot = { ...snapshot, items };
+    }
+    function mdWidth() {
+        return width() - INDENT.length;
+    }
+    /** The reply's rows behind its bullet (the segment's first row) or indent (the rest). */
+    function decorate(rows) {
+        return rows.map((row) => {
+            if (isBlank(row))
+                return "";
+            const prefix = segmentShown ? INDENT : BULLET;
+            segmentShown = true;
+            return prefix + row;
+        });
+    }
+    /** Renders the finished part of the reply into the history; `final` flushes it all. */
+    function flushSegment(final) {
+        const done = final ? segment.length : finishedLength(segment);
+        if (done > segmentDone) {
+            const rows = renderMarkdown(segment.slice(segmentDone, done), mdWidth()).slice(rowsCommitted);
+            // A new block of the same reply is separated by a blank line; the rest of a block
+            // whose first rows are already in the history continues right under them.
+            const lead = segmentShown && rowsCommitted === 0 && rows.length > 0 ? [""] : [];
+            if (rows.some((row) => !isBlank(row)))
+                push([...lead, ...decorate(rows)], "agent");
+            segmentDone = done;
+            rowsCommitted = 0;
+        }
+        if (final) {
+            segment = "";
+            segmentDone = 0;
+            rowsCommitted = 0;
+            segmentShown = false;
+            return [];
+        }
+        const rest = segment.slice(segmentDone);
+        if (!rest.trim())
+            return [];
+        const rows = renderMarkdown(rest, mdWidth());
+        const overflow = rows.length - rowsCommitted - LIVE_ROWS;
+        if (overflow > 0) {
+            const lead = segmentShown && rowsCommitted === 0 ? [""] : [];
+            push([...lead, ...decorate(rows.slice(rowsCommitted, rowsCommitted + overflow))], "agent");
+            rowsCommitted += overflow;
+        }
+        // Live rows get their bullet/indent without marking the segment as shown yet.
+        const shown = segmentShown;
+        const live = decorate(rows.slice(rowsCommitted));
+        segmentShown = shown;
+        return live;
+    }
+    function closeGroup() {
+        if (!group)
+            return;
+        const calls = group;
+        group = null;
+        push([groupLine(calls)], "action", { expanded: toolGroupExpanded(calls, width()) });
+    }
+    function groupLine(calls) {
+        return INDENT + ui.dim(fitWidth(toolGroupSummary(calls, options.toolPhrase), width() - INDENT.length));
+    }
+    /** Ends whatever is open (the reply in progress, a tool group) into the history. */
+    function closeAll() {
+        flushSegment(true);
+        closeGroup();
+    }
+    /** Recomputes the live area from what is open. */
+    function refreshLive(liveRows = []) {
+        let rows = liveRows;
+        let kind = liveRows.length > 0 ? "agent" : null;
+        if (group) {
+            rows = snapshot.expanded ? toolGroupExpanded(group, width()) : [groupLine(group)];
+            kind = "action";
+        }
+        const live = rows.join("\n");
+        const liveGap = gapPending || (kind !== null && lastKind !== null && kind !== lastKind && !lastIsBlank(snapshot.items));
+        update({ live, liveGap });
+    }
+    return {
+        renderer,
+        render(event) {
+            renderer.render(event);
+            switch (event.type) {
+                case "text": {
+                    reply += event.text;
+                    closeGroup();
+                    segment += event.text;
+                    refreshLive(flushSegment(false));
+                    return;
+                }
+                case "action": {
+                    flushSegment(true);
+                    group ??= [];
+                    group.push({ id: event.toolUseId, label: formatAction(event.toolName, event.input), toolName: event.toolName, result: null });
+                    snapshot = { ...snapshot, activity: formatAction(event.toolName, event.input), subagentActivity: null };
+                    refreshLive();
+                    return;
+                }
+                case "tool-result": {
+                    const call = group?.find((c) => c.id === event.toolUseId);
+                    if (call)
+                        call.result = { isError: event.isError, text: event.text };
+                    refreshLive();
+                    return;
+                }
+                case "subagent-action": {
+                    const label = formatAction(event.toolName, event.input);
+                    const parent = group?.find((c) => c.id !== undefined && c.id === event.parentToolUseId);
+                    if (parent)
+                        parent.children = [...(parent.children ?? []), label];
+                    snapshot = { ...snapshot, subagentActivity: label };
+                    refreshLive();
+                    return;
+                }
+                case "mcp-error":
+                    closeAll();
+                    push([ui.warn(`Some MCP servers failed to connect: ${event.failedServers.join(", ")}`)], "notice");
+                    refreshLive();
+                    return;
+                case "info":
+                    closeAll();
+                    push([(event.level === "warning" ? ui.warn : ui.dim)(`(${event.text})`)], "notice");
+                    refreshLive();
+                    return;
+                case "turn-end":
+                    closeAll();
+                    if (event.failed && event.errorText)
+                        push([ui.error(event.errorText)], "error");
+                    snapshot = { ...snapshot, turns: snapshot.turns + 1, usage: event.usage ?? snapshot.usage };
+                    refreshLive();
+                    return;
+                case "prompt-suggestion":
+                    return;
+            }
+        },
+        writeLine(text, kind = "notice") {
+            closeAll();
+            renderer.writeLine(text);
+            push(text.split("\n"), kind);
+            refreshLive();
+        },
+        note(text, kind = "note") {
+            closeAll();
+            push(text.split("\n"), kind);
+            refreshLive();
+        },
+        separate() {
+            if (!lastIsBlank(snapshot.items))
+                gapPending = true;
+            refreshLive();
+        },
+        startTurn() {
+            reply = "";
+            renderer.startTurn();
+            update({ busy: true, turnStartedAt: Date.now(), activity: null, subagentActivity: null });
+        },
+        endTurn() {
+            closeAll();
+            renderer.endLine();
+            const started = snapshot.turnStartedAt;
+            if (started !== null) {
+                const seconds = Math.max(1, Math.round((Date.now() - started) / 1000));
+                push([ui.dim(`✻ Worked for ${seconds}s`)], "note");
+            }
+            snapshot = { ...snapshot, busy: false, turnStartedAt: null, activity: null, subagentActivity: null };
+            refreshLive();
+        },
+        toggleExpanded() {
+            snapshot = { ...snapshot, expanded: !snapshot.expanded };
+            refreshLive();
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        getSnapshot: () => snapshot,
+        lastReply: () => reply.trim(),
+        setContextPercent: (percent) => update({ contextPercent: percent }),
+    };
+}

package/dist/tui/ink/terminalCursor.d.ts

@@ -0,0 +1,32 @@
+import type { DOMElement } from "ink";
+/** Where the terminal's cursor goes: `column` columns right of where `node` starts. */
+export interface CursorTarget {
+    node: DOMElement;
+    column: number;
+}
+export interface CursorController {
+    /** The input to put the cursor in, or null to hide it (no input on screen). */
+    setTarget(target: CursorTarget | null): void;
+    /** The stream Ink must write to (see createCursorController()). */
+    stream: NodeJS.WriteStream;
+}
+/** Where `node` sits in the frame, from the laid-out Yoga tree (0-based column and row). */
+export declare function framePosition(node: DOMElement): {
+    x: number;
+    y: number;
+};
+/**
+ * The terminal's own cursor for the full-screen chat, so it looks like the terminal's (a
+ * bar in Windows Terminal's default profile, as in Claude Code) instead of a drawn block.
+ *
+ * Ink's `useCursor` doesn't fit a frame as tall as the terminal: that redraw path moves the
+ * cursor only when its position changes, and one row off. A full-screen frame always starts
+ * at the top-left corner, so after Ink writes, the cursor is moved to its absolute position.
+ * Ink writes through `stream`, which hides the cursor before every write: otherwise, between
+ * a frame (which leaves the cursor at its end) and the move, the terminal draws the cursor
+ * at the bottom too, and with the spinner redrawing ~12 times a second it shows in two
+ * places at once (seen on Windows Terminal).
+ */
+export declare function createCursorController(output: NodeJS.WriteStream): CursorController;
+/** Set by the full-screen chat; an input without it draws its own block cursor. */
+export declare const CursorContext: import("react").Context<CursorController | null>;

package/dist/tui/ink/terminalCursor.js

@@ -0,0 +1,68 @@
+import { createContext } from "react";
+const HIDE = "\x1b[?25l";
+const SHOW = "\x1b[?25h";
+/** Where `node` sits in the frame, from the laid-out Yoga tree (0-based column and row). */
+export function framePosition(node) {
+    let x = 0;
+    let y = 0;
+    for (let current = node; current; current = current.parentNode) {
+        x += current.yogaNode?.getComputedLeft() ?? 0;
+        y += current.yogaNode?.getComputedTop() ?? 0;
+    }
+    return { x: Math.round(x), y: Math.round(y) };
+}
+/**
+ * The terminal's own cursor for the full-screen chat, so it looks like the terminal's (a
+ * bar in Windows Terminal's default profile, as in Claude Code) instead of a drawn block.
+ *
+ * Ink's `useCursor` doesn't fit a frame as tall as the terminal: that redraw path moves the
+ * cursor only when its position changes, and one row off. A full-screen frame always starts
+ * at the top-left corner, so after Ink writes, the cursor is moved to its absolute position.
+ * Ink writes through `stream`, which hides the cursor before every write: otherwise, between
+ * a frame (which leaves the cursor at its end) and the move, the terminal draws the cursor
+ * at the bottom too, and with the spinner redrawing ~12 times a second it shows in two
+ * places at once (seen on Windows Terminal).
+ */
+export function createCursorController(output) {
+    let target = null;
+    let scheduled = false;
+    function place() {
+        scheduled = false;
+        if (!target)
+            return; // stays hidden
+        const { x, y } = framePosition(target.node);
+        output.write(`\x1b[${y + 1};${x + target.column + 1}H${SHOW}`);
+    }
+    function schedule() {
+        if (scheduled)
+            return;
+        scheduled = true;
+        // After the rest of Ink's writes for this frame, which are synchronous.
+        queueMicrotask(place);
+    }
+    const write = (chunk, ...rest) => {
+        const ok = output.write(typeof chunk === "string" ? HIDE + chunk : chunk, ...rest);
+        schedule();
+        return ok;
+    };
+    // Everything but write goes to the real stream (columns, rows, resize events, isTTY...).
+    const stream = new Proxy(output, {
+        get(real, property) {
+            if (property === "write")
+                return write;
+            const value = Reflect.get(real, property, real);
+            return typeof value === "function" ? value.bind(real) : value;
+        },
+    });
+    return {
+        setTarget(next) {
+            target = next;
+            if (!next)
+                output.write(HIDE);
+            schedule();
+        },
+        stream,
+    };
+}
+/** Set by the full-screen chat; an input without it draws its own block cursor. */
+export const CursorContext = createContext(null);

package/dist/tui/ink/terminalStatus.d.ts

@@ -0,0 +1,20 @@
+/** True when `input` is only focus reports, which must never reach an input as text. */
+export declare function isFocusReport(input: string): boolean;
+/** The focus state the reports in `input` leave: true (focused), false, or null if none. */
+export declare function focusFromReport(input: string): boolean | null;
+export interface TerminalStatus {
+    /** Title and focus reporting on; call once. */
+    start(): void;
+    turnStarted(): void;
+    turnEnded(): void;
+    setFocused(focused: boolean): void;
+    /** Everything back as it was (title cleared, taskbar cleared, focus reporting off). */
+    stop(): void;
+}
+/**
+ * Shows the chat's state outside it, through sequences Windows Terminal understands: the
+ * tab title ("✻ <name> — working…" during a turn), the taskbar button (indeterminate
+ * progress during a turn) and, when a turn ends while the window isn't focused, a paused
+ * (yellow) taskbar state until it's focused again.
+ */
+export declare function createTerminalStatus(write: (text: string) => void, name: string): TerminalStatus;

package/dist/tui/ink/terminalStatus.js

@@ -0,0 +1,55 @@
+// Focus reporting: the terminal sends ESC [ I / ESC [ O when the window gains/loses focus.
+const FOCUS_ON = "\x1b[?1004h";
+const FOCUS_OFF = "\x1b[?1004l";
+// eslint-disable-next-line no-control-regex -- \x1b is the ESC byte the report may start with
+const FOCUS_REPORT = /^(?:\x1b?\[[IO])+$/;
+/** OSC 0: the window/tab title. */
+const title = (text) => `\x1b]0;${text}\x07`;
+// OSC 9;4: Windows Terminal's taskbar progress: 0 clears it, 3 is indeterminate, 4 is paused
+// (yellow), used here as "needs attention".
+const PROGRESS_CLEAR = "\x1b]9;4;0;0\x07";
+const PROGRESS_BUSY = "\x1b]9;4;3;0\x07";
+const PROGRESS_ATTENTION = "\x1b]9;4;4;100\x07";
+/** True when `input` is only focus reports, which must never reach an input as text. */
+export function isFocusReport(input) {
+    return FOCUS_REPORT.test(input);
+}
+/** The focus state the reports in `input` leave: true (focused), false, or null if none. */
+export function focusFromReport(input) {
+    if (!isFocusReport(input))
+        return null;
+    return input.endsWith("[I");
+}
+/**
+ * Shows the chat's state outside it, through sequences Windows Terminal understands: the
+ * tab title ("✻ <name> — working…" during a turn), the taskbar button (indeterminate
+ * progress during a turn) and, when a turn ends while the window isn't focused, a paused
+ * (yellow) taskbar state until it's focused again.
+ */
+export function createTerminalStatus(write, name) {
+    let focused = true;
+    let needsAttention = false;
+    return {
+        start() {
+            write(FOCUS_ON + title(name));
+        },
+        turnStarted() {
+            needsAttention = false;
+            write(title(`✻ ${name} — working…`) + PROGRESS_BUSY);
+        },
+        turnEnded() {
+            needsAttention = !focused;
+            write(title(name) + (needsAttention ? PROGRESS_ATTENTION : PROGRESS_CLEAR));
+        },
+        setFocused(next) {
+            focused = next;
+            if (focused && needsAttention) {
+                needsAttention = false;
+                write(PROGRESS_CLEAR);
+            }
+        },
+        stop() {
+            write(FOCUS_OFF + PROGRESS_CLEAR + title(""));
+        },
+    };
+}

package/dist/tui/ink/toolGroup.d.ts

@@ -0,0 +1,36 @@
+export interface ToolCall {
+    id?: string;
+    toolName: string;
+    /** The friendly label (see toolLabels.ts), shown when the group is unfolded. */
+    label: string;
+    result: {
+        isError: boolean;
+        text: string;
+    } | null;
+    /** For a call that runs a subagent: the labels of the tool calls it made, in order. */
+    children?: string[];
+}
+/** How a tool counts in a group's summary: the phrase for one call and for several, "{n}" standing for the count. */
+export type ToolPhrase = [one: string, many: string];
+/**
+ * A folded group's one line, as in the Claude Code CLI: "Read 2 files, ran 1 shell
+ * command". Calls to the same kind of tool are counted together, in the order they first
+ * appear; tools with no phrase of their own (MCP tools, the consumer's) count as "tools",
+ * unless `phraseFor` gives one.
+ */
+export declare function toolGroupSummary(calls: readonly ToolCall[], phraseFor?: (toolName: string) => ToolPhrase | undefined): string;
+/**
+ * One line for a tool's result: its first line (in red if it failed) and how many more it
+ * had. `markdown`: the first line is rendered (a subagent's answer), so no "**" or
+ * backticks show.
+ */
+export declare function resultSummary(result: {
+    isError: boolean;
+    text: string;
+}, markdown?: boolean): string;
+/**
+ * The calls one by one: each behind a `●`, then after `⎿` the calls a subagent made (the
+ * latest few, dim) and the result in one line (a subagent's answer with its markdown
+ * rendered), or "…" while it runs.
+ */
+export declare function toolGroupExpanded(calls: readonly ToolCall[], width: number): string[];

package/dist/tui/ink/toolGroup.js

@@ -0,0 +1,77 @@
+import { fitWidth } from "./lineBuffer.js";
+import { renderMarkdown } from "./markdown.js";
+import * as ui from "../ui.js";
+// A subagent can make many calls; the latest ones are shown, the rest counted.
+const MAX_CHILDREN = 5;
+// Tools whose result is a subagent's answer, in markdown: its first line is rendered.
+const SUBAGENT_TOOLS = new Set(["Agent", "Task"]);
+const BUILT_IN = {
+    Read: ["read {n} file", "read {n} files"],
+    Write: ["wrote {n} file", "wrote {n} files"],
+    Edit: ["edited {n} file", "edited {n} files"],
+    Glob: ["listed files", "listed files {n} times"],
+    Grep: ["searched {n} time", "searched {n} times"],
+    Bash: ["ran {n} shell command", "ran {n} shell commands"],
+    WebSearch: ["searched the web", "searched the web {n} times"],
+    WebFetch: ["fetched {n} page", "fetched {n} pages"],
+    Skill: ["used {n} skill", "used {n} skills"],
+    Agent: ["ran {n} subagent", "ran {n} subagents"],
+    Task: ["ran {n} subagent", "ran {n} subagents"],
+};
+const OTHER = ["used {n} tool", "used {n} tools"];
+/**
+ * A folded group's one line, as in the Claude Code CLI: "Read 2 files, ran 1 shell
+ * command". Calls to the same kind of tool are counted together, in the order they first
+ * appear; tools with no phrase of their own (MCP tools, the consumer's) count as "tools",
+ * unless `phraseFor` gives one.
+ */
+export function toolGroupSummary(calls, phraseFor) {
+    // Counted by the phrase's text: a consumer's phraseFor() may return a new array each call.
+    const counts = new Map();
+    for (const call of calls) {
+        const phrase = phraseFor?.(call.toolName) ?? BUILT_IN[call.toolName] ?? OTHER;
+        const key = phrase.join("|");
+        const entry = counts.get(key) ?? { phrase, n: 0 };
+        entry.n++;
+        counts.set(key, entry);
+    }
+    const text = [...counts.values()].map(({ phrase: [one, many], n }) => (n === 1 ? one : many).replace("{n}", String(n))).join(", ");
+    return text.charAt(0).toUpperCase() + text.slice(1);
+}
+/**
+ * One line for a tool's result: its first line (in red if it failed) and how many more it
+ * had. `markdown`: the first line is rendered (a subagent's answer), so no "**" or
+ * backticks show.
+ */
+export function resultSummary(result, markdown = false) {
+    const lines = result.text.split("\n").filter((line) => line.trim() !== "");
+    if (lines.length === 0)
+        return result.isError ? ui.error("error") : ui.dim("(no output)");
+    const more = lines.length > 1 ? ui.dim(` (+${lines.length - 1} ${lines.length === 2 ? "line" : "lines"})`) : "";
+    const first = lines[0].trim();
+    if (result.isError)
+        return ui.error(first) + more;
+    // Rendered wide, as one row: the summary line is cut to the room left afterwards.
+    return (markdown ? (renderMarkdown(first, 1000)[0] ?? first) : first) + more;
+}
+/**
+ * The calls one by one: each behind a `●`, then after `⎿` the calls a subagent made (the
+ * latest few, dim) and the result in one line (a subagent's answer with its markdown
+ * rendered), or "…" while it runs.
+ */
+export function toolGroupExpanded(calls, width) {
+    return calls.flatMap((call) => {
+        const children = call.children ?? [];
+        const shown = children.slice(-MAX_CHILDREN);
+        const result = call.result ? fitWidth(resultSummary(call.result, SUBAGENT_TOOLS.has(call.toolName)), width - 5) : ui.dim("…");
+        const under = [
+            ...(children.length > shown.length ? [ui.dim(`… ${children.length - shown.length} earlier`)] : []),
+            ...shown.map((label) => fitWidth(ui.dim(`· ${label}`), width - 5)),
+            result,
+        ];
+        return [
+            `${ui.toolBullet("●")} ${fitWidth(call.label, width - 2)}`,
+            ...under.map((line, i) => (line === "" ? "" : `  ${i === 0 ? ui.dim("⎿") : " "}  ${line}`)),
+        ];
+    });
+}