pi-pretty-tui 0.2.6 → 0.2.8

package/README.md

@@ -6,8 +6,8 @@ A beautiful, polished TUI for the [Pi coding agent](https://pi.dev/).
 
 ## Features
 
-- **Collapsible activity timeline:** instead of filling the conversation with individual calls, thoughts, tools, and ordinary `info` notifications share one chronological activity stream. Work appears beneath a single `Running(...)` row and settles into a quiet `Done(...)` row. Parent rows distinguish top-level tool calls, nested calls, and thoughts; expanding one reveals every ordered member with summaries retained above nested details. Thoughts and tools are peers: a turn that calls no tool still gets its own `Running(1 thought)` / `Done(1 thought)` parent row with the Thought as its child, so thinking is never dropped.
-- **Live working duration:** in clean mode, elapsed time appears beside `Working` in the prompt editor's top border, using the border's own color. It shares the agent-run clock and duration format with the completion footer, includes automatic retries, and disappears when the run settles. Narrow editors omit the timer when it cannot fit. The clean-mode `Running` parent dot alternates between `accent` and `dim` about every 800 ms; its label and tool dots stay stable, and the pulse stops when the run settles. Expanded `Done` titles and markers use the theme's `success` color; collapsed summaries remain quiet gray.
+- **Collapsible activity timeline:** instead of filling the conversation with individual calls, thoughts, tools, and ordinary `info` notifications share one chronological activity stream. Work appears beneath a single `Running(...)` row and settles into a quiet `Done(...)` row. Parent rows show a combined total of top-level and nested tool calls, plus thoughts; expanding one reveals every ordered member with summaries retained above nested details. Thoughts and tools are peers: a turn that calls no tool still gets its own `Running(1 thought)` / `Done(1 thought)` parent row with the Thought as its child, so thinking is never dropped.
+- **Live working duration:** in clean mode, elapsed time appears beside `Working` in the prompt editor's top border, using the border's own color. It shares the agent-run clock and duration format with the completion footer, includes automatic retries, and disappears when the run settles. Narrow editors omit the timer when it cannot fit. The clean-mode `Running` parent dot alternates between the prompt editor’s current border color and `dim` about every 800 ms; its label uses that same border color, and tool dots stay stable, and the pulse stops when the run settles. Expanded `Done` titles and markers use the theme's `success` color; collapsed summary dots, titles, and details use `dim`.
 - **Transient UI status:** one line above the editor shows direct Pi UI feedback such as Thinking/tool-output visibility changes. A newer UI status replaces it, and it disappears automatically after ten seconds without entering the transcript or session.
 - **Durable response footers:** once the complete agent run settles—including tools, retries, and compaction—the final answer ends with one quiet gray divider containing the elapsed-work time and, in fullscreen, a `[Copy]` control. It copies only the final visible answer, excluding thoughts, tools, statuses, and the footer itself; the footer survives reloads and session-tree navigation.
 - **Useful details on demand:** tool-aware summaries keep paths, commands, results, diffs, file previews, and live shell output concise without removing access to the original content.
@@ -37,11 +37,15 @@ Displayed custom messages without their own renderer use one generic accent-colo
 
 Pi's direct internal `showStatus()` feedback is transient: it appears only in the status line above the editor, a newer status replaces it, and a ten-second timer removes it. It never enters the transcript or activity timeline and is cleared on reload. In clean mode, `Ctrl+T` and `Ctrl+O` only show short hints to click the corresponding disclosure; neither changes visibility or Pi's Thinking setting. In full and compact modes, both shortcuts keep Pi's native behaviour.
 
+## Error presentation
+
+In clean mode, standalone errors keep their original title and complete text in a compact `✕ Error · reason` layout. Consecutive errors with exactly the same source type, title, and full text share one visible row with a dim `×2` / `×3` count. Other transcript components break the run; errors carrying thought/tool/visible-response content are not folded. This is UI-only: session records and original message components remain unchanged. Long errors wrap without an added preview truncation; full/compact modes keep native presentation.
+
 ## Codemode and nested tools
 
 In clean mode, tools that call other tools through Pi's nested execution API keep their own parent node. Expand the activity group to see each internal call, its status, compact arguments, duration, and result summary. Click an internal call to inspect its arguments and text result independently. Click its expanded body to collapse just that call. Script and script-output bodies also collapse their own sections when clicked. Tool calls use a `●` marker: dim while running, success-colored when successful, and error-colored when failed. Tool names use bold theme text. `[Script]` and `[Script output]` are separate disclosures; the nested parent title is informational and clicking it does not expand or collapse details. Use each section or child to expand and collapse its own details; `Ctrl+O` only shows a hint in clean mode. Extensions can still use Pi's `setToolsExpanded()` API for global control; local disclosures remain usable afterward, and another global API call resets the local overrides. Calls retain their start order even when they finish in parallel. A handled child failure remains marked as failed even if the script succeeds.
 
-The group distinguishes, for example, `1 tool call · 3 nested calls`. Internal calls never become phantom transcript members or displace the end-of-tree collapse action. Ownership uses Pi's `parentToolCallId`, not tool names or JavaScript parsing; wrappers other than codemode benefit too. This requires a Pi version with nested execution events (0.99.0 or later); older Pi keeps its existing display. Full and compact modes retain the native tool presentation.
+The activity-group summary combines top-level and nested calls: one parent call plus three internal calls displays as `4 tool calls`. The parent call itself counts once, while its node retains the nested-call count and tree structure. Internal calls never become phantom transcript members or displace the end-of-tree collapse action. Ownership uses Pi's `parentToolCallId`, not tool names or JavaScript parsing; wrappers other than codemode benefit too. This requires a Pi version with nested execution events (0.99.0 or later); older Pi keeps its existing display. Full and compact modes retain the native tool presentation.
 
 Child text results and edit diffs are saved in hidden, UI-only session entries for reload and branch navigation. Each root retains at most 256 calls, 4,096 characters of arguments per call, 8,192 characters of text per result, and 131,072 characters of arguments/results in total; truncation is indicated. Detail previews also have a 200-line limit, and nested trees display up to eight levels below the root. Old sessions without a snapshot explicitly show that only call metadata was retained. Nested results currently use a generic text presentation, not each third-party renderer, and images are not stored in these snapshots. Root media remains available in native full/compact mode.
 
@@ -61,6 +65,8 @@ In fullscreen mode, left-click a user bubble's body or border to copy its comple
 
 ## Copy code blocks
 
+Rounded code-block lines and corners use `borderMuted`; language labels, `[Copy]`, and code text retain their existing colors.
+
 In fullscreen TUI mode, fenced Markdown code blocks in user and assistant transcript messages include a clickable `[Copy]` control in the top rule:
 
 ```sh
@@ -82,7 +88,7 @@ The suite covers live and restored activity timelines, retries and terminal stat
 
 ## Compatibility notice
 
-The current development and regression-test baseline is **Pi 1.0.1**. User chat bubbles support its direct Markdown layout, keeping their transparent background and content-sized width. Nested execution requires Pi 0.99.0 or later; this is a feature requirement, not a promise that every older Pi release is tested.
+The current development and regression-test baseline is **Pi 1.1.0**. User chat bubbles support its direct Markdown layout, keeping their transparent background and content-sized width. Nested execution requires Pi 0.99.0 or later; this is a feature requirement, not a promise that every older Pi release is tested.
 
 Tool rendering uses Pi's documented extension APIs. Active-tool state follows Pi's built-in execution transitions through its exported interactive components. Clean-mode thought details use the activity hierarchy's own disclosure state; full and compact modes retain Pi's built-in Thinking visibility control. Rendering native user messages as adaptive chat bubbles, rounding the native prompt editor, changing unordered-list markers, and enhancing fenced code blocks require reload-safe runtime patches because Pi does not currently expose public renderer hooks for those presentation details. Markdown enhancements are activated only while rendering user and assistant messages in the main transcript; Markdown created by extension overlays keeps Pi's native layout. Markdown parsing, syntax highlighting, and terminal semantic zones remain handled by Pi.
 

package/README.zh-CN.md

@@ -6,9 +6,9 @@
 
 ## 功能特性
 
-- **可折叠的活动时间线：** 不再让大量独立调用填满对话。思考、工具和普通 `info` 通知会进入同一条按真实时间排序的活动流；工作进行时显示为 `Running(...)`，结束后变为低调的 `Done(...)`。父级分别统计顶层工具调用、嵌套调用和思考数量；展开后可查看所有有序成员，成员摘要在展开嵌套详情后仍然保留。思考与工具地位相同：没有调用任何工具的那一轮同样会有自己的 `Running(1 thought)` / `Done(1 thought)` 父行，思考作为其子级，内容不会被丢弃。
+- **可折叠的活动时间线：** 不再让大量独立调用填满对话。思考、工具和普通 `info` 通知会进入同一条按真实时间排序的活动流；工作进行时显示为 `Running(...)`，结束后变为低调的 `Done(...)`。父级合并统计顶层与嵌套工具调用总数，并单独显示思考数量；展开后可查看所有有序成员，成员摘要在展开嵌套详情后仍然保留。思考与工具地位相同：没有调用任何工具的那一轮同样会有自己的 `Running(1 thought)` / `Done(1 thought)` 父行，思考作为其子级，内容不会被丢弃。
 - **可持久化的回答 footer：** 整轮 Agent 工作真正 settled 后（包括工具、自动重试和 compaction），最终回答底部会显示一条低调的灰色分隔线，工作时长与 fullscreen 模式下的 `[Copy]` 控件都嵌在线中。`[Copy]` 只复制最终可见回答，不包含 thought、工具、状态或 footer；reload 和 session tree 切换后仍会保留。
-- **实时工作计时：** clean 模式下，耗时显示在输入框顶部边框的 `Working` 右侧，颜色与边框一致。它与完成 footer 共用 Agent 整轮工作的计时起点和时长格式，包含自动重试，工作真正结束后消失；窄输入框放不下时会隐藏计时。clean 模式下，`Running` 父节点圆点约每 800 ms 在 `accent` 和 `dim` 间切换；文字与工具圆点保持稳定，整轮结束后停止闪烁。展开后的 `Done` 标题和圆点使用主题的 `success` 色，折叠摘要仍保持低调的灰色。
+- **实时工作计时：** clean 模式下，耗时显示在输入框顶部边框的 `Working` 右侧，颜色与边框一致。它与完成 footer 共用 Agent 整轮工作的计时起点和时长格式，包含自动重试，工作真正结束后消失；窄输入框放不下时会隐藏计时。clean 模式下，`Running` 父节点圆点约每 800 ms 在输入框当前边框色和 `dim` 间切换；`Running` 文字使用相同边框色，工具圆点保持稳定，整轮结束后停止闪烁。展开后的 `Done` 标题和圆点使用主题的 `success` 色，折叠摘要的圆点、标题与内容统一使用 `dim`。
 - **临时 UI 状态：** 编辑器上方的一行只显示 Pi 直接产生的 UI 操作反馈，例如 Thinking 或工具输出可见性变化。新状态会替换旧状态，并在十秒后自动消失，不进入 transcript 或 session。
 - **按需查看有效信息：** 针对不同工具设计的摘要，会简洁呈现路径、命令、结果、diff、文件预览和实时 shell 输出，同时保留查看原始完整内容的能力。
 - **统一、精致的视觉体验：** 透明、右对齐的用户聊天气泡会根据短消息自适应宽度，长消息则在终端宽度的 75% 处换行；气泡使用主题链接色（`mdLink`）的圆角边框，并移除了多余的 `User` 标注。配合圆角输入框、主题感知配色、层级清晰的 Markdown 标题、更清爽的列表，以及带语法高亮的圆角代码块，让整个 TUI 更协调。在 fullscreen 模式下，每个围栏代码块还带有符合原生体验的 `[Copy]` 控件。
@@ -37,11 +37,15 @@ Pi 可能会提示内置工具被覆盖。这是正常现象：pi-pretty-tui 会
 
 Pi 内部直接调用 `showStatus()` 产生的反馈属于临时 UI 状态：它只显示在编辑器上方，新状态替换旧状态，并由十秒 timer 自动清除；它不会进入 transcript 或活动时间线，reload 时也会清除。在 clean 模式下，`Ctrl+T` 和 `Ctrl+O` 都只显示点击对应节点的简短提示，不改变内容可见性或 Pi 的 Thinking 设置。在 full 和 compact 模式下，两者保留 Pi 的原生行为。
 
+## 错误展示
+
+clean 模式下，独立错误保留原始标题和完整内容，以紧凑的 `✕ Error · 原因` 展示。来源类型、标题及完整内容完全一致的相邻错误合为一条可见行，并使用暗色 `×2` / `×3` 标识次数。其他 transcript 组件会打断计数；包含思考、工具或可见回答的错误不参与合并。合并仅影响 UI，不删除或修改会话记录及原始消息组件。长错误完整换行，不增加预览截断；full/compact 模式保留原生展示。
+
 ## Codemode 与嵌套工具
 
 clean 模式下，通过 Pi 嵌套执行 API 调用其他工具的工具保留自己的父节点。展开活动组后，会显示各内部调用的状态、紧凑参数、耗时和结果摘要；点击某个内部调用，可以独立展开其参数和文本结果；点击展开后的正文可收起该调用，脚本和脚本输出正文也可点击收起各自区块。工具统一使用 `●` 圆点：运行中为主题暗色，成功与失败分别为主题成功色与错误色；工具名使用正文色加粗。`[Script]` 和 `[Script output]` 分别控制脚本与汇总输出；嵌套父工具标题仅用于展示，点击不会展开或折叠详情。各区块或子调用通过自己的入口独立展开/收起，`Ctrl+O` 在 clean 模式下只显示提示。扩展仍可通过 Pi 的 `setToolsExpanded()` API 全局控制，之后也可局部展开/收起；再次调用全局 API 会重置局部状态。并行调用按照启动顺序排列，不会随完成顺序跳动。即使脚本捕获错误后成功，失败的子调用仍会明确标记。
 
-活动组会分别统计，例如 `1 tool call · 3 nested calls`。内部调用不会变成不存在的顶层 transcript 成员，也不会挤掉树尾折叠按钮。归属依据 Pi 的 `parentToolCallId`，不依赖工具名或 JavaScript 源码解析，因此其他嵌套调用工具也适用。这需要支持嵌套执行事件的 Pi（0.99.0 及以后）；旧版本保持原有显示。full 和 compact 模式保留原生工具展示。
+活动组摘要合并统计顶层与嵌套调用：一个父调用加三个内部调用显示为 `4 tool calls`，父调用本身也计一次；父工具节点仍保留子调用数量和树结构。内部调用不会变成不存在的顶层 transcript 成员，也不会挤掉树尾折叠按钮。归属依据 Pi 的 `parentToolCallId`，不依赖工具名或 JavaScript 源码解析，因此其他嵌套调用工具也适用。这需要支持嵌套执行事件的 Pi（0.99.0 及以后）；旧版本保持原有显示。full 和 compact 模式保留原生工具展示。
 
 子工具的文本结果和 edit diff 会存入隐藏的、仅用于 UI 的 session 条目，支持 reload 和会话分支恢复。每个父调用最多保留 256 个子调用，每项参数最多 4,096 字符，每项文本结果最多 8,192 字符，参数和结果合计最多 131,072 字符；截断会明确提示。每项展开预览还设有 200 行上限，嵌套树最多展示父调用以下八层。没有快照的旧会话会明确显示仅保留调用记录。目前子结果使用通用文本视图，不调用各第三方工具的 renderer，也不在快照中保存图片；父工具自身的媒体结果仍可在原生 full/compact 模式查看。
 
@@ -61,6 +65,8 @@ fullscreen 模式下，左键点击用户气泡的正文或边框，可复制完
 
 ## 复制代码块
 
+代码块的圆角与线条使用 `borderMuted`，语言标签、`[Copy]` 和代码正文保持原有配色。
+
 在 fullscreen TUI 模式下，用户消息与助手回复中的 Markdown 围栏代码块会在顶部边框显示可点击的 `[Copy]` 控件：
 
 ```sh
@@ -82,7 +88,7 @@ npm test
 
 ## 兼容性说明
 
-当前开发与回归测试基线为 **Pi 1.0.1**。用户气泡已适配该版本直接使用 Markdown 的布局，保留透明背景与按内容自适应的宽度。嵌套执行需要 Pi 0.99.0 及以后；这是功能要求，不代表每个旧版都经过测试。
+当前开发与回归测试基线为 **Pi 1.1.0**。用户气泡已适配该版本直接使用 Markdown 的布局，保留透明背景与按内容自适应的宽度。嵌套执行需要 Pi 0.99.0 及以后；这是功能要求，不代表每个旧版都经过测试。
 
 工具渲染使用 Pi 的公开扩展 API。活动工具状态通过 Pi 导出的交互组件跟随其内置执行状态变化；clean 模式的 thought 详情使用活动时间线自身的展开状态，full 和 compact 模式则保留 Pi 内置的 Thinking 可见性控制。由于 Pi 目前没有为这些展示细节提供公开渲染钩子，自适应的原生用户消息气泡、原生输入编辑器圆角、无序列表标记和围栏代码块增强需要使用可安全重载的运行时补丁。Markdown 增强仅在渲染主 transcript 中的用户消息和助手回复时启用；扩展 overlay 创建的 Markdown 保持 Pi 原生布局。Markdown 解析、语法高亮和终端语义区域仍由 Pi 处理。
 

package/extensions/index.ts

@@ -99,6 +99,37 @@ export default function prettyTui(pi: ExtensionAPI) {
   let fullscreenTui = false;
   const mouseClickHitTests = new WeakMap<object, (event: any) => boolean>();
   let currentTui: any;
+  let currentPromptEditor: any;
+  let errorChatContainer: any;
+  const runtimeErrorDescriptors = new WeakMap<object, { source: string; title: string; content: string }>();
+  const errorDescriptor = (component: any) => {
+    const runtime = runtimeErrorDescriptors.get(component);
+    if (runtime) return runtime;
+    if (!(component instanceof AssistantMessageComponent)) return undefined;
+    const message = (component as any).lastMessage;
+    if (message?.stopReason !== "error" || (message.content ?? []).some((item: any) =>
+      item.type === "toolCall" || item.type === "thinking" || item.type === "text" && item.text?.length)) return undefined;
+    return { source: "assistant:error", title: "Error", content: String(message.errorMessage ?? "") };
+  };
+  const errorRun = (component: any) => {
+    const children: any[] = errorChatContainer?.children ?? [];
+    const index = children.indexOf(component);
+    const descriptor = errorDescriptor(component);
+    const same = (other: any) => {
+      const value = errorDescriptor(other);
+      return descriptor && value && value.source === descriptor.source &&
+        value.title === descriptor.title && value.content === descriptor.content;
+    };
+    if (index < 0 || !descriptor) return { hidden: false, count: 1, compact: false };
+    let count = 1;
+    while (index + count < children.length && same(children[index + count])) count++;
+    return { hidden: index > 0 && Boolean(same(children[index - 1])), count,
+      compact: index > 0 && Boolean(errorDescriptor(children[index - 1])) };
+  };
+  const runningColor = (theme: any, text: string): string =>
+    typeof currentPromptEditor?.borderColor === "function"
+      ? currentPromptEditor.borderColor(text)
+      : theme.fg("border", text);
   let currentExtensionUi: any;
   let changingAllToolsExpansion = false;
   const latestActivityWidgetKey = "pretty-tui-latest-activity";
@@ -420,6 +451,10 @@ export default function prettyTui(pi: ExtensionAPI) {
       }
     }
   };
