@hheei/pi-ext-ui 0.6.0 → 0.7.1

package/README.md

@@ -8,8 +8,8 @@ The shared view API owns fold levels, compact sections, status glyphs, copy feed
 
 Background Bash and subagent tools own their display formats through ext-core `ToolPresentation` providers. This resolver consumes those providers automatically, including nested codemode calls, and adds shared folding and copy controls. Without `pi-ext-ui`, the same tools retain native Pi renderers. No direct dependency on `pi-ext-ui` is required by the tool extensions.
 
-Activity groups are on by default for Pi **>=1.0.1** TUI sessions. Turn them off with the Tool UI setting `toolGroups.enabled` in `ext_settings.json` (the ext-core settings page). The change applies to the current session. A heading such as `▸ codemode ×2 · grep ×3` keeps one live summary row per tool beneath a single outer rail. Each thinking round and notification also keeps a summary row; notifications are not counted. Groups form while tools run and can span consecutive tool/thinking rounds. Prose, user messages, unknown components, images, and unknown tool renderers break groups. Any MessageView transcript notice stays inside the group, so bg-bash, subagent, memory, optimizer, and codemode-guard notices do not need their own allowlist. Notification rows show their text directly. Streaming arguments, partial results, completion, and errors update the existing row.
+Activity groups are on by default for Pi **>=1.0.1** TUI sessions. Turn them off with the Tool UI setting `toolGroups.enabled` in `ext_settings.json` (the ext-core settings page). The change applies to the current session. A heading such as `▸ codemode ×2 · grep ×3` keeps one live summary row per tool beneath a single outer rail. Each thinking round and notification also keeps a summary row; notifications are not counted. A thinking item shows a content preview while Pi hides thinking and opens the full text on demand; while thinking is visible the category prints it flat. Groups form while tools run and can span consecutive tool/thinking rounds. Prose, user messages, unknown components, images, and unknown tool renderers break groups. Any MessageView transcript notice stays inside the group, so bg-bash, subagent, memory, optimizer, and codemode-guard notices do not need their own allowlist. Notification rows show their own text once, indented and width-wrapped; only a MessageView with a real body gets an expand pin. Streaming arguments, partial results, completion, and errors update the existing row.
 
-Fullscreen: click the group heading to restore the original component layouts and interactions beneath the outer rail. Both terminal modes: Ctrl+O forces groups open; closing global expansion restores each group’s local choice. Appending members preserves that choice. Original per-tool fold choices remain intact. Groups are presentation only and are rebuilt on history navigation; session data, model context, and HTML export remain unchanged. Thinking summaries keep a label; expanding respects native thinking visibility. Each `ctx.ui.notify` call retains its full text for expansion. Notifications remain session-local, as in Pi.
+Fullscreen: click the group heading to restore the original component layouts and interactions beneath the outer rail. Both terminal modes: Ctrl+O forces groups open; closing global expansion restores each group’s local choice. Appending members preserves that choice. Original per-tool fold choices remain intact. Groups are presentation only and are rebuilt on history navigation; session data, model context, and HTML export remain unchanged. Thinking keeps its label; the hidden state shows a preview instead of dropping the text, and the visible state has no per-item arrow. Each `ctx.ui.notify` keeps its full text inline. Notifications remain session-local, as in Pi.
 
 Grouping uses two centralized, version-checked host prototype hooks: tool lookup and extension notifications. Thinking uses the existing assistant message, with no extra hook. Unsupported hosts or incompatible layouts report a warning and retain normal rendering. Cleanup restores the original methods; if another extension replaces the same methods, restart Pi to unload the conflicting patch. For workspace development use `pnpm run pi-dev`: running the bundled CLI beside physical host devDependencies can resolve a second host class, unlike the published installation.

package/dist/background.d.ts

@@ -0,0 +1,18 @@
+import type { Theme, ThemeBg } from "@earendil-works/pi-coding-agent";
+/**
+ * Paint one surface's rows. A surface owns its own background and nothing else: after any reset
+ * (`0`, `49`, or a compound sequence containing one) it re-asserts *its* background, so a row keeps
+ * the fill across the styled spans a theme or child renderer ends with `\x1b[0m`.
+ *
+ * It never guesses another surface's background. A nested surface that ended its own fill is gone;
+ * the rest of the row belongs to the surface painting it. Nested surfaces stay separate because each
+ * one paints the rows it draws, not because this function tracks ANSI state.
+ */
+export declare function backgroundFill(theme: Theme, token: ThemeBg): (text: string) => string;
+/**
+ * One independent surface: a filled padding row above and below, every row reaching `width`.
+ *
+ * A block that owns a surface also owns its breathing room, so two adjacent blocks separate with
+ * their own padding rows instead of sharing one unstyled gap.
+ */
+export declare function surfaceBlock(theme: Theme, token: ThemeBg, rows: readonly string[], width: number): string[];

package/dist/background.js

@@ -0,0 +1,44 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
+const MARK = "\u0000";
+/** Any SGR sequence: parameters are `;`-separated, an empty parameter list means reset. */
+const SGR = /\x1b\[([0-9;]*)m/g;
+/**
+ * Paint one surface's rows. A surface owns its own background and nothing else: after any reset
+ * (`0`, `49`, or a compound sequence containing one) it re-asserts *its* background, so a row keeps
+ * the fill across the styled spans a theme or child renderer ends with `\x1b[0m`.
+ *
+ * It never guesses another surface's background. A nested surface that ended its own fill is gone;
+ * the rest of the row belongs to the surface painting it. Nested surfaces stay separate because each
+ * one paints the rows it draws, not because this function tracks ANSI state.
+ */
+export function backgroundFill(theme, token) {
+    const [start, end] = theme.bg(token, MARK).split(MARK);
+    if (start === undefined || end === undefined)
+        return (text) => text;
+    return (text) => {
+        let out = start;
+        let from = 0;
+        for (const match of text.matchAll(SGR)) {
+            const params = match[1] ?? "";
+            const resets = params === "" || params.split(";").some((code) => code === "0" || code === "49");
+            const next = (match.index ?? 0) + match[0].length;
+            out += text.slice(from, next);
+            if (resets)
+                out += start;
+            from = next;
+        }
+        return `${out}${text.slice(from)}${end}`;
+    };
+}
+/**
+ * One independent surface: a filled padding row above and below, every row reaching `width`.
+ *
+ * A block that owns a surface also owns its breathing room, so two adjacent blocks separate with
+ * their own padding rows instead of sharing one unstyled gap.
+ */
+export function surfaceBlock(theme, token, rows, width) {
+    const fill = backgroundFill(theme, token);
+    const pad = fill(" ".repeat(Math.max(0, width)));
+    const body = rows.map((row) => fill(row + " ".repeat(Math.max(0, width - visibleWidth(row)))));
+    return [pad, ...body, pad];
+}

package/dist/extension.js

@@ -2,12 +2,15 @@ import { getRuntimeSettingsRegistry, messageViewPoint, registerExtensionHook, re
 import { installHostToolGroups } from "./host-transcript-patch.js";
 import { createMessageView } from "./message-view.js";
 import { createOptionalToolRendererFactory, registerCollapsibleToolRenderer } from "./renderer.js";
-import { activityGroupsEnabled, createToolGroupSettings } from "./settings.js";
-import { clearCapturedNestedCalls } from "./tracker.js";
+import { ToolUiRuntime } from "./runtime.js";
+import { activityGroupsEnabled, createToolGroupSettings, toolBackgroundsEnabled, } from "./settings.js";
+import { TOOL_SPINNER_INTERVAL_MS } from "./tool-view.js";
 export default function (pi) {
+    // One runtime per extension instance: two Pi runtimes in one process never share these facts.
+    const runtime = new ToolUiRuntime();
     let redrawGroups;
     pi.on("agent_settled", () => redrawGroups?.());
-    registerCollapsibleToolRenderer(pi);
+    registerCollapsibleToolRenderer(pi, runtime);
     registerExtensionLifecycle(pi, {
         key: "@hheei/pi-ext-ui",
         async start(context) {
@@ -31,18 +34,59 @@ export default function (pi) {
                     context.extension.ui.notify(error instanceof Error ? error.message : String(error), "warning");
                 }
             };
-            const provider = createToolGroupSettings({ onEnabled: apply });
+            const applyBackgrounds = (enabled) => {
+                runtime.backgrounds = enabled;
+                redrawGroups?.();
+            };
+            const provider = createToolGroupSettings({
+                onEnabled: apply,
+                onBackgrounds: applyBackgrounds,
+            });
             const onAgentStart = pi.on("agent_start", () => {
                 patch?.beginRun();
                 redrawGroups?.();
             });
+            // A live tool animates its status glyph. The ticker exists only while one is running, and the
+            // frame itself comes from one shared clock, so a phase never restarts on a status change.
+            let liveTools = 0;
+            let ticker;
+            const stopTicker = () => {
+                if (ticker === undefined)
+                    return;
+                clearInterval(ticker);
+                ticker = undefined;
+            };
             const onAgentEnd = pi.on("agent_end", () => {
                 patch?.endRun();
+                // No tool outlives the agent loop, so the animation cannot keep a ticker alive either.
+                liveTools = 0;
+                stopTicker();
                 redrawGroups?.();
             });
+            const onToolStart = pi.on("tool_execution_start", () => {
+                liveTools += 1;
+                if (ticker !== undefined)
+                    return;
+                ticker = setInterval(() => {
+                    if (liveTools === 0 || redrawGroups === undefined) {
+                        stopTicker();
+                        return;
+                    }
+                    redrawGroups();
+                }, TOOL_SPINNER_INTERVAL_MS);
+            });
+            const onToolEnd = pi.on("tool_execution_end", () => {
+                liveTools = Math.max(0, liveTools - 1);
+                if (liveTools === 0)
+                    stopTicker();
+            });
             context.resources.add("run-clock", () => {
                 onAgentStart();
                 onAgentEnd();
+                onToolStart();
+                onToolEnd();
+                stopTicker();
+                liveTools = 0;
             });
             context.resources.add("tool-group-settings", registerSettings(provider, getRuntimeSettingsRegistry(pi)));
             context.resources.add("tool-groups", () => {
@@ -51,9 +95,14 @@ export default function (pi) {
                 patch = undefined;
             });
             context.resources.add("tracker-cleanup", () => {
-                clearCapturedNestedCalls();
+                runtime.tracker.clear();
+            });
+            // Resume reads the host's own nested-call record for the current branch, never another one.
+            runtime.nestedCalls.setSource(context.extension.sessionManager);
+            context.resources.add("nested-call-source", () => {
+                runtime.nestedCalls.setSource(undefined);
             });
-            const toolRenderers = registerExtensionHook(pi, toolRendererPoint, createOptionalToolRendererFactory(pi));
+            const toolRenderers = registerExtensionHook(pi, toolRendererPoint, createOptionalToolRendererFactory(pi, runtime));
             context.resources.add("tool-renderer", () => toolRenderers.dispose());
             const handle = registerExtensionHook(context.pi, messageViewPoint, createMessageView);
             context.resources.add("message-view", () => handle.dispose());
@@ -62,14 +111,17 @@ export default function (pi) {
                     sessionId: context.extension.sessionManager.getSessionId(),
                     signal: context.signal,
                 });
-                if (!context.signal.aborted)
+                if (!context.signal.aborted) {
                     apply(activityGroupsEnabled(state));
+                    applyBackgrounds(toolBackgroundsEnabled(state));
+                }
             }
             catch (error) {
                 if (!context.signal.aborted) {
                     const detail = error instanceof Error ? error.message : String(error);
                     context.extension.ui.notify(`Tool activity groups settings unreadable: ${detail}`, "warning");
                     apply(true);
+                    applyBackgrounds(false);
                 }
             }
         },

package/dist/host-transcript-patch.js

@@ -1,7 +1,7 @@
 import { AssistantMessageComponent, InteractiveMode, ToolExecutionComponent, VERSION, } from "@earendil-works/pi-coding-agent";
-import { Container, Spacer, stripTerminalSequences, Text, wrapTextWithAnsi, } from "@earendil-works/pi-tui";
+import { Container, stripTerminalSequences, Text } from "@earendil-works/pi-tui";
 import { MessageView } from "./message-view.js";
-import { ToolGroupView } from "./tool-group-view.js";
+import { memberParts, TailUnit, ToolGroupView, } from "./tool-group-view.js";
 import { ToolView, toSingleRow } from "./tool-view.js";
 const SEAMS = ["getRegisteredToolDefinition", "showExtensionNotify"];
 function record(value) {
@@ -47,21 +47,25 @@ function assistantInfo(component) {
     const hidden = Reflect.get(component, "hideThinkingBlock");
     const calls = new Set();
     let eligible = !["length", "aborted", "error"].includes(String(message.stopReason));
-    let thinking = "";
+    const thinking = [];
     for (const block of message.content) {
         if (!record(block))
             throw new Error("Pi assistant content shape changed");
         if (block.type === "toolCall" && typeof block.id === "string")
             calls.add(block.id);
-        else if (block.type === "thinking" && typeof block.thinking === "string")
-            thinking += block.thinking;
+        else if (block.type === "thinking" && typeof block.thinking === "string") {
+            // Pi joins a thinking run with blank lines; the same separator keeps paragraphs readable here.
+            const text = block.thinking.trim();
+            if (text !== "")
+                thinking.push(text);
+        }
         else if (block.type !== "text" || typeof block.text !== "string" || block.text.trim() !== "")
             eligible = false;
     }
     return {
         calls,
         eligible,
-        thinking,
+        thinking: thinking.join("\n\n"),
         hidden: hidden === true,
         usage: readUsage(message.usage),
     };
@@ -88,10 +92,9 @@ function toolMember(component, calls) {
             !result.content.every((block) => record(block) && block.type === "text") ||
             !(renderer instanceof ToolView)))
         return undefined;
-    const summary = renderer instanceof ToolView
-        ? (renderer.summary ?? callRenderer.summary)
-        : callRenderer.summary;
-    if (summary === undefined)
+    // The visible view decides the facts: a hidden call renderer reports no summary of its own.
+    const view = renderer instanceof ToolView ? renderer : callRenderer;
+    if (view.summary === undefined)
         return undefined;
     const status = !complete
         ? "streaming"
@@ -100,16 +103,17 @@ function toolMember(component, calls) {
             : record(result) && result.isError === true
                 ? "error"
                 : "ok";
-    const children = renderer instanceof ToolView ? renderer.children : callRenderer.children;
-    const childCount = renderer instanceof ToolView ? renderer.childCount : undefined;
+    const children = view.children;
     return {
         kind: "tool",
         component,
         title: toSingleRow(stripTerminalSequences(name)),
-        summary,
         status,
+        // The host keeps isPartial true until it stores a final result; argsComplete alone is not
+        // completion, and restored history never sets it. The result is the observed end fact.
+        completed: !partial && result !== undefined,
         ...(children === undefined || children.length === 0 ? {} : { children }),
-        ...(childCount === undefined ? {} : { childCount }),
+        ...(view.childCount === undefined ? {} : { childCount: view.childCount }),
     };
 }
 function messageView(component) {
@@ -132,50 +136,50 @@ function noticeMember(component) {
         component,
         title: view.kind,
         summary: view.activitySummary,
-        // A notice with no preview and no body has nothing to open; the group draws a pin only when
-        // detail exists, so an unconditional function would give it an arrow onto an empty body.
-        ...(view.hasDetail ? { detail: (width) => view.detailRows(width) } : {}),
+        // Preview is visible content; only a real body opens. A preview-only notice therefore never
+        // grows a second expansion level, and the notice lays out both blocks itself.
+        content: (width) => view.previewRows(width),
+        ...(view.expandable ? { detail: (width) => view.bodyRows(width) } : {}),
     };
 }
-class NotifyView extends Container {
+/**
+ * A captured `ui.notify`. It owns its content: one indented, width-wrapped block with the notice's
+ * semantic color. The group draws these rows once, so a plain notice has no expansion of its own.
+ */
+class NotifyView {
     #text = new Text("", 1, 0);
     #ui;
     #message;
     #type;
     constructor(message, type, ui) {
-        super();
         this.#ui = ui;
         this.#message = message;
         this.#type = type;
-        this.addChild(new Spacer(1));
-        this.addChild(this.#text);
-    }
-    get summary() {
-        return this.#ui.theme.fg(this.#type === "info" ? "dim" : this.#type, toSingleRow(this.#content));
     }
     get member() {
         return {
             kind: "notice",
             component: this,
             title: this.#type,
-            summary: this.summary,
-            detail: (width) => this.#detail(width),
+            content: (width) => this.rows(width),
         };
     }
-    #detail(width) {
-        const inner = Math.max(1, width - 2);
-        return this.#content.split("\n").flatMap((line) => {
-            const wrapped = wrapTextWithAnsi(line, inner);
-            return (wrapped.length > 0 ? wrapped : [""]).map((row) => `  ${row}`);
-        });
+    /** The notice body as it appears both in the transcript and inside the activity group. */
+    rows(width) {
+        // info is the terminal's own readable text; a warning or error keeps its status token and
+        // its written prefix, so the level never depends on color alone.
+        this.#text.setText(this.#ui.theme.fg(this.#type === "info" ? "text" : this.#type, this.#content));
+        return this.#text.render(width);
     }
     get #content() {
         const prefix = this.#type === "error" ? "Error: " : this.#type === "warning" ? "Warning: " : "";
         return `${prefix}${this.#message}`;
     }
     render(width) {
-        this.#text.setText(this.#ui.theme.fg(this.#type === "info" ? "dim" : this.#type, this.#content));
-        return super.render(width);
+        return ["", ...this.rows(width)];
+    }
+    invalidate() {
+        this.#text.invalidate();
     }
 }
 function attach(host, run) {
@@ -196,40 +200,144 @@ function attach(host, run) {
         throw new Error("Pi transcript cannot accept instance methods");
     const projection = new Container();
     let groups = new Map();
+    /** One wrapper per tail component, so its reserved height survives a transcript rebuild. */
+    let tails = new Map();
     let active = true;
+    const disposeGroups = () => {
+        for (const group of groups.values())
+            group.dispose();
+        groups.clear();
+    };
+    /**
+     * Record first observation time for new components during a live loop. Restored history stays
+     * unknown until live content joins its block.
+     */
+    const claim = (child) => {
+        if (run.observed.has(child))
+            return;
+        const current = run.current;
+        run.observed.set(child, current !== undefined && current.run.endedAt === undefined
+            ? { at: performance.now(), run: current.run }
+            : undefined);
+    };
+    const observe = () => {
+        for (const child of chat.children)
+            claim(child);
+    };
+    /** Create or recover one clock for each live continuous block. */
+    const clockOf = (members, endedAt) => {
+        const parts = members.flatMap(memberParts);
+        let clock;
+        for (const part of parts) {
+            clock = run.clocks.get(part);
+            if (clock !== undefined)
+                break;
+        }
+        if (clock === undefined) {
+            const origin = parts
+                .map((part) => run.observed.get(part))
+                .find((value) => value !== undefined);
+            if (origin === undefined)
+                return undefined;
+            clock = { startedAt: origin.at };
+            if (origin.run.endedAt !== undefined)
+                clock.endedAt = origin.run.endedAt;
+            else
+                run.activeClocks.add(clock);
+        }
+        if (endedAt !== undefined && clock.endedAt === undefined) {
+            clock.endedAt = endedAt;
+            run.activeClocks.delete(clock);
+        }
+        for (const part of parts)
+            if (run.clocks.get(part) === undefined)
+                run.clocks.set(part, clock);
+        return clock;
+    };
     const rebuild = () => {
         const next = new Map();
+        const nextTails = new Map();
         const children = [];
         const blocks = [];
         let calls = new Set();
         let members = [];
-        /** Closes the pending run. `ended` is false only for the run still open at the transcript tail. */
-        const flush = (ended) => {
+        /** Every request this pending block owns, in transcript order, whether or not it is displayed. */
+        let requests = [];
+        /**
+         * Closes the pending block. `ended` is false only for the block still open at the transcript tail:
+         * that one keeps its last visible unit outside the group, and its facts still count here.
+         */
+        const flush = (ended, boundary) => {
             const first = members[0]?.component;
-            if (first !== undefined && members.filter((member) => member.kind === "tool").length > 1) {
-                const group = groups.get(first) ??
-                    new ToolGroupView(host.ui, host.requestRender, run.current?.endedAt === undefined ? run.current : undefined);
-                blocks.push({ group, members, ended });
+            let weight = 0;
+            for (const member of members) {
+                if (member.kind === "tool")
+                    weight += 1;
+                else if (member.kind === "notice" ||
+                    (member.thinking !== undefined && member.thinking !== ""))
+                    weight += 0.5;
+            }
+            if (first !== undefined && weight >= 2) {
+                const group = groups.get(first) ?? new ToolGroupView(host.ui, host.requestRender);
+                const tail = ended ? undefined : members.at(-1);
+                const inside = tail === undefined ? members : members.slice(0, -1);
+                const boundaryTime = ended && boundary !== undefined
+                    ? (run.observed.get(boundary)?.at ?? performance.now())
+                    : undefined;
+                blocks.push({
+                    group,
+                    members: inside,
+                    tail,
+                    requests,
+                    clock: clockOf(members, boundaryTime),
+                });
                 next.set(first, group);
                 children.push(group);
+                if (tail !== undefined) {
+                    const key = memberParts(tail)[0];
+                    const unit = (key === undefined ? undefined : tails.get(key)) ?? new TailUnit(tail);
+                    unit.update(tail);
+                    if (key !== undefined)
+                        nextTails.set(key, unit);
+                    children.push(unit);
+                }
             }
             else
-                children.push(...members.map((member) => member.component));
+                children.push(...members.flatMap(memberParts));
             members = [];
+            requests = [];
         };
         for (const child of chat.children) {
+            claim(child);
             if (child instanceof AssistantMessageComponent) {
                 const info = assistantInfo(child);
                 calls = info.calls;
+                // The request belongs to the block whose work it answers, even when its text is native
+                // content the aggregate never shows.
+                requests.push(info.usage === undefined ? {} : { usage: info.usage });
                 if (info.eligible) {
                     const thinking = info.thinking;
-                    members.push({
-                        kind: "assistant",
-                        component: child,
-                        ...(thinking === "" ? {} : { thinkingChars: thinking.length }),
-                        ...(thinking === "" || info.hidden ? {} : { thinking }),
-                        ...(info.usage === undefined ? {} : { usage: info.usage }),
-                    });
+                    const previous = members.at(-1);
+                    if (thinking !== "" && previous?.kind === "thinking") {
+                        // One continuous run: consecutive thinking blocks are one item, paragraphs kept.
+                        members[members.length - 1] = {
+                            ...previous,
+                            thinking: `${previous.thinking ?? ""}\n\n${thinking}`,
+                            parts: [...memberParts(previous), child],
+                            ...(previous.thinkingHidden === true || info.hidden ? { thinkingHidden: true } : {}),
+                        };
+                    }
+                    else {
+                        members.push({
+                            kind: "thinking",
+                            component: child,
+                            // The host's hide setting is a display preference, not a content filter: the text
+                            // stays available to the group's preview and expansion, and is never written back.
+                            ...(thinking === ""
+                                ? {}
+                                : { thinking, ...(info.hidden ? { thinkingHidden: true } : {}) }),
+                        });
+                    }
                     continue;
                 }
             }
@@ -251,15 +359,20 @@ function attach(host, run) {
                     continue;
                 }
             }
-            flush(true);
+            flush(true, child);
             children.push(child);
         }
         flush(false);
-        const frozen = run.current === undefined || run.current.endedAt !== undefined;
         for (const block of blocks) {
-            block.group.update(block.members, frozen || block.ended);
+            block.group.update(block.members, block.tail, block.requests, block.clock);
+        }
+        // A block the new projection does not reuse is gone: its hold timer must go with it.
+        for (const [key, group] of groups) {
+            if (next.get(key) !== group)
+                group.dispose();
         }
         groups = next;
+        tails = nextTails;
         projection.children = children;
     };
     const wrappers = {
@@ -271,7 +384,7 @@ function attach(host, run) {
             }
             catch (error) {
                 active = false;
-                groups.clear();
+                disposeGroups();
                 projection.clear();
                 host.ui.notify(`Tool grouping disabled: ${error instanceof Error ? error.message : String(error)}`, "warning");
                 return original.render.call(chat, width);
@@ -299,12 +412,13 @@ function attach(host, run) {
             host.requestRender();
             return true;
         },
+        observe,
         dispose() {
             if (disposed)
                 return;
             disposed = true;
             active = false;
-            groups.clear();
+            disposeGroups();
             projection.clear();
             let conflict = false;
             for (const key of ["render", "handleMouse", "invalidate"]) {
@@ -431,12 +545,15 @@ export function installHostToolGroups(context) {
                 value: state.wrappers[seam],
             });
     }
-    const run = {};
+    const run = {
+        observed: new WeakMap(),
+        clocks: new WeakMap(),
+        activeClocks: new Set(),
+    };
     const owner = {
         ui,
         hosts: new Map(),
         failed: new WeakSet(),
-        run,
         attach: (host) => attach(host, run),
     };
     state.owners.set(ui, owner);
@@ -463,18 +580,29 @@ export function installHostToolGroups(context) {
                 host.requestRender();
         },
         beginRun() {
-            run.current = { startedAt: performance.now() };
+            // History may not have rendered yet. Claim it before opening the new live run.
+            for (const host of owner.hosts.values())
+                host.observe();
+            run.current = { run: {} };
         },
         endRun() {
+            // Mark unseen transcript children before ending the run so later renders treat them as history.
+            for (const host of owner.hosts.values())
+                host.observe();
+            const endedAt = performance.now();
             const current = run.current;
-            if (current !== undefined && current.endedAt === undefined)
-                current.endedAt = performance.now();
+            if (current !== undefined && current.run.endedAt === undefined)
+                current.run.endedAt = endedAt;
+            for (const clock of run.activeClocks)
+                clock.endedAt = endedAt;
+            run.activeClocks.clear();
         },
         dispose() {
             if (disposed)
                 return;
             disposed = true;
             run.current = undefined;
+            run.activeClocks.clear();
             state.owners.delete(ui);
             for (const host of owner.hosts.values())
                 host.dispose();

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export { type DiffHunk, type DiffLine, type DiffSource, type DiffStats, DiffView, type DiffViewOptions, diffStats, } from "./diff-view.js";
 export { createMessageView, type MessageRows, type MessageTone, MessageView, type MessageViewHeader, type MessageViewSpec, } from "./message-view.js";
-export { extractChildToolCopyText, NestedCallsView, type NestedCallsViewProps, } from "./nested-calls-view.js";
-export { type CollapsibleToolRendererOptions, createCollapsibleToolRendererResolver, estimateStreamingTokens, inlinePresentation, isMcpTool, type NestedCallRecord, registerCollapsibleToolRenderer, SPECIALIZED_TOOL_RENDERERS, type SpecializedToolRendererName, type ToolRenderContext, } from "./renderer.js";
+export { extractChildToolCopyText, inlinePresentation } from "./native-tools.js";
+export { NestedCallsView, type NestedCallsViewProps, } from "./nested-calls-view.js";
+export { type CollapsibleToolRendererOptions, createCollapsibleToolRendererResolver, estimateStreamingTokens, isMcpTool, type NestedCallRecord, registerCollapsibleToolRenderer, SPECIALIZED_TOOL_RENDERERS, type SpecializedToolRendererName, type ToolRenderContext, } from "./renderer.js";
+export { ToolUiRuntime } from "./runtime.js";
 export { type Collapsible, createToolView, type FoldLevel, formatStatusGlyph, formatToolHeaderText, isCollapsible, type RailColorToken, type RailSection, type ToolStatusKind, ToolView, type ToolViewChild, type ToolViewCopySpec, type ToolViewHeaderSpec, type ToolViewSpec, transitionFoldLevel, } from "./tool-view.js";
-export { type CapturedToolCall, clearCapturedNestedCalls, getCapturedNestedCalls, recordToolExecutionEnd, recordToolExecutionStart, } from "./tracker.js";
+export { type CapturedToolCall, type NestedCallArgsFact, NestedCallArgsIndex, ToolExecutionTracker, } from "./tracker.js";

package/dist/index.js

@@ -1,6 +1,8 @@
 export { DiffView, diffStats, } from "./diff-view.js";
 export { createMessageView, MessageView, } from "./message-view.js";
-export { extractChildToolCopyText, NestedCallsView, } from "./nested-calls-view.js";
-export { createCollapsibleToolRendererResolver, estimateStreamingTokens, inlinePresentation, isMcpTool, registerCollapsibleToolRenderer, SPECIALIZED_TOOL_RENDERERS, } from "./renderer.js";
+export { extractChildToolCopyText, inlinePresentation } from "./native-tools.js";
+export { NestedCallsView, } from "./nested-calls-view.js";
+export { createCollapsibleToolRendererResolver, estimateStreamingTokens, isMcpTool, registerCollapsibleToolRenderer, SPECIALIZED_TOOL_RENDERERS, } from "./renderer.js";
+export { ToolUiRuntime } from "./runtime.js";
 export { createToolView, formatStatusGlyph, formatToolHeaderText, isCollapsible, ToolView, transitionFoldLevel, } from "./tool-view.js";
-export { clearCapturedNestedCalls, getCapturedNestedCalls, recordToolExecutionEnd, recordToolExecutionStart, } from "./tracker.js";
+export { NestedCallArgsIndex, ToolExecutionTracker, } from "./tracker.js";

package/dist/message-view.d.ts

@@ -14,16 +14,10 @@ export declare class MessageView implements Component {
     handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined;
     /** Provider-declared notice type, used to group notices without reading their text. */
     get kind(): string;
-    /**
-     * Detail rows inside an activity group: preview and body below the summary row the group already
-     * draws, regardless of local fold. Repeating the header there would print the summary twice.
-     */
-    detailRows(width: number): string[];
+    /** Preview rows inside an activity group: visible content below the summary, folded or not. */
+    previewRows(width: number): string[];
+    /** Body rows inside an activity group: what opening this notice reveals. */
+    bodyRows(width: number): string[];
     /** Single-row label used when this notice sits inside an activity group. */
     get activitySummary(): string;
-    /**
-     * Whether anything would render below the label. `expandable` asks about the body only; a
-     * preview-only notice still has detail to show, so the group keys its pin on this instead.
-     */
-    get hasDetail(): boolean;
 }