@hheei/pi-ext-ui 0.4.2 → 0.5.1

package/README.md

@@ -7,3 +7,9 @@ Pi UI primitives and a small set of specialized tool renderers.
 The shared view API owns fold levels, compact sections, status glyphs, copy feedback, and width-safe rendering. It does not read files, execute tools, infer outcomes, or import a concrete extension.
 
 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. 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.
+
+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/extension.js

@@ -1,12 +1,50 @@
-import { messageViewPoint, registerExtensionHook, registerExtensionLifecycle, toolRendererPoint, } from "@hheei/pi-ext-core";
+import { getRuntimeSettingsRegistry, messageViewPoint, registerExtensionHook, registerExtensionLifecycle, registerSettings, toolRendererPoint, } from "@hheei/pi-ext-core";
+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";
+function sessionId(extension) {
+    const manager = extension.sessionManager;
+    if (typeof manager !== "object" || manager === null || !("getSessionId" in manager))
+        return "";
+    const read = manager.getSessionId;
+    return typeof read === "function" ? String(read.call(manager)) : "";
+}
 export default function (pi) {
+    let redrawGroups;
+    pi.on("agent_settled", () => redrawGroups?.());
     registerCollapsibleToolRenderer(pi);
     registerExtensionLifecycle(pi, {
         key: "@hheei/pi-ext-ui",
-        start(context) {
+        async start(context) {
+            let patch;
+            const apply = (enabled) => {
+                if (context.extension.mode !== "tui")
+                    return;
+                if (!enabled) {
+                    redrawGroups = undefined;
+                    patch?.dispose();
+                    patch = undefined;
+                    return;
+                }
+                if (patch !== undefined)
+                    return;
+                try {
+                    patch = installHostToolGroups(context.extension);
+                    redrawGroups = patch.requestRender;
+                }
+                catch (error) {
+                    context.extension.ui.notify(error instanceof Error ? error.message : String(error), "warning");
+                }
+            };
+            const provider = createToolGroupSettings({ onEnabled: apply });
+            context.resources.add("tool-group-settings", registerSettings(provider, getRuntimeSettingsRegistry(pi)));
+            context.resources.add("tool-groups", () => {
+                redrawGroups = undefined;
+                patch?.dispose();
+                patch = undefined;
+            });
             context.resources.add("tracker-cleanup", () => {
                 clearCapturedNestedCalls();
             });
@@ -14,6 +52,21 @@ export default function (pi) {
             context.resources.add("tool-renderer", () => toolRenderers.dispose());
             const handle = registerExtensionHook(context.pi, messageViewPoint, createMessageView);
             context.resources.add("message-view", () => handle.dispose());
+            try {
+                const state = await provider.storage.load({
+                    sessionId: sessionId(context.extension),
+                    signal: context.signal,
+                });
+                if (!context.signal.aborted)
+                    apply(activityGroupsEnabled(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);
+                }
+            }
         },
     });
 }

package/dist/host-transcript-patch.d.ts

@@ -0,0 +1,6 @@
+import { type ExtensionContext } from "@earendil-works/pi-coding-agent";
+/** Private to pi-ext-ui: two process hooks, scoped by the actual host UI facade. */
+export declare function installHostToolGroups(context: ExtensionContext): {
+    dispose(): void;
+    requestRender(): void;
+};

package/dist/host-transcript-patch.js

@@ -0,0 +1,462 @@
+import { AssistantMessageComponent, InteractiveMode, ToolExecutionComponent, VERSION, } from "@earendil-works/pi-coding-agent";
+import { Container, MouseRegion, Spacer, stripTerminalSequences, Text, truncateToWidth, } from "@earendil-works/pi-tui";
+import { renderWithoutToolRails, ToolView, toSingleRow } from "./tool-view.js";
+const SEAMS = ["getRegisteredToolDefinition", "showExtensionNotify"];
+function record(value) {
+    return typeof value === "object" && value !== null;
+}
+// Audited Pi >=1.0.1 compiles these TS-private members to ordinary JS properties.
+// All host-private access stays here; VERSION comes from the running host virtual module.
+function readHost(value) {
+    if (!record(value))
+        throw new Error("Invalid InteractiveMode instance");
+    const chat = value.chatContainer;
+    const session = value.session;
+    const tui = value.ui;
+    if (!record(session) || !record(tui) || typeof tui.requestRender !== "function") {
+        throw new Error("Pi host session/TUI shape changed");
+    }
+    const runner = session.extensionRunner;
+    if (!(chat instanceof Container) ||
+        !record(runner) ||
+        typeof runner.getUIContext !== "function") {
+        throw new Error("Pi host transcript/runner shape changed");
+    }
+    const ui = runner.getUIContext();
+    const requestRender = tui.requestRender;
+    return { chat, ui, requestRender: () => requestRender.call(tui) };
+}
+function assistantInfo(component) {
+    const message = Reflect.get(component, "lastMessage");
+    if (!record(message) || !Array.isArray(message.content)) {
+        throw new Error("Pi assistant message shape changed");
+    }
+    const calls = new Set();
+    let eligible = !["length", "aborted", "error"].includes(String(message.stopReason));
+    let thinking = false;
+    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.trim() !== "";
+        else if (block.type !== "text" || typeof block.text !== "string" || block.text.trim() !== "")
+            eligible = false;
+    }
+    return { calls, eligible, thinking };
+}
+function toolMember(component, calls) {
+    const id = Reflect.get(component, "toolCallId");
+    const name = Reflect.get(component, "toolName");
+    const partial = Reflect.get(component, "isPartial");
+    const result = Reflect.get(component, "result");
+    const renderer = Reflect.get(component, "resultRendererComponent");
+    const callRenderer = Reflect.get(component, "callRendererComponent");
+    if (typeof id !== "string" || typeof name !== "string" || typeof partial !== "boolean") {
+        throw new Error("Pi tool component shape changed");
+    }
+    if (!calls.has(id) || !(callRenderer instanceof ToolView))
+        return undefined;
+    if (result !== undefined &&
+        (!record(result) ||
+            !Array.isArray(result.content) ||
+            !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)
+        return undefined;
+    return { component, name: toSingleRow(stripTerminalSequences(name)), summary };
+}
+class NotifyView extends Container {
+    #text = new Text("", 1, 0);
+    #context;
+    #message;
+    #type;
+    constructor(message, type, context) {
+        super();
+        this.#context = context;
+        this.#message = message;
+        this.#type = type;
+        this.addChild(new Spacer(1));
+        this.addChild(this.#text);
+    }
+    get summary() {
+        return this.#context.ui.theme.fg(this.#type === "info" ? "dim" : this.#type, toSingleRow(`notify · ${this.#content}`));
+    }
+    get #content() {
+        const prefix = this.#type === "error" ? "Error: " : this.#type === "warning" ? "Warning: " : "";
+        return `${prefix}${this.#message}`;
+    }
+    render(width) {
+        this.#text.setText(this.#context.ui.theme.fg(this.#type === "info" ? "dim" : this.#type, this.#content));
+        return super.render(width);
+    }
+}
+class ToolGroup extends Container {
+    #header = new Text("", 0, 0);
+    #originals = new Container();
+    #context;
+    #members = [];
+    #expanded = false;
+    #renderedExpanded = false;
+    constructor(context, redraw) {
+        super();
+        this.#context = context;
+        const heading = new MouseRegion(this.#header, (event) => {
+            if (event.type !== "click" || event.button !== "left")
+                return undefined;
+            this.#expanded = this.#context.ui.getToolsExpanded() ? false : !this.#expanded;
+            redraw();
+            return { handled: true, render: true };
+        });
+        const body = {
+            render: (width) => {
+                const rows = this.#renderedExpanded
+                    ? renderWithoutToolRails(this.#originals, Math.max(1, width - 2))
+                    : this.#members.flatMap((member) => member.summary === undefined ? [] : [member.summary]);
+                const rail = this.#context.ui.theme.fg("dim", "▎");
+                return rows.map((row) => truncateToWidth(`${rail} ${row}`, Math.max(0, width), "…"));
+            },
+            handleMouse: (event) => {
+                if (!this.#renderedExpanded || event.x < 2)
+                    return undefined;
+                return this.#originals.handleMouse({
+                    ...event,
+                    x: event.x - 2,
+                    width: Math.max(1, event.width - 2),
+                });
+            },
+            invalidate() { },
+        };
+        this.children = [new Spacer(1), heading, body];
+    }
+    update(members) {
+        this.#members = members;
+        this.#originals.children = members.map(({ component, name }) => {
+            if (name === undefined)
+                return component;
+            let offset = 0;
+            return {
+                render(width) {
+                    const rows = component.render(width);
+                    // Pi adds one leading separator per tool; the group supplies its own spacing.
+                    offset = rows[0] === "" ? 1 : 0;
+                    return rows.slice(offset);
+                },
+                handleMouse(event) {
+                    return component.handleMouse?.({
+                        ...event,
+                        y: event.y + offset,
+                        height: event.height + offset,
+                    });
+                },
+                invalidate() { },
+            };
+        });
+    }
+    invalidate() {
+        // Original chatContainer.invalidate invalidates original members exactly once.
+        this.#header.invalidate();
+    }
+    render(width) {
+        this.#renderedExpanded = this.#expanded || this.#context.ui.getToolsExpanded();
+        const theme = this.#context.ui.theme;
+        const counts = new Map();
+        for (const member of this.#members) {
+            if (member.name !== undefined)
+                counts.set(member.name, (counts.get(member.name) ?? 0) + 1);
+        }
+        const heading = [...counts]
+            .map(([name, count]) => `${theme.fg("toolTitle", theme.bold(name))} ${theme.fg("dim", `×${count}`)}`)
+            .join(theme.fg("dim", " · "));
+        this.#header.setText(truncateToWidth(`${theme.fg("dim", this.#renderedExpanded ? "▾" : "▸")} ${heading}`, Math.max(0, width), "…"));
+        return super.render(width);
+    }
+}
+function attach(host, context) {
+    const chat = host.chat;
+    const original = {
+        render: chat.render,
+        handleMouse: chat.handleMouse,
+        invalidate: chat.invalidate,
+    };
+    const descriptors = Object.getOwnPropertyDescriptors(chat);
+    for (const key of ["render", "handleMouse", "invalidate"]) {
+        const descriptor = descriptors[key];
+        if (descriptor !== undefined && descriptor.writable !== true) {
+            throw new Error(`Pi transcript ${key} cannot be replaced`);
+        }
+    }
+    if (!Object.isExtensible(chat))
+        throw new Error("Pi transcript cannot accept instance methods");
+    const projection = new Container();
+    let groups = new Map();
+    let active = true;
+    const rebuild = () => {
+        const next = new Map();
+        const children = [];
+        let calls = new Set();
+        let members = [];
+        const flush = () => {
+            const first = members[0]?.component;
+            if (first !== undefined && members.filter((member) => member.name !== undefined).length > 1) {
+                const group = groups.get(first) ?? new ToolGroup(context, host.requestRender);
+                group.update(members);
+                next.set(first, group);
+                children.push(group);
+            }
+            else
+                children.push(...members.map((member) => member.component));
+            members = [];
+        };
+        for (const child of chat.children) {
+            if (child instanceof AssistantMessageComponent) {
+                const info = assistantInfo(child);
+                calls = info.calls;
+                if (info.eligible) {
+                    members.push({
+                        component: child,
+                        ...(info.thinking ? { summary: context.ui.theme.fg("thinkingText", "thinking…") } : {}),
+                    });
+                    continue;
+                }
+            }
+            else if (child instanceof ToolExecutionComponent) {
+                const member = toolMember(child, calls);
+                if (member !== undefined) {
+                    members.push(member);
+                    continue;
+                }
+            }
+            else if (child instanceof NotifyView) {
+                members.push({ component: child, summary: child.summary });
+                continue;
+            }
+            flush();
+            children.push(child);
+        }
+        flush();
+        groups = next;
+        projection.children = children;
+    };
+    const wrappers = {
+        render(width) {
+            if (!active)
+                return original.render.call(chat, width);
+            try {
+                rebuild();
+            }
+            catch (error) {
+                active = false;
+                groups.clear();
+                projection.clear();
+                context.ui.notify(`Tool grouping disabled: ${error instanceof Error ? error.message : String(error)}`, "warning");
+                return original.render.call(chat, width);
+            }
+            // Real renderer errors propagate; never hide a tool-rendering failure.
+            return projection.render(width);
+        },
+        handleMouse(event) {
+            return active ? projection.handleMouse(event) : original.handleMouse.call(chat, event);
+        },
+        invalidate() {
+            original.invalidate.call(chat);
+            for (const group of groups.values())
+                group.invalidate();
+        },
+    };
+    Object.assign(chat, wrappers);
+    host.requestRender();
+    let disposed = false;
+    return {
+        notify(message, type) {
+            if (!active)
+                return false;
+            chat.addChild(new NotifyView(message, type, context));
+            host.requestRender();
+            return true;
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            active = false;
+            groups.clear();
+            projection.clear();
+            let conflict = false;
+            for (const key of ["render", "handleMouse", "invalidate"]) {
+                if (chat[key] !== wrappers[key]) {
+                    conflict = true;
+                    continue;
+                }
+                const descriptor = descriptors[key];
+                if (descriptor === undefined)
+                    Reflect.deleteProperty(chat, key);
+                else
+                    Object.defineProperty(chat, key, descriptor);
+            }
+            if (conflict)
+                context.ui.notify("Tool grouping patch changed by another extension; restart Pi to fully unload it.", "warning");
+            host.requestRender();
+        },
+    };
+}
+function connect(owner, host) {
+    if (owner.hosts.has(host.chat) || owner.failed.has(host.chat))
+        return;
+    try {
+        owner.hosts.set(host.chat, { ...owner.attach(host), requestRender: host.requestRender });
+    }
+    catch (error) {
+        owner.failed.add(host.chat);
+        owner.context.ui.notify(`Tool grouping unavailable: ${error instanceof Error ? error.message : String(error)}`, "warning");
+    }
+}
+function patchState() {
+    const prototype = InteractiveMode.prototype;
+    const key = Symbol.for("@hheei/pi-ext-ui/host-tool-groups/2");
+    const existing = Reflect.get(prototype, key);
+    if (existing !== undefined) {
+        if (!record(existing) ||
+            !(existing.owners instanceof Map) ||
+            !(existing.hosts instanceof Set) ||
+            !record(existing.originals) ||
+            !record(existing.wrappers) ||
+            SEAMS.some((seam) => !record(existing.originals[seam]) || typeof existing.wrappers[seam] !== "function"))
+            throw new Error("Invalid tool grouping patch owner");
+        return existing;
+    }
+    const lookup = Object.getOwnPropertyDescriptor(prototype, SEAMS[0]);
+    const notify = Object.getOwnPropertyDescriptor(prototype, SEAMS[1]);
+    if (typeof lookup?.value !== "function" ||
+        !lookup.writable ||
+        lookup.value.length !== 1 ||
+        typeof notify?.value !== "function" ||
+        !notify.writable ||
+        notify.value.length !== 2)
+        throw new Error("Pi tool/notification seam changed or is already patched");
+    const owners = new Map();
+    const hosts = new Set();
+    const seen = new WeakSet();
+    const failed = new WeakSet();
+    const locate = (instance) => {
+        if (owners.size === 0 || (record(instance) && failed.has(instance)))
+            return undefined;
+        let host;
+        try {
+            host = readHost(instance);
+        }
+        catch (error) {
+            if (record(instance))
+                failed.add(instance);
+            for (const owner of owners.values())
+                owner.context.ui.notify(`Tool grouping unavailable: ${error instanceof Error ? error.message : String(error)}`, "warning");
+            return undefined;
+        }
+        if (record(instance) && !seen.has(instance)) {
+            seen.add(instance);
+            hosts.add(new WeakRef(instance));
+        }
+        const owner = owners.get(host.ui);
+        if (owner === undefined)
+            return undefined;
+        connect(owner, host);
+        return { owner, host };
+    };
+    const state = {
+        owners,
+        hosts,
+        originals: { getRegisteredToolDefinition: lookup, showExtensionNotify: notify },
+        wrappers: {
+            getRegisteredToolDefinition(name) {
+                const result = Reflect.apply(lookup.value, this, [name]);
+                locate(this);
+                return result;
+            },
+            showExtensionNotify(message, type) {
+                const match = locate(this);
+                if (match?.owner.hosts.get(match.host.chat)?.notify(message, type ?? "info"))
+                    return;
+                return Reflect.apply(notify.value, this, [message, type]);
+            },
+        },
+    };
+    Object.defineProperty(prototype, key, { value: state });
+    return state;
+}
+/** Private to pi-ext-ui: two process hooks, scoped by the actual host UI facade. */
+export function installHostToolGroups(context) {
+    const parts = VERSION.split(".").map(Number);
+    const [major = 0, minor = 0, patch = 0] = parts;
+    if (parts.length !== 3 ||
+        !parts.every(Number.isInteger) ||
+        !(major > 1 || (major === 1 && (minor > 0 || (minor === 0 && patch >= 1)))))
+        throw new Error(`Tool grouping requires Pi >=1.0.1; running ${VERSION}`);
+    const state = patchState();
+    if (state.owners.has(context.ui))
+        throw new Error("Tool grouping already owns this UI runtime");
+    if (state.owners.size === 0) {
+        for (const seam of SEAMS) {
+            if (Object.getOwnPropertyDescriptor(InteractiveMode.prototype, seam)?.value !==
+                state.originals[seam].value)
+                throw new Error("Pi tool/notification seam was changed by another extension");
+        }
+        for (const seam of SEAMS)
+            Object.defineProperty(InteractiveMode.prototype, seam, {
+                ...state.originals[seam],
+                value: state.wrappers[seam],
+            });
+    }
+    const owner = {
+        context,
+        hosts: new Map(),
+        failed: new WeakSet(),
+        attach: (host) => attach(host, context),
+    };
+    state.owners.set(context.ui, owner);
+    // Reload rebuilds history before session_start; reconnect already discovered instances.
+    for (const reference of state.hosts) {
+        const instance = reference.deref();
+        if (instance === undefined) {
+            state.hosts.delete(reference);
+            continue;
+        }
+        try {
+            const host = readHost(instance);
+            if (host.ui === context.ui)
+                connect(owner, host);
+        }
+        catch {
+            state.hosts.delete(reference);
+        }
+    }
+    let disposed = false;
+    return {
+        requestRender() {
+            for (const host of owner.hosts.values())
+                host.requestRender();
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            state.owners.delete(context.ui);
+            for (const host of owner.hosts.values())
+                host.dispose();
+            owner.hosts.clear();
+            if (state.owners.size !== 0)
+                return;
+            for (const seam of SEAMS) {
+                if (Object.getOwnPropertyDescriptor(InteractiveMode.prototype, seam)?.value ===
+                    state.wrappers[seam])
+                    Object.defineProperty(InteractiveMode.prototype, seam, state.originals[seam]);
+                else
+                    context.ui.notify("Tool grouping seam changed by another extension; restart Pi to fully unload it.", "warning");
+            }
+        },
+    };
+}

package/dist/payload-parser.d.ts

@@ -1,4 +1,4 @@
-import { type AgentToolResult } from "@earendil-works/pi-coding-agent";
+import type { AgentToolResult } from "@earendil-works/pi-coding-agent";
 import { type DiffSource } from "./diff-view.js";
 import type { ToolStatusKind } from "./tool-view.js";
 export declare const EDIT_TOOL_NAME = "edit";

package/dist/payload-parser.js

@@ -1,10 +1,18 @@
-import { formatReadLineRange } from "@earendil-works/pi-coding-agent";
 import { stripTerminalSequences } from "@earendil-works/pi-tui";
 import { diffStats } from "./diff-view.js";
 export const EDIT_TOOL_NAME = "edit";
 export const WRITE_TOOL_NAME = "write";
 export const CODEMODE_OPTIONS_PREFIX = "// @options:";
 export const CODEMODE_SCRIPT_HEADER = /^Script (?:completed|failed)\r?\nWall time ([\d.]+) seconds\r?\nOutput:\r?\n/;
+// Pi <1.3 has no exported read-range formatter. Keep this UI summary independent of that export.
+function readLineNumber(value) {
+    const parsed = typeof value === "number"
+        ? value
+        : typeof value === "string" && value.trim() !== ""
+            ? Number(value)
+            : Number.NaN;
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
 export function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -280,7 +288,16 @@ export function fileToolPresentation(toolName, args, _details, isError) {
         if (path === "")
             return undefined;
         const parsed = parseCallArgs(args);
-        const range = formatReadLineRange(parsed?.offset, parsed?.limit);
+        const offset = parsed?.offset;
+        const limit = parsed?.limit;
+        const start = offset == null ? 1 : readLineNumber(offset);
+        const count = limit == null ? undefined : readLineNumber(limit);
+        const end = start !== undefined && count !== undefined ? start + count - 1 : undefined;
+        const range = (offset == null && limit == null) ||
+            start === undefined ||
+            (limit != null && count === undefined)
+            ? ""
+            : `:${start}${end ? `-${end}` : ""}`;
         return { summary: `${path}${range}`, status: isError ? "error" : "ok" };
     }
     if (toolName === WRITE_TOOL_NAME) {

package/dist/renderer.d.ts

@@ -1,5 +1,9 @@
 import { type ExtensionAPI, type ToolRendererResolver, type ToolRenderers } from "@earendil-works/pi-coding-agent";
-export type ToolRenderContext = Parameters<NonNullable<ToolRenderers["renderCall"]>>[2];
+/** Optional host metadata is absent on early supported Pi versions. */
+export type ToolRenderContext = Parameters<NonNullable<ToolRenderers["renderCall"]>>[2] & {
+    readonly durationMs?: number | undefined;
+    readonly outputPad?: number | undefined;
+};
 /**
  * Upstream tools whose call and result views pi-ext-ui still frames itself. Concrete tool packages
  * own their own presentation through ext-core's optional renderer point, so their names never

package/dist/renderer.js

@@ -107,12 +107,10 @@ function rememberCallView(context, view) {
 }
 /**
  * A result view takes over from the call view. A container tool yields on any result, because its
- * own row would duplicate the nested rows and output it now carries; every other tool keeps its
- * call row until the final result. A provider states that for its own tool, so no name is involved.
+ * own row would duplicate the nested rows and output it now carries. A mounted result view takes
+ * over from its call view, including during partial updates. A provider states container semantics.
  */
-function hideCallView(context, replaceCallOnPartial, isPartial) {
-    if (!replaceCallOnPartial && isPartial)
-        return;
+function hideCallView(context) {
     const view = isRecord(context.state) ? context.state[CALL_VIEW_STATE_KEY] : undefined;
     if (view instanceof ToolView)
         view.hide();
@@ -652,9 +650,7 @@ function createRendererResolver(options, resolvePresentation, resolveNativeRende
                     : provider(resultContext.args, result, theme, resultContext);
                 // Without an owner, a container frame is the only name-based decision left, and it
                 // belongs to upstream codemode.
-                const replacesCallOnPartial = presentation?.replaceCallOnPartial === true ||
-                    (presentation === undefined && SPECIALIZED_TOOL_SET.has(toolName));
-                hideCallView(context, replacesCallOnPartial, renderOptions.isPartial);
+                hideCallView(context);
                 if (presentation !== undefined) {
                     return renderOwnedPresentation({
                         toolName,

package/dist/settings.d.ts

@@ -0,0 +1,6 @@
+import { type SettingsProvider, type SettingsState } from "@hheei/pi-ext-core";
+/** Missing or non-boolean values stay on; only an explicit false disables groups. */
+export declare function activityGroupsEnabled(state: SettingsState | undefined): boolean;
+export declare function createToolGroupSettings(options: {
+    readonly onEnabled: (enabled: boolean) => void;
+}): SettingsProvider;

package/dist/settings.js

@@ -0,0 +1,36 @@
+import { createJsonSettingsStorage, } from "@hheei/pi-ext-core";
+const GROUP = "toolGroups";
+const FIELD = "enabled";
+/** Missing or non-boolean values stay on; only an explicit false disables groups. */
+export function activityGroupsEnabled(state) {
+    const value = state?.[GROUP]?.[FIELD];
+    return value !== false;
+}
+export function createToolGroupSettings(options) {
+    return {
+        id: "pi-ext-ui",
+        title: "Tool UI",
+        origin: "@hheei/pi-ext-ui",
+        groups: [
+            {
+                id: GROUP,
+                title: "Tool activity",
+                fields: [
+                    {
+                        id: FIELD,
+                        label: "Activity groups",
+                        type: "boolean",
+                        defaultValue: true,
+                        description: "Group consecutive tool, thinking, and notification rows in the TUI transcript.",
+                        parse: (draft) => draft === "true",
+                    },
+                ],
+            },
+        ],
+        storage: createJsonSettingsStorage({ group: GROUP }),
+        onChange(change) {
+            if (change.groupId === GROUP && change.fieldId === FIELD)
+                options.onEnabled(change.value === true);
+        },
+    };
+}

package/dist/tool-view.d.ts

@@ -45,6 +45,8 @@ export interface ToolViewSpec {
 export declare function createToolView(spec: ToolViewSpec): ToolView;
 export declare const MAX_LEVEL2_SECTION_LINES = 500;
 export declare const MAX_LEVEL2_BYTES: number;
+/** Internal transcript composition: original components keep their layout and interactions. */
+export declare function renderWithoutToolRails(component: Component, width: number): string[];
 export declare function transitionFoldLevel(current: FoldLevel, ctrlKey: boolean): FoldLevel;
 export declare function formatStatusGlyph(status: ToolStatusKind | undefined, theme: Theme): string;
 /**
@@ -83,6 +85,8 @@ export declare class ToolView implements Component {
     get foldLevel(): FoldLevel;
     get effectiveLevel(): FoldLevel;
     get collapsed(): boolean;
+    /** Current semantic header, without fold/copy controls or body; hidden slots have no summary. */
+    get summary(): string | undefined;
     setFoldLevel(next: FoldLevel): void;
     setCollapsed(collapsed: boolean): void;
     toggle(ctrlKey?: boolean): void;

package/dist/tool-view.js

@@ -18,6 +18,17 @@ const DEFAULT_MAX_SECTION_LINES = 9;
 export const MAX_LEVEL2_SECTION_LINES = 500;
 export const MAX_LEVEL2_BYTES = 64 * 1024;
 const DEFAULT_COPY_FEEDBACK_MS = 1200;
+let outerRailDepth = 0;
+/** Internal transcript composition: original components keep their layout and interactions. */
+export function renderWithoutToolRails(component, width) {
+    outerRailDepth++;
+    try {
+        return component.render(width);
+    }
+    finally {
+        outerRailDepth--;
+    }
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -209,6 +220,7 @@ export class ToolView {
     #localTimer;
     #lastWidth = 80;
     #lastHeight = 0;
+    #lastNoRail = false;
     #cache;
     constructor(spec) {
         this.#spec = spec;
@@ -247,16 +259,15 @@ export class ToolView {
         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;
+        return this.#spec.globalExpanded === true ? 2 : this.foldLevel;
     }
     get collapsed() {
         return this.foldLevel === 0;
     }
+    /** Current semantic header, without fold/copy controls or body; hidden slots have no summary. */
+    get summary() {
+        return this.#hidden ? undefined : formatToolHeaderText(this.#spec.header, this.#spec.theme);
+    }
     #collapseChildren() {
         const { collapsedRows, collapsibleChildren } = this.#spec;
         if (collapsibleChildren !== undefined) {
@@ -284,7 +295,7 @@ export class ToolView {
         this.setFoldLevel(collapsed ? 0 : 1);
     }
     toggle(ctrlKey = false) {
-        this.setFoldLevel(transitionFoldLevel(this.foldLevel, ctrlKey));
+        this.setFoldLevel(transitionFoldLevel(this.effectiveLevel, ctrlKey));
     }
     #triggerCopy(shiftKey) {
         const copySpec = this.#spec.copy;
@@ -363,7 +374,7 @@ export class ToolView {
         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 noRail = options?.noRail ?? (outerRailDepth > 0 || this.#spec.noRail === true);
         const innerWidth = noRail ? safeWidth : Math.max(1, safeWidth - 2);
         const output = [];
         if (level === 0) {
@@ -420,15 +431,18 @@ export class ToolView {
             return [];
         const level = this.effectiveLevel;
         const copied = isCopiedActive(this.#spec.stateHolder, this.#localCopiedUntil);
+        const noRail = outerRailDepth > 0 || this.#spec.noRail === true;
         if (this.#cache !== undefined &&
             this.#cache.width === width &&
             this.#cache.level === level &&
+            this.#cache.noRail === noRail &&
             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;
+        this.#lastNoRail = noRail;
         if (level !== 0) {
             this.#collapseChildren();
         }
@@ -447,7 +461,7 @@ export class ToolView {
             }
         }
         this.#lastHeight = safeLines.length;
-        this.#cache = { width, level, copied, lines: safeLines };
+        this.#cache = { width, level, copied, noRail, lines: safeLines };
         return safeLines;
     }
     handleMouse(event) {
@@ -488,7 +502,7 @@ export class ToolView {
                 "handleMouse" in rows &&
                 typeof rows.handleMouse === "function") {
                 const handler = rows.handleMouse;
-                const railOffset = this.#spec.noRail ? 0 : 2;
+                const railOffset = this.#lastNoRail ? 0 : 2;
                 const subEvent = {
                     ...event,
                     y: event.y - 1,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hheei/pi-ext-ui",
-  "version": "0.4.2",
+  "version": "0.5.1",
   "description": "Collapsible tool rendering frame and tool renderer pilot for Pi.",
   "type": "module",
   "main": "dist/index.js",
@@ -36,11 +36,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@hheei/pi-ext-core": "^0.6.0"
+    "@hheei/pi-ext-core": "^0.6.4"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": ">=1.3.0",
-    "@earendil-works/pi-tui": ">=1.3.0"
+    "@earendil-works/pi-coding-agent": ">=1.0.1",
+    "@earendil-works/pi-tui": ">=1.0.1"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "1.3.0",