+  const requestActivityRender = (group?: ActivityGroup): void => {
+    if (group) refreshActivityGroup(group);
+    currentTui?.requestRender?.();
+  };
   const revealActivityGroup = (group: ActivityGroup, ui?: any): void => {
     collapsedActivityGroups.delete(group.id);
     revealedActivityGroups.add(group.id);
@@ -544,7 +579,31 @@ export default function prettyTui(pi: ExtensionAPI) {
     );
   };
 
-  const renderPendingActivityUpdate = (member: ActivityMember, width: number): string[] => {
+  const renderStandaloneError = (member: ActivityMember, width: number, component?: any): string[] => {
+    const run = component ? errorRun(component) : { hidden: false, count: 1, compact: false };
+    if (run.hidden) return [];
+    const theme = defaultActivityTheme();
+    const style = activityUpdateStyle(member, theme);
+    const original = component ? errorDescriptor(component) : undefined;
+    const title = stripTerminalSequences(original?.title ?? member.updateTitle ?? "Error");
+    const content = stripTerminalSequences(original?.content || member.updateContent || "");
+    const heading = style.icon + style.title(title);
+    const prefix = heading + (content ? theme.fg("dim", " · ") : "");
+    const text = prefix + theme.fg("muted", content) + (run.count > 1 ? theme.fg("dim", ` ×${run.count}`) : "");
+    // Wrap rather than truncate; all original detail lines remain accessible.
+    const continuation = " ".repeat(Math.min(visibleWidth(prefix), Math.max(0, Math.floor(width / 3))));
+    const rows: string[] = [];
+    for (const line of text.split("\n")) {
+      const wrapped = wrapTextWithAnsi(line, Math.max(1, width - visibleWidth(continuation)));
+      rows.push(...wrapped.map((row, index) => (rows.length || index ? continuation : "") + row));
+    }
+    return [...(run.compact ? [] : [""]), ...rows.map((line) => truncateToWidth(line, Math.max(1, width), ""))];
+  };
+
+  const renderPendingActivityUpdate = (member: ActivityMember, width: number, component?: any): string[] => {
+    if (member.updateSeverity === "error" && member.updateTitle !== "Response truncated") {
+      return renderStandaloneError(member, width, component);
+    }
     const theme = defaultActivityTheme();
     const title = truncateToWidth(member.updateTitle ?? "Update", Math.max(1, width - 2), "…");
     const style = activityUpdateStyle(member, theme);
@@ -563,8 +622,9 @@ export default function prettyTui(pi: ExtensionAPI) {
     group: ActivityGroup,
     member: ActivityMember,
     width: number,
+    component?: any,
   ): string[] => {
-    if (!activityGroupCollapsible(group)) return renderPendingActivityUpdate(member, width);
+    if (!activityGroupCollapsible(group)) return renderPendingActivityUpdate(member, width, component);
     const position = activityMemberPosition(group, member);
     if (!activityGroupRevealed(group)) {
       return position.first
@@ -722,6 +782,7 @@ export default function prettyTui(pi: ExtensionAPI) {
     const originalEditorHandleMouse = customEditorPrototype.handleMouse;
     const patchedEditorTopBorder = function (this: any, width: number, hiddenLineCount: number): string {
       if (this.tui) currentTui = this.tui;
+      currentPromptEditor = this;
       const indicator = this.workingStatusIndicator;
       if (renderMode !== "clean" || indicator?.kind !== "working" || responseRunStartedAt === undefined) {
         return originalEditorTopBorder.call(this, width, hiddenLineCount);
@@ -743,6 +804,7 @@ export default function prettyTui(pi: ExtensionAPI) {
       }
     };
     const patchedEditorRender = function (this: any, width: number): string[] {
+      currentPromptEditor = this;
       if (width < 3) return originalEditorRender.call(this, width);
 
       const innerWidth = width - 2;
@@ -786,6 +848,7 @@ export default function prettyTui(pi: ExtensionAPI) {
     customEditorPrototype.handleMouse = patchedEditorHandleMouse;
 
     pi.on("session_shutdown", () => {
+      currentPromptEditor = undefined;
       const patch = customEditorPrototype[editorFramePatchKey];
       if (!patch) return;
       if (patch.patchedRender === customEditorPrototype.render) {
@@ -1230,7 +1293,7 @@ export default function prettyTui(pi: ExtensionAPI) {
         const terminalGroup = activityTimeline.groupForMember(terminalMember.id);
         if (!terminalGroup) return originalRender.call(this, width);
         activityUpdateComponents.set(terminalMember.id, this);
-        return renderActivityUpdateProjection(terminalGroup, terminalMember, width);
+        return renderActivityUpdateProjection(terminalGroup, terminalMember, width, this);
       }
 
       const key = assistantMessageKey(message);
@@ -1495,10 +1558,14 @@ export default function prettyTui(pi: ExtensionAPI) {
     const group = activityTimeline.groupForMember(member.id);
     if (!group || !mode.chatContainer?.addChild) return false;
     const component: Component = {
-      render: (width: number) => renderActivityUpdateProjection(group, member, width),
+      render: (width: number) => renderActivityUpdateProjection(group, member, width, component),
       invalidate() {},
       handleMouse: (event: any) => handleActivityUpdateMouse(group, member, event),
     } as Component;
+    if (severity === "error") runtimeErrorDescriptors.set(component, {
+      source: "runtime:error", title, content,
+    });
+    errorChatContainer = mode.chatContainer;
     activityUpdateComponents.set(member.id, component);
     mode.chatContainer.addChild(component);
     mode.ui?.requestRender?.();
@@ -1557,6 +1624,7 @@ export default function prettyTui(pi: ExtensionAPI) {
 
     const patchedRenderSessionEntries = function (this: any, entries: any[], options?: any) {
       currentTui = this.ui;
+      errorChatContainer = this.chatContainer;
       fullscreenTui = currentTui?.mode === "fullscreen";
       // buildContextEntries() prepends the latest compaction for model context,
       // while Pi's live compaction UI appends it chronologically. Keep reloads
@@ -1662,6 +1730,7 @@ export default function prettyTui(pi: ExtensionAPI) {
     // calling sites, rather than depend on private chat-container children or
     // instanceof checks (these can be wrapped or come from another module).
     const patchedAddMessageToChat = function (this: any, message: any, ...args: any[]) {
+      errorChatContainer = this.chatContainer;
       if (message?.role === "assistant") cacheMessageContexts.set(this, message);
       else cacheMessageContexts.delete(this);
       return originalAddMessageToChat.call(this, message, ...args);
@@ -1862,6 +1931,7 @@ export default function prettyTui(pi: ExtensionAPI) {
 
     pi.on("session_shutdown", () => {
       fullscreenTui = false;
+      errorChatContainer = undefined;
       currentTui = undefined;
       clearLatestActivityStatus();
       currentExtensionUi = undefined;
@@ -2254,17 +2324,23 @@ export default function prettyTui(pi: ExtensionAPI) {
       );
       const buttonStart = visibleWidth(topPrefix) + fillWidth + (showCopyButton ? 1 : 0);
       const topRule = topPrefix + "─".repeat(fillWidth) + topSuffix;
-      const styledTopRule = this.theme.codeBlockBorder(topRule);
+      const frameBorder = (text: string) => currentExtensionUi?.theme?.fg
+        ? currentExtensionUi.theme.fg("borderMuted", text)
+        : this.theme.codeBlockBorder(text);
+      // Keep labels and Copy at their original contrast; soften only the frame.
+      const styledTopRule = frameBorder("╭─ ") + this.theme.codeBlockBorder(label + " ") +
+        frameBorder("─".repeat(fillWidth)) +
+        (showCopyButton ? this.theme.codeBlockBorder(` ${copyLabel} `) : "") + frameBorder("╮");
       const framedCodeWidth = Math.max(1, frameWidth - 4);
       const lines = [
         styledTopRule,
         ...codeLines.map((line) =>
-          this.theme.codeBlockBorder("│ ") +
+          frameBorder("│ ") +
           line +
           " ".repeat(Math.max(0, framedCodeWidth - visibleWidth(line))) +
-          this.theme.codeBlockBorder(" │")
+          frameBorder(" │")
         ),
-        this.theme.codeBlockBorder(`╰${"─".repeat(Math.max(0, frameWidth - 2))}╯`),
+        frameBorder(`╰${"─".repeat(Math.max(0, frameWidth - 2))}╯`),
       ];
 
       if (showCopyButton && Array.isArray(this[codeBlockCollectionKey])) {
@@ -3103,6 +3179,7 @@ export default function prettyTui(pi: ExtensionAPI) {
   }
 
   const finishCleanGroup = (activity = cleanRun.activity ?? "done") => {
+    const activeGroup = activityTimeline.currentGroup();
     if (cleanRun.lastCompletedToolCallId && cleanRun.count > 0) {
       const group: ToolSummaryGroup = {
         count: cleanRun.count,
@@ -3129,6 +3206,7 @@ export default function prettyTui(pi: ExtensionAPI) {
     cleanRun.activeToolCallId = undefined;
     cleanRun.activeToolName = undefined;
     activityTimeline.boundary();
+    requestActivityRender(activeGroup);
   };
 
   closeCleanAtNativeCustomBoundary = () => {
@@ -3164,7 +3242,8 @@ export default function prettyTui(pi: ExtensionAPI) {
     const activityText = /^thinking(?:\.\.\.)?$/iu.test(normalizedActivityText)
       ? "thinking"
       : rawActivityText;
-    const countLabel = count > 0 ? `${count} tool ${count === 1 ? "call" : "calls"}` : "";
+    const totalCalls = count + nestedCount;
+    const countLabel = totalCalls > 0 ? `${totalCalls} tool ${totalCalls === 1 ? "call" : "calls"}` : "";
     const thoughtLabel = thoughtCount > 0
       ? `${thoughtCount} ${thoughtCount === 1 ? "thought" : "thoughts"}`
       : "";
@@ -3173,7 +3252,7 @@ export default function prettyTui(pi: ExtensionAPI) {
     const activityLabel = count > 0 && activityText !== "done" && activityText.trim()
       ? activityText
       : "";
-    return [countLabel, nestedCount ? `${nestedCount} nested ${nestedCount === 1 ? "call" : "calls"}` : "", thoughtLabel, activityLabel].filter(Boolean).join(" · ");
+    return [countLabel, thoughtLabel, activityLabel].filter(Boolean).join(" · ");
   };
 
   const summaryRow = (
@@ -3190,19 +3269,24 @@ export default function prettyTui(pi: ExtensionAPI) {
       const dimPhase = responseRunStartedAt !== undefined &&
         Math.floor(Math.max(0, Date.now() - responseRunStartedAt) / RUNNING_DOT_INTERVAL_MS) % 2 === 1;
       const color = currentActivity === "done"
-        ? collapsedDone ? "thinkingText" : "success"
+        ? collapsedDone ? "dim" : "success"
         : dimPhase ? "dim" : "accent";
-      return theme.fg(color, "● ");
+      return currentActivity !== "done" && !dimPhase
+        ? runningColor(theme, "● ")
+        : theme.fg(color, "● ");
     },
     continuation: "  ",
     content: () => {
       const currentActivity = typeof activity === "function" ? activity() : activity;
       const label = currentActivity === "done" ? "Done" : "Running";
       const color = label === "Done"
-        ? collapsedDone ? "thinkingText" : "success"
+        ? collapsedDone ? "dim" : "success"
         : "accent";
-      const detailColor = label === "Done" && collapsedDone ? "thinkingText" : "text";
-      return theme.fg(color, theme.bold(label)) +
+      const detailColor = label === "Done" && collapsedDone ? "dim" : "text";
+      const title = label === "Running"
+        ? runningColor(theme, theme.bold(label))
+        : theme.fg(color, theme.bold(label));
+      return title +
         theme.fg("dim", "(") +
         theme.fg(detailColor, summaryText(count, failed, thoughtCount, currentActivity, nestedCount)) +
         theme.fg("dim", ")");
@@ -3256,6 +3340,10 @@ export default function prettyTui(pi: ExtensionAPI) {
     const toolCount = group.toolCallIds.length;
     const nestedCount = group.toolCallIds.reduce((count, id) => count + nestedTools.count(id), 0);
     const live = () => cleanRun.activeToolName ?? currentCleanActivity();
+    const currentGroup = activityTimeline.currentGroup();
+    const isLiveGroup = currentGroup?.id === group.id &&
+      !activityTimeline.isSettled(group.id) &&
+      !cleanRun.settled;
     if (settled) {
       return fit(block([summaryRow(
         summaryTheme,
@@ -3267,8 +3355,8 @@ export default function prettyTui(pi: ExtensionAPI) {
         nestedCount,
       )]).render(width));
     }
-    if (owner && !cleanRun.settled) {
-      // Live tool group: keep the current tool name and the running count.
+    if (owner && isLiveGroup) {
+      // Only the current, unsettled group may consume live run state.
       return fit(block([summaryRow(
         summaryTheme,
         Math.max(toolCount, liveCleanToolCount()),
@@ -3279,8 +3367,8 @@ export default function prettyTui(pi: ExtensionAPI) {
         nestedCount,
       )]).render(width));
     }
-    if (!owner && !activityTimeline.isSettled(group.id)) {
-      // Thought-only group while the model is still working.
+    if (!owner && isLiveGroup) {
+      // Thought-only current group while the model is still working.
       return fit(block([summaryRow(
         summaryTheme,
         toolCount,
@@ -3314,6 +3402,11 @@ export default function prettyTui(pi: ExtensionAPI) {
     cleanToolThemes.set(toolCallId, theme);
     const activityGroup = activityTimeline.groupForTool(toolCallId);
     if (activityGroup) activityFallbackThemes.set(activityGroup.id, theme);
+    const isLiveGroup = !activityGroup || (
+      activityTimeline.currentGroup()?.id === activityGroup.id &&
+      !activityTimeline.isSettled(activityGroup.id) &&
+      !cleanRun.settled
+    );
     return {
       render(width: number): string[] {
         if (renderMode !== "clean") return [];
@@ -3331,7 +3424,7 @@ export default function prettyTui(pi: ExtensionAPI) {
         }
         if (cleanRun.settled) return [];
 
-        if (cleanRun.activeToolCallId === toolCallId) {
+        if (isLiveGroup && cleanRun.activeToolCallId === toolCallId) {
           return block([summaryRow(
             theme,
             liveCleanToolCount(),
@@ -3344,6 +3437,7 @@ export default function prettyTui(pi: ExtensionAPI) {
         // The active tool owns the live Running row. Keep the latest completed
         // portion hidden while that tool's minimum display time is running.
         if (
+          isLiveGroup &&
           cleanRun.lastCompletedToolCallId === toolCallId &&
           cleanRun.count > 0 &&
           !cleanRun.activeToolCallId
@@ -3949,6 +4043,7 @@ export default function prettyTui(pi: ExtensionAPI) {
     cleanRun.active = true;
     cleanRun.activeToolCallId = event.toolCallId;
     beginToolActivity(event.toolCallId, displayName, true);
+    requestActivityRender(activityTimeline.groupForTool(event.toolCallId));
   });
   pi.on("tool_execution_update", (event) => {
     if ((event as any).parentToolCallId) {
@@ -3990,6 +4085,7 @@ export default function prettyTui(pi: ExtensionAPI) {
     }
     const visibleSummaryToolCallId = cleanRun.activeToolCallId ?? cleanRun.lastCompletedToolCallId;
     setCleanGroupMembers(visibleSummaryToolCallId, cleanRun.currentToolCallIds.slice());
+    requestActivityRender(activityTimeline.groupForTool(event.toolCallId));
     // Tool success and failure remain owned by the activity group. The bottom
     // line is reserved for transient UI status messages.
   });
@@ -4029,6 +4125,8 @@ export default function prettyTui(pi: ExtensionAPI) {
     cleanRun.activeToolName = undefined;
     cleanRun.activity = "done";
     cleanRun.settled = true;
+    for (const group of activityTimeline.groups()) refreshActivityGroup(group);
+    currentTui?.requestRender?.();
 
     if (responseRunStartedAt !== undefined) {
       // message_end runs before later extensions can replace the message and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-pretty-tui",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "A beautiful, polished TUI for the Pi coding agent",
   "license": "MIT",
   "author": "Kainan Yang <ykn0309@whu.edu.cn>",
@@ -39,8 +39,8 @@
     "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "1.0.1",
-    "@earendil-works/pi-tui": "1.0.1",
+    "@earendil-works/pi-coding-agent": "1.1.0",
+    "@earendil-works/pi-tui": "1.1.0",
     "@types/node": "^24.0.0",
     "jiti": "^2.7.0",
     "typescript": "^5.9.0"