pi-pretty-tui 0.2.4 → 0.2.5

package/README.md

@@ -6,14 +6,14 @@ 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 count only tool 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.
+- **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. Expanded `Done` titles and markers use the theme's `success` color; collapsed summaries remain quiet gray.
 - **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.
 - **A cohesive visual finish:** transparent, right-aligned user chat bubbles size themselves to short messages and wrap longer ones at 75% of the terminal width, with an accent-blue rounded border and no redundant `User` label. Together with the rounded prompt input, theme-aware colors, clear Markdown heading hierarchy, cleaner lists, and rounded syntax-highlighted code blocks, they make the entire TUI feel intentional. In fullscreen, each fenced code block also includes a native-feeling `[Copy]` control.
 
-Pi's built-in `read`, `bash`, `edit`, `write`, `grep`, `find`, and `ls` tools receive purpose-built compact views. Every third-party tool automatically receives a consistent compact row; opening it preserves its native renderer while removing conflicting terminal background colors. User and steering messages, compaction summaries, visible assistant text, warnings, errors, aborted/truncated responses, and displayed custom messages with a registered renderer create hard group boundaries. Pi's cursor, IME, autocomplete, mouse interaction, and tool execution behavior remain intact.
+Pi's built-in `read`, `bash`, `edit`, `write`, `grep`, `find`, and `ls` tools receive purpose-built compact views. Third-party tools without nested calls automatically receive a consistent compact row; opening it preserves its native renderer while removing conflicting terminal background colors. User and steering messages, compaction summaries, visible assistant text, warnings, errors, aborted/truncated responses, and displayed custom messages with a registered renderer create hard group boundaries. Pi's cursor, IME, autocomplete, mouse interaction, and tool execution behavior remain intact.
 
 ## Install
 
@@ -31,10 +31,22 @@ Click a `Running(...)` or `Done(...)` row to keep it as a parent and reveal tool
 
 Extension calls to `ctx.ui.notify(message, "info")` (or with the type omitted) join an existing thought/tool group in chronological order; without existing work they remain independent and never attach to a future group. Warnings and errors stay standalone, use yellow `⚠` and red `✕`, and are hard boundaries. Tool failures remain owned by their tool details. None of these extension notifications or errors appear in the transient UI-status line.
 
+In clean mode, Pi's native cache-miss notices join the thought/tool group of the assistant message that incurred the miss, as a yellow `⚠` child. They hide and reveal with the group and do not interrupt subsequent tool calls. If that message has no associated work (for example, a text-only final answer), the notice remains independent. Pi still decides whether a notice should appear and formats its token count, cost, model-switch and idle-gap labels; the integration hooks `addCacheMissNotice()` rather than matching text. Historical notices are re-derived on rebuild, not written as extra session entries. Full and compact modes retain Pi's native presentation.
+
 Displayed custom messages without their own renderer use one generic accent-coloured `◇` Markdown presentation: they join current thought/tool work when it exists, otherwise remain independent, and preserve their session persistence. Messages with a registered renderer remain completely native and form hard boundaries. These decisions use only Pi's notification type and renderer presence—never extension names, custom message names, or content heuristics.
 
 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` leaves Pi's persisted Thinking setting unchanged and shows a short hint instead: thought details expand only when their own row is clicked, while `Ctrl+O` retains global activity expansion. In full and compact modes, `Ctrl+T` keeps Pi's native behaviour.
 
+## 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. Successful and failed tool calls consistently use a `●` marker in the theme's success and error colors, respectively. `[Script]` and `[Script output]` are separate disclosures; clicking the parent tool or pressing `Ctrl+O` expands all its details. 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.
+
+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.
+
+These UI entries do not change the script's output or the model's tool results. They **do** save child text that a script may never have printed: treat session files as potentially sensitive. Common credential argument keys are redacted; tool output is not guaranteed to be free of secrets.
+
 ## Settings and rendering modes
 
 Run `/pretty-tui` to open the extension settings. The `Enabled` switch persists whether pi-pretty-tui installs its render patches and built-in tool renderers. Changing it automatically runs Pi's official reload flow, so no manual `/reload` is needed. You can also use `/pretty-tui enable` and `/pretty-tui disable` directly. While disabled, the settings command remains available and Pi uses its native rendering.
@@ -64,6 +76,8 @@ 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.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.
 
 No Pi source files are modified. Runtime patches are removed during session shutdown, but a future Pi release may require this extension to be updated.

package/README.zh-CN.md

@@ -6,14 +6,14 @@
 
 ## 功能特性
 
-- **可折叠的活动时间线：** 不再让大量独立调用填满对话。思考、工具和普通 `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 整轮工作的计时起点和时长格式，包含自动重试，工作真正结束后消失；窄输入框放不下时会隐藏计时。展开后的 `Done` 标题和圆点使用主题的 `success` 色，折叠摘要仍保持低调的灰色。
 - **临时 UI 状态：** 编辑器上方的一行只显示 Pi 直接产生的 UI 操作反馈，例如 Thinking 或工具输出可见性变化。新状态会替换旧状态，并在十秒后自动消失，不进入 transcript 或 session。
 - **按需查看有效信息：** 针对不同工具设计的摘要，会简洁呈现路径、命令、结果、diff、文件预览和实时 shell 输出，同时保留查看原始完整内容的能力。
 - **统一、精致的视觉体验：** 透明、右对齐的用户聊天气泡会根据短消息自适应宽度，长消息则在终端宽度的 75% 处换行；气泡使用 accent 浅蓝色圆角边框，并移除了多余的 `User` 标注。配合圆角输入框、主题感知配色、层级清晰的 Markdown 标题、更清爽的列表，以及带语法高亮的圆角代码块，让整个 TUI 更协调。在 fullscreen 模式下，每个围栏代码块还带有符合原生体验的 `[Copy]` 控件。
 
-Pi 内置的 `read`、`bash`、`edit`、`write`、`grep`、`find` 和 `ls` 工具使用专门设计的紧凑视图；所有第三方工具会自动获得统一的紧凑行，单独展开时继续使用原生 renderer，但会移除与整体冲突的终端背景色。用户与 steer 消息、compaction 摘要、可见 assistant 正文、warning、error、aborted/length 响应，以及注册了专用 renderer 的 displayed custom message 都会形成硬分组边界。同时不会影响 Pi 原有的光标、输入法、自动补全、鼠标交互和工具执行行为。
+Pi 内置的 `read`、`bash`、`edit`、`write`、`grep`、`find` 和 `ls` 工具使用专门设计的紧凑视图；没有嵌套调用的第三方工具会自动获得统一的紧凑行，单独展开时继续使用原生 renderer，但会移除与整体冲突的终端背景色。用户与 steer 消息、compaction 摘要、可见 assistant 正文、warning、error、aborted/length 响应，以及注册了专用 renderer 的 displayed custom message 都会形成硬分组边界。同时不会影响 Pi 原有的光标、输入法、自动补全、鼠标交互和工具执行行为。
 
 ## 安装
 
@@ -31,10 +31,22 @@ Pi 可能会提示内置工具被覆盖。这是正常现象：pi-pretty-tui 会
 
 扩展调用 `ctx.ui.notify(message, "info")`（或省略 type）时，如果当前已有 thought/tool 活动组，通知会按真实时间顺序加入该组；如果没有现有工作，则独立显示，并且不会附着到未来的工具组。warning 和 error 保持独立，分别使用黄色 `⚠` 和红色 `✕`，并形成硬边界。工具失败继续归属于对应工具详情。上述扩展通知和错误都不会进入临时 UI 状态栏。
 
+在 clean 模式下，Pi 原生的 cache miss 提示以黄色 `⚠` 子节点加入产生该次缓存未命中的 assistant 消息所属的 thought/tool 活动组，随组折叠与展开，并且不会打断后续工具调用。如果该消息没有关联的工作（例如只输出正文的最终回答），提示保持独立。是否显示提示，以及 token 数、成本、模型切换和空闲时长等文案仍由 Pi 决定；接管的是 `addCacheMissNotice()` 入口，不匹配文本。历史提示在重建时重新推导，不额外写入会话记录。full 和 compact 模式保留 Pi 原生样式。
+
 没有自有 renderer 的 displayed custom message 使用统一、accent 配色的 `◇` Markdown 显示：当前存在 thought/tool 工作时加入当前组，否则独立显示，并保留 session 持久化。注册了 renderer 的消息完全保留插件原生显示并形成硬边界。所有判断只依据 Pi 的通知 type 和 renderer 是否存在，不识别扩展名称、custom message 名称，也不根据文本内容推断语义。
 
 Pi 内部直接调用 `showStatus()` 产生的反馈属于临时 UI 状态：它只显示在编辑器上方，新状态替换旧状态，并由十秒 timer 自动清除；它不会进入 transcript 或活动时间线，reload 时也会清除。在 clean 模式下，`Ctrl+T` 不修改 Pi 持久化的 Thinking 设置，只显示一条简短提示；thought 详情仅在点击对应子项时展开，`Ctrl+O` 继续负责全局活动展开。在 full 和 compact 模式下，`Ctrl+T` 保留 Pi 的原生行为。
 
+## Codemode 与嵌套工具
+
+clean 模式下，通过 Pi 嵌套执行 API 调用其他工具的工具保留自己的父节点。展开活动组后，会显示各内部调用的状态、紧凑参数、耗时和结果摘要；点击某个内部调用，可以独立展开其参数和文本结果；点击展开后的正文可收起该调用，脚本和脚本输出正文也可点击收起各自区块。成功与失败的工具统一使用主题成功色与错误色的 `●` 圆点。`[Script]` 和 `[Script output]` 分别控制脚本与汇总输出；点击父工具或按 `Ctrl+O` 会展开全部详情。并行调用按照启动顺序排列，不会随完成顺序跳动。即使脚本捕获错误后成功，失败的子调用仍会明确标记。
+
+活动组会分别统计，例如 `1 tool call · 3 nested 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 模式查看。
+
+这些 UI 条目不会修改脚本输出或模型收到的工具结果，但**会保存脚本可能未打印的子工具文本**，因此请将 session 文件视为可能含有敏感信息。常见凭证参数键会被遮盖，工具输出则不保证已清除所有敏感内容。
+
 ## 设置与渲染模式
 
 运行 `/pretty-tui` 可打开扩展设置。`Enabled` 开关会持久化控制 pi-pretty-tui 是否安装渲染补丁和内置工具 renderer。修改后会自动调用 Pi 官方的 reload 流程，无需手动执行 `/reload`。也可以直接使用 `/pretty-tui enable` 和 `/pretty-tui disable`。禁用期间设置命令仍然可用，Pi 会恢复原生渲染。
@@ -64,6 +76,8 @@ npm test
 
 ## 兼容性说明
 
+当前开发与回归测试基线为 **Pi 1.0.0**。用户气泡已适配该版本直接使用 Markdown 的布局，保留透明背景与按内容自适应的宽度。嵌套执行需要 Pi 0.99.0 及以后；这是功能要求，不代表每个旧版都经过测试。
+
 工具渲染使用 Pi 的公开扩展 API。活动工具状态通过 Pi 导出的交互组件跟随其内置执行状态变化；clean 模式的 thought 详情使用活动时间线自身的展开状态，full 和 compact 模式则保留 Pi 内置的 Thinking 可见性控制。由于 Pi 目前没有为这些展示细节提供公开渲染钩子，自适应的原生用户消息气泡、原生输入编辑器圆角、无序列表标记和围栏代码块增强需要使用可安全重载的运行时补丁。Markdown 增强仅在渲染主 transcript 中的用户消息和助手回复时启用；扩展 overlay 创建的 Markdown 保持 Pi 原生布局。Markdown 解析、语法高亮和终端语义区域仍由 Pi 处理。
 
 本扩展不会修改 Pi 源文件。运行时补丁会在会话关闭时移除，但未来的 Pi 版本可能需要本扩展同步适配。

package/extensions/activity-timeline.ts

@@ -177,6 +177,44 @@ export class ActivityTimeline {
     return this.appendUpdate(group!, updateKey, title, content, persistent, severity);
   }
 
+  /** A native notice is inserted immediately after the message's last member,
+   * even when the rest of the branch was already restored into this timeline. */
+  addUpdateAfterMember(
+    anchorId: string,
+    updateKey: string,
+    title: string,
+    content: string,
+    severity: ActivitySeverity = "info",
+  ): ActivityMember | undefined {
+    const existing = this.memberForUpdate(updateKey);
+    if (existing) return existing;
+    const group = this.groupForMember(anchorId);
+    if (!group) return undefined;
+    const member = this.addUpdateToGroup(group.id, updateKey, title, content, false, severity);
+    if (!member) return undefined;
+    group.members.pop(); // addUpdateToGroup appended this new member
+    const index = group.members.findIndex((child) => child.id === anchorId);
+    group.members.splice(index + 1, 0, member);
+    return member;
+  }
+
+  /** Standalone derived notices must not change the live/last restored group. */
+  addStandaloneUpdate(
+    updateKey: string,
+    title: string,
+    content: string,
+    severity: ActivitySeverity = "info",
+  ): ActivityMember {
+    const existing = this.memberForUpdate(updateKey);
+    if (existing) return existing;
+    const previous = this.currentGroupId;
+    this.currentGroupId = undefined;
+    const member = this.addPendingUpdate(updateKey, title, content, false, severity);
+    this.boundary();
+    this.currentGroupId = previous;
+    return member;
+  }
+
   private appendUpdate(
     group: ActivityGroup,
     updateKey: string,
@@ -237,6 +275,24 @@ export class ActivityTimeline {
     return memberId ? this.member(memberId) : undefined;
   }
 
+  /** Remove a re-derived UI notice without splitting or settling real work. */
+  discardUpdate(updateKey: string): void {
+    const memberId = this.updateMembers.get(updateKey);
+    if (!memberId) return;
+    const group = this.groupForMember(memberId);
+    if (group) {
+      group.members = group.members.filter((member) => member.id !== memberId);
+      if (!group.members.length) {
+        this.groupsById.delete(group.id);
+        this.settledGroups.delete(group.id);
+        if (this.currentGroupId === group.id) this.currentGroupId = undefined;
+      }
+    }
+    this.updateMembers.delete(updateKey);
+    this.memberGroups.delete(memberId);
+    this.membersById.delete(memberId);
+  }
+
   /**
    * Releases a claimed update and splits the group at that point, so a native
    * custom renderer can take the message over without the remaining members

package/extensions/index.ts

@@ -1,3 +1,4 @@
+import { NestedTools, NESTED_SNAPSHOT_ENTRY } from "./nested-tools.js";
 import {
   AssistantMessageComponent,
   CustomEditor,
@@ -223,6 +224,11 @@ export default function prettyTui(pi: ExtensionAPI) {
     return `${hours}h ${String(minutes).padStart(2, "0")}m`;
   };
   const activityTimeline = new ActivityTimeline();
+  const nestedTools = new NestedTools();
+  const refreshNestedTools = (id: string) => {
+    cleanToolComponents.get(nestedTools.root(id))?.updateDisplay?.();
+    currentTui?.requestRender?.();
+  };
   const revealedActivityGroups = new Set<string>();
   // A local collapse must still work when Ctrl+O has expanded every group.
   const collapsedActivityGroups = new Set<string>();
@@ -236,6 +242,8 @@ export default function prettyTui(pi: ExtensionAPI) {
     component: Markdown;
   }>();
   let activityUpdateSequence = 0;
+  // Assigned by the interactive-mode patch below; tool events carry no `this`.
+  let flushDeferredCacheNotices: ((toolCallId: string) => void) | undefined;
   const assistantBoundaryKeys = new Set<string>();
   const cleanCompactToolCallIds = new Set<string>();
   const cleanGroupToolCallIds = new Map<string, string[]>();
@@ -373,7 +381,7 @@ export default function prettyTui(pi: ExtensionAPI) {
   const renderActivityCollapse = (group: ActivityGroup, width: number): string => {
     const theme = activityGroupTheme(group);
     return truncateToWidth(
-      theme.fg("dim", collapsePrefix) + theme.fg("muted", collapseLabel),
+      theme.fg("dim", collapsePrefix) + theme.fg("mdLink", collapseLabel),
       Math.max(1, width),
       "",
     );
@@ -816,10 +824,16 @@ export default function prettyTui(pi: ExtensionAPI) {
       content.paddingY = 0;
       content.setBgFn?.(undefined);
       content.invalidate?.();
-      // Pi wraps the Markdown in a full-width Box. Render the Markdown child
-      // directly so short messages expose their natural visible width instead
-      // of inheriting the Box's width-filling padding.
+      // Older Pi wraps Markdown in a Box; Pi 1.0 renders Markdown directly
+      // with its own background and padding. Normalize both layouts before
+      // measuring, preserving the native foreground and Markdown options.
       const markdown = content.children?.[0] ?? content;
+      markdown.paddingX = 0;
+      markdown.paddingY = 0;
+      if (markdown.defaultTextStyle) {
+        markdown.defaultTextStyle = { ...markdown.defaultTextStyle, bgColor: undefined };
+      }
+      markdown.invalidate?.();
 
       const outputPad = Math.max(0, Number(this.outputPad) || 0);
       const markdownTheme = this.markdownTheme;
@@ -1479,6 +1493,17 @@ export default function prettyTui(pi: ExtensionAPI) {
     const originalShowStatus = interactiveModePrototype.showStatus;
     const originalShowWarning = interactiveModePrototype.showWarning;
     const originalShowError = interactiveModePrototype.showError;
+    const originalAddCacheMissNotice = interactiveModePrototype.addCacheMissNotice;
+    const originalMaybeShowCacheMissNotice = interactiveModePrototype.maybeShowCacheMissNotice;
+    const originalAddMessageToChat = interactiveModePrototype.addMessageToChat;
+    const cacheMessageContexts = new WeakMap<object, any>();
+    const pendingCacheNotices = new Map<string, {
+      key: string; title: string; content: string; toolCallIds: string[];
+    }>();
+    // The interactive-mode instance that owns the chat container. Tool events
+    // carry no `this`, so deferred notices need this handle to mount.
+    const cacheNoticeHost: { current?: any } = {};
+    const cacheNoticeOwners = new WeakMap<object, any>();
     const patchedSetToolsExpanded = function (this: any, expanded: boolean) {
       cleanToolsExpanded = expanded;
       collapsedActivityGroups.clear();
@@ -1504,6 +1529,18 @@ export default function prettyTui(pi: ExtensionAPI) {
       // while Pi's live compaction UI appends it chronologically. Keep reloads
       // and transcript rebuilds consistent with that live presentation.
       const orderedEntries = orderContextEntriesForTranscript(entries);
+      cacheMessageContexts.delete(this);
+      // Pi re-derives notices on each rebuild (including when its display
+      // setting changes). Remove old projections, not their work groups.
+      for (const group of activityTimeline.groups()) {
+        for (const member of [...group.members]) {
+          if (member.updateKey?.startsWith("cache-miss:") || member.updateKey?.startsWith("runtime:cache-miss:")) {
+            activityTimeline.discardUpdate(member.updateKey);
+            activityUpdateComponents.delete(member.id);
+            activityUpdateMarkdownComponents.delete(member.id);
+          }
+        }
+      }
       return originalRenderSessionEntries.call(this, orderedEntries, options);
     };
 
@@ -1588,6 +1625,163 @@ export default function prettyTui(pi: ExtensionAPI) {
       }
     };
 
+    // CacheMiss itself carries no assistant/message ID. Bind it at Pi's
+    // 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[]) {
+      if (message?.role === "assistant") cacheMessageContexts.set(this, message);
+      else cacheMessageContexts.delete(this);
+      return originalAddMessageToChat.call(this, message, ...args);
+    };
+    const patchedMaybeShowCacheMissNotice = function (this: any, message: any, ...args: any[]) {
+      const previous = cacheMessageContexts.get(this);
+      cacheMessageContexts.set(this, message);
+      try {
+        return originalMaybeShowCacheMissNotice.call(this, message, ...args);
+      } finally {
+        if (previous) cacheMessageContexts.set(this, previous);
+        else cacheMessageContexts.delete(this);
+      }
+    };
+
+    // One projection component per activity update member. Cache notices are
+    // also mounted immediately after the tool that anchors them, so container
+    // order matches group order even when the notice arrives before the tools.
+    const mountActivityUpdate = (
+      mode: any,
+      group: ActivityGroup,
+      member: ActivityMember,
+      nativeNodes: Component[] = [],
+      after?: Component,
+    ): void => {
+      const container = mode?.chatContainer;
+      const existing = activityUpdateComponents.get(member.id);
+      if (existing) {
+        const children: Component[] | undefined = container?.children;
+        if (after && children) {
+          const target = children.indexOf(existing);
+          const anchorIndex = children.indexOf(after);
+          if (target >= 0 && anchorIndex >= 0 && target !== anchorIndex + 1) {
+            children.splice(target, 1);
+            children.splice(children.indexOf(after) + 1, 0, existing);
+          }
+        }
+        return;
+      }
+      // A mode switch can keep existing components rather than rebuild them.
+      const component: Component = {
+        render: (width: number) => renderMode === "clean"
+          ? renderActivityUpdateProjection(group, member, width)
+          : nativeNodes.flatMap((node) => node.render(width)),
+        invalidate() {},
+        handleMouse: (event: any) => renderMode === "clean"
+          ? handleActivityUpdateMouse(group, member, event)
+          : undefined,
+      } as Component;
+      activityUpdateComponents.set(member.id, component);
+      const index = after && container?.children ? container.children.indexOf(after) : -1;
+      if (index >= 0) {
+        container.children.splice(index + 1, 0, component);
+        return;
+      }
+      container?.addChild?.(component);
+    };
+
+    // Live cache misses arrive before the message's tools execute, so their
+    // members do not exist yet. Attach the notice once its first tool joins the
+    // group; this keeps it inside the tree instead of above it.
+    const flushPendingCacheNotices = (toolCallId: string): void => {
+      if (pendingCacheNotices.size === 0) return;
+      for (const [messageKey, pending] of [...pendingCacheNotices]) {
+        if (!pending.toolCallIds.includes(toolCallId)) continue;
+        pendingCacheNotices.delete(messageKey);
+        const anchorMember = activityTimeline.memberForTool(toolCallId);
+        if (!anchorMember) continue;
+        const member = activityTimeline.addUpdateAfterMember(
+          anchorMember.id, pending.key, pending.title, pending.content, "warning",
+        ) ?? activityTimeline.addStandaloneUpdate(
+          pending.key, pending.title, pending.content, "warning",
+        );
+        const group = activityTimeline.groupForMember(member.id);
+        if (!group) continue;
+        mountActivityUpdate(
+          cacheNoticeHost.current, group, member, [],
+          cleanToolComponents.get(toolCallId),
+        );
+        refreshActivityGroup(group);
+        cacheNoticeHost.current?.ui?.requestRender?.();
+      }
+    };
+    flushDeferredCacheNotices = flushPendingCacheNotices;
+
+    const patchedAddCacheMissNotice = function (this: any, miss: any) {
+      if (renderMode !== "clean" || !this.chatContainer?.addChild) {
+        return originalAddCacheMissNotice.call(this, miss);
+      }
+      // Let Pi decide thresholds, formatting and cause labels. Capture its
+      // native nodes rather than duplicating cache heuristics or matching text.
+      const nativeNodes: Component[] = [];
+      const captureHost = Object.create(this);
+      captureHost.chatContainer = Object.create(this.chatContainer);
+      captureHost.chatContainer.addChild = (node: Component) => nativeNodes.push(node);
+      originalAddCacheMissNotice.call(captureHost, miss);
+      const text = nativeNodes.flatMap((node) => node.render(4096))
+        .map((line) => stripTerminalSequences(line).trim()).filter(Boolean).join("\n");
+      if (!text) return;
+
+      // Rebuilds have already restored the *whole* branch. Use the assistant
+      // physically preceding this insertion, not currentGroup() (the last one).
+      const children: any[] = this.chatContainer.children ?? [];
+      let message: any = cacheMessageContexts.get(this);
+      for (let index = children.length - 1; !message && index >= 0; index--) {
+        const child = children[index];
+        if (cacheNoticeOwners.has(child)) { message = cacheNoticeOwners.get(child); break; }
+        if (child instanceof ToolExecutionComponent) continue;
+        if (child instanceof AssistantMessageComponent) { message = (child as any).lastMessage; break; }
+        break; // never cross a user/custom/compaction boundary
+      }
+      // Live Pi may have inserted a provider diagnostic after the assistant.
+      if (!message && this.streamingComponent && children.includes(this.streamingComponent)) {
+        message = this.streamingMessage;
+      }
+      let anchor: ActivityMember | undefined;
+      const calls = messageContentItems(message).filter((item: any) => item.type === "toolCall");
+      for (let index = calls.length - 1; index >= 0; index--) {
+        anchor = activityTimeline.memberForTool(calls[index].id);
+        if (anchor) break;
+      }
+      if (!anchor && message && !visibleAssistantText(message)) {
+        anchor = activityTimeline.memberForThinking(assistantMessageKey(message));
+      }
+      const key = message
+        ? `cache-miss:${assistantMessageKey(message)}`
+        : `runtime:cache-miss:${++activityUpdateSequence}`;
+      const [title, ...details] = text.split("\n");
+      const content = details.join("\n");
+      cacheNoticeHost.current = this;
+      if (!anchor && calls.length > 0) {
+        // The tools have not started yet: their group does not exist. Defer so
+        // the notice lands after the tool instead of floating above the tree.
+        pendingCacheNotices.set(key, {
+          key, title, content, toolCallIds: calls.map((call: any) => call.id),
+        });
+        return;
+      }
+      const member = (anchor && activityTimeline.addUpdateAfterMember(
+        anchor.id, key, title, content, "warning",
+      )) || activityTimeline.addStandaloneUpdate(key, title, content, "warning");
+      const group = activityTimeline.groupForMember(member.id);
+      if (!group) return;
+      mountActivityUpdate(
+        this, group, member, nativeNodes,
+        anchor?.toolCallId ? cleanToolComponents.get(anchor.toolCallId) : undefined,
+      );
+      const component = activityUpdateComponents.get(member.id);
+      if (component && message) cacheNoticeOwners.set(component, message);
+      refreshActivityGroup(group);
+      this.ui?.requestRender?.();
+    };
+
     interactiveModePrototype[toolsExpansionPatchKey] = {
       originalSetToolsExpanded,
       patchedSetToolsExpanded,
@@ -1605,6 +1799,12 @@ export default function prettyTui(pi: ExtensionAPI) {
       patchedShowWarning,
       originalShowError,
       patchedShowError,
+      originalAddCacheMissNotice,
+      patchedAddCacheMissNotice,
+      originalMaybeShowCacheMissNotice,
+      patchedMaybeShowCacheMissNotice,
+      originalAddMessageToChat,
+      patchedAddMessageToChat,
     };
     interactiveModePrototype.setToolsExpanded = patchedSetToolsExpanded;
     interactiveModePrototype.renderSessionEntries = patchedRenderSessionEntries;
@@ -1614,6 +1814,15 @@ export default function prettyTui(pi: ExtensionAPI) {
     interactiveModePrototype.showStatus = patchedShowStatus;
     interactiveModePrototype.showWarning = patchedShowWarning;
     interactiveModePrototype.showError = patchedShowError;
+    if (typeof originalAddCacheMissNotice === "function") {
+      interactiveModePrototype.addCacheMissNotice = patchedAddCacheMissNotice;
+      if (typeof originalMaybeShowCacheMissNotice === "function") {
+        interactiveModePrototype.maybeShowCacheMissNotice = patchedMaybeShowCacheMissNotice;
+      }
+      if (typeof originalAddMessageToChat === "function") {
+        interactiveModePrototype.addMessageToChat = patchedAddMessageToChat;
+      }
+    }
 
     pi.on("session_shutdown", () => {
       fullscreenTui = false;
@@ -1646,6 +1855,15 @@ export default function prettyTui(pi: ExtensionAPI) {
       if (patch.patchedShowError === interactiveModePrototype.showError) {
         interactiveModePrototype.showError = patch.originalShowError;
       }
+      if (patch.patchedAddCacheMissNotice === interactiveModePrototype.addCacheMissNotice) {
+        interactiveModePrototype.addCacheMissNotice = patch.originalAddCacheMissNotice;
+      }
+      if (patch.patchedMaybeShowCacheMissNotice === interactiveModePrototype.maybeShowCacheMissNotice) {
+        interactiveModePrototype.maybeShowCacheMissNotice = patch.originalMaybeShowCacheMissNotice;
+      }
+      if (patch.patchedAddMessageToChat === interactiveModePrototype.addMessageToChat) {
+        interactiveModePrototype.addMessageToChat = patch.originalAddMessageToChat;
+      }
       if (
         interactiveModePrototype.setToolsExpanded === patch.originalSetToolsExpanded &&
         interactiveModePrototype.renderSessionEntries === patch.originalRenderSessionEntries &&
@@ -1654,7 +1872,10 @@ export default function prettyTui(pi: ExtensionAPI) {
         interactiveModePrototype.toggleThinkingBlockVisibility === patch.originalToggleThinkingBlockVisibility &&
         interactiveModePrototype.showStatus === patch.originalShowStatus &&
         interactiveModePrototype.showWarning === patch.originalShowWarning &&
-        interactiveModePrototype.showError === patch.originalShowError
+        interactiveModePrototype.showError === patch.originalShowError &&
+        interactiveModePrototype.addCacheMissNotice === patch.originalAddCacheMissNotice &&
+        interactiveModePrototype.maybeShowCacheMissNotice === patch.originalMaybeShowCacheMissNotice &&
+        interactiveModePrototype.addMessageToChat === patch.originalAddMessageToChat
       ) {
         delete interactiveModePrototype[toolsExpansionPatchKey];
       }
@@ -2107,24 +2328,10 @@ export default function prettyTui(pi: ExtensionAPI) {
     context.state.compactToolStatus = status;
   };
 
-  const foregroundLuminance = (styled: string): number | undefined => {
-    const trueColor = /\x1b\[38;2;(\d+);(\d+);(\d+)m/.exec(styled);
-    if (!trueColor) return undefined;
-    const [, red, green, blue] = trueColor.map(Number);
-    return red * 0.2126 + green * 0.7152 + blue * 0.0722;
-  };
-
-  const successMarkerColor = (theme: any): string => {
-    const textLuminance = foregroundLuminance(theme.fg("text", "M"));
-    return textLuminance !== undefined && textLuminance < 128
-      ? "success"
-      : "syntaxComment";
-  };
-
   const callRow = (theme: any, name: string, detail: string, state: any): DisplayRow => ({
     prefix: () => {
       const status = (state.compactToolStatus ?? "running") as ToolStatus;
-      const color = status === "success" ? successMarkerColor(theme) : status === "error" ? "error" : "dim";
+      const color = status === "success" ? "success" : status === "error" ? "error" : "dim";
       return theme.fg(color, "● ");
     },
     continuation: "  ",
@@ -2396,7 +2603,7 @@ export default function prettyTui(pi: ExtensionAPI) {
     const dotColor = component.result?.isError
       ? "error"
       : component.result && !component.isPartial
-        ? successMarkerColor(theme)
+        ? "success"
         : "accent";
     const title = theme.fg(dotColor, "● ") +
       theme.fg("accent", theme.bold(label)) +
@@ -2585,7 +2792,7 @@ export default function prettyTui(pi: ExtensionAPI) {
       // not one of our self-rendering specialized tools.
       const thirdParty = !SPECIALIZED_TOOL_NAMES.has(this.toolName) ||
         this.toolDefinition?.renderShell !== "self";
-      const cacheable = !this.expanded && Boolean(this.result) && !this.isPartial;
+      const cacheable = nestedTools.count(this.toolCallId) === 0 && !this.expanded && Boolean(this.result) && !this.isPartial;
       const cached = cacheable ? this[cleanChildRenderCacheKey] : undefined;
       let decoratedContent: string[];
       if (
@@ -2602,7 +2809,9 @@ export default function prettyTui(pi: ExtensionAPI) {
         decoratedContent = cached.lines;
       } else {
         let contentLines: string[];
-        if (thirdParty) {
+        if (nestedTools.count(this.toolCallId) > 0) {
+          contentLines = nestedTools.render(this, childWidth, childTheme).lines;
+        } else if (thirdParty) {
           const summaryLines = renderThirdPartyCompact(this, childWidth, childTheme);
           if (this.expanded) {
             const detailPrefix = "  │ ";
@@ -2686,6 +2895,24 @@ export default function prettyTui(pi: ExtensionAPI) {
         return { handled: true };
       }
 
+      if (nestedTools.count(this.toolCallId) > 0 && isLeftClick) {
+        const theme = cleanThemeForToolCall(this.toolCallId) ?? activityGroupTheme(group);
+        const { childWidth } = activityTreeStyle(group, member, event.width, theme);
+        const projection = nestedTools.render(this, childWidth, theme);
+        const contentY = event.y - (position.first ? summaryHeight + 1 : 0);
+        const action = projection.actions.get(contentY);
+        if (action) {
+          nestedTools.toggle(action);
+          this.updateDisplay?.();
+          this.ui?.requestRender?.();
+        } else if (contentY === 0) {
+          originalSetExpanded.call(this, !this.expanded);
+          this.ui?.requestRender?.();
+        }
+        // Nested results are UI projections, not native renderer rows.
+        return { handled: true };
+      }
+
       // Self-rendering tools reserve y=0 for Pi's leading spacer. Clean mode
       // replaces that spacer with the compact header for non-first members.
       const thirdPartyHeaderY = position.first ? summaryHeight + 1 : 0;
@@ -2815,6 +3042,7 @@ export default function prettyTui(pi: ExtensionAPI) {
     _failed: number,
     thoughtCount: number,
     activity = "done",
+    nestedCount = 0,
   ): string => {
     const rawActivityText = typeof activity === "string" ? activity : "done";
     const normalizedActivityText = rawActivityText.trim();
@@ -2830,7 +3058,7 @@ export default function prettyTui(pi: ExtensionAPI) {
     const activityLabel = count > 0 && activityText !== "done" && activityText.trim()
       ? activityText
       : "";
-    return [countLabel, thoughtLabel, activityLabel].filter(Boolean).join(" · ");
+    return [countLabel, nestedCount ? `${nestedCount} nested ${nestedCount === 1 ? "call" : "calls"}` : "", thoughtLabel, activityLabel].filter(Boolean).join(" · ");
   };
 
   const summaryRow = (
@@ -2840,6 +3068,7 @@ export default function prettyTui(pi: ExtensionAPI) {
     thoughtCount: number,
     activity: DisplayValue = "done",
     collapsedDone = false,
+    nestedCount = 0,
   ): DisplayRow => ({
     prefix: () => {
       const currentActivity = typeof activity === "function" ? activity() : activity;
@@ -2858,7 +3087,7 @@ export default function prettyTui(pi: ExtensionAPI) {
       const detailColor = label === "Done" && collapsedDone ? "thinkingText" : "text";
       return theme.fg(color, theme.bold(label)) +
         theme.fg("dim", "(") +
-        theme.fg(detailColor, summaryText(count, failed, thoughtCount, currentActivity)) +
+        theme.fg(detailColor, summaryText(count, failed, thoughtCount, currentActivity, nestedCount)) +
         theme.fg("dim", ")");
     },
   });
@@ -2908,6 +3137,7 @@ export default function prettyTui(pi: ExtensionAPI) {
     const owner = activityGroupOwner(group);
     const settled = owner ? settledSummaries.get(owner) : undefined;
     const toolCount = group.toolCallIds.length;
+    const nestedCount = group.toolCallIds.reduce((count, id) => count + nestedTools.count(id), 0);
     const live = () => cleanRun.activeToolName ?? currentCleanActivity();
     if (settled) {
       return fit(block([summaryRow(
@@ -2917,6 +3147,7 @@ export default function prettyTui(pi: ExtensionAPI) {
         Math.max(settled.thoughtCount, group.thoughtCount),
         settled.activity,
         collapsedDone,
+        nestedCount,
       )]).render(width));
     }
     if (owner && !cleanRun.settled) {
@@ -2928,6 +3159,7 @@ export default function prettyTui(pi: ExtensionAPI) {
         group.thoughtCount,
         live,
         collapsedDone,
+        nestedCount,
       )]).render(width));
     }
     if (!owner && !activityTimeline.isSettled(group.id)) {
@@ -2939,6 +3171,7 @@ export default function prettyTui(pi: ExtensionAPI) {
         group.thoughtCount,
         "thinking",
         collapsedDone,
+        nestedCount,
       )]).render(width));
     }
     // Finished group with no durable summary: a completed Thought-only turn, or
@@ -2950,6 +3183,7 @@ export default function prettyTui(pi: ExtensionAPI) {
       group.thoughtCount,
       "done",
       collapsedDone,
+      nestedCount,
     )]).render(width));
   };
 
@@ -3148,6 +3382,7 @@ export default function prettyTui(pi: ExtensionAPI) {
     settledSummaries.clear();
     legacySummaryLastToolCallIds.clear();
     activityTimeline.clear();
+    nestedTools.clear();
     responseAnswerTexts.clear();
     responseRunStartedAt = undefined;
     responseHasAssistantMessage = false;
@@ -3307,6 +3542,10 @@ export default function prettyTui(pi: ExtensionAPI) {
     cleanContextCompacted = modelContextEntries[0]?.type === "compaction";
     const contextEntries = orderContextEntriesForTranscript(modelContextEntries);
     for (const entry of contextEntries) {
+      if (entry.type === "custom" && entry.customType === NESTED_SNAPSHOT_ENTRY) {
+        nestedTools.restore(entry.data);
+        continue;
+      }
       if (entry.type === "compaction") {
         finishGroup();
         lastFinishedGroup = undefined;
@@ -3391,6 +3630,10 @@ export default function prettyTui(pi: ExtensionAPI) {
         continue;
       }
 
+      if (message.role === "toolResult") {
+        nestedTools.absorb(message.toolCallId, message.nestedCalls ?? message.details?.calls, !message.details?.callsTruncated);
+      }
+
       if (
         message.role === "toolResult" &&
         toolCalls.has(message.toolCallId) &&
@@ -3473,6 +3716,7 @@ export default function prettyTui(pi: ExtensionAPI) {
     if (toolCalls.length === 0) return false;
     for (const toolCall of toolCalls) {
       activityTimeline.addTool(toolCall.id, toolCall.name ?? "tool");
+      flushDeferredCacheNotices?.(toolCall.id);
       if (!cleanRun.currentToolCallIds.includes(toolCall.id)) {
         cleanRun.currentToolCallIds.push(toolCall.id);
       }
@@ -3569,7 +3813,13 @@ export default function prettyTui(pi: ExtensionAPI) {
     if (renderMode === "clean") startWorkingElapsedTimer();
   });
   pi.on("tool_execution_start", (event) => {
+    if ((event as any).parentToolCallId) {
+      nestedTools.start(event);
+      refreshNestedTools(event.toolCallId);
+      return;
+    }
     activityTimeline.addTool(event.toolCallId, event.toolName);
+    flushDeferredCacheNotices?.(event.toolCallId);
     if (!cleanRun.currentToolCallIds.includes(event.toolCallId)) {
       cleanRun.currentToolCallIds.push(event.toolCallId);
     }
@@ -3581,7 +3831,25 @@ export default function prettyTui(pi: ExtensionAPI) {
     cleanRun.activeToolCallId = event.toolCallId;
     beginToolActivity(event.toolCallId, displayName, true);
   });
+  pi.on("tool_execution_update", (event) => {
+    if ((event as any).parentToolCallId) {
+      nestedTools.update(event);
+      refreshNestedTools(event.toolCallId);
+    } else {
+      nestedTools.absorb(event.toolCallId, (event.partialResult as any)?.details?.calls, !(event.partialResult as any)?.details?.callsTruncated);
+      refreshNestedTools(event.toolCallId);
+    }
+  });
   pi.on("tool_execution_end", (event) => {
+    if ((event as any).parentToolCallId) {
+      nestedTools.update(event, true);
+      refreshNestedTools(event.toolCallId);
+      return;
+    }
+    nestedTools.absorb(event.toolCallId, (event.result as any)?.details?.calls, !(event.result as any)?.details?.callsTruncated);
+    nestedTools.finish(event.toolCallId);
+    const snapshot = nestedTools.snapshot(event.toolCallId);
+    if (snapshot) pi.appendEntry(NESTED_SNAPSHOT_ENTRY, snapshot);
     const activityName = cleanRun.activeToolCallId === event.toolCallId
       ? cleanRun.activeToolName ?? cleanToolNames.get(event.toolCallId) ?? event.toolName
       : cleanToolNames.get(event.toolCallId) ?? event.toolName;
@@ -3618,6 +3886,11 @@ export default function prettyTui(pi: ExtensionAPI) {
   pi.on("agent_settled", (_event, ctx) => {
     stopWorkingElapsedTimer();
     if (cleanRun.settled) return;
+    for (const rootId of nestedTools.finishAll()) {
+      const snapshot = nestedTools.snapshot(rootId);
+      if (snapshot) pi.appendEntry(NESTED_SNAPSHOT_ENTRY, snapshot);
+      refreshNestedTools(rootId);
+    }
 
     clearPendingToolActivities();
     // Finalize the last group after retries/compaction have definitely ended.

package/extensions/nested-tools.ts

@@ -0,0 +1,244 @@
+import { stripTerminalSequences, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+
+export const NESTED_SNAPSHOT_ENTRY = "pretty-tui-nested-results";
+export const NESTED_LIMITS = { calls: 256, args: 4096, output: 8192, total: 131072 };
+type Status = "running" | "ok" | "error" | "cancelled";
+export type NestedCall = {
+  id: string; parentId: string; name: string; args: string; status: Status;
+  startedAt?: number; durationMs?: number; output?: string; truncated?: boolean; argsTruncated?: boolean;
+};
+export type NestedSnapshot = { version: 1; rootId: string; calls: NestedCall[]; incomplete: boolean };
+const safeText = (value: string) => stripTerminalSequences(value).replace(/[\x00-\x08\x0b-\x1f\x7f]/gu, "");
+const bounded = (text: string, limit: number) => safeText(text).slice(0, limit);
+const argsText = (args: any): string => {
+  try {
+    return bounded(JSON.stringify(args ?? {}, (key, value) =>
+      /token|secret|password|credential|authorization|api[_-]?key/iu.test(key) ? "[redacted]" : value,
+    ), NESTED_LIMITS.args);
+  } catch { return "[arguments unavailable]"; }
+};
+const recordedArgs = (value: string): string => {
+  try { return argsText(JSON.parse(value)); } catch {
+    return bounded(value.replace(/("[^"\n]*(?:token|secret|password|credential|authorization|api[_-]?key)[^"\n]*"\s*:\s*)("(?:\\.|[^"\\])*"|[^,}\n]*)/giu, '$1"[redacted]"'), NESTED_LIMITS.args);
+  }
+};
+const resultText = (result: any): string => {
+  const text = (Array.isArray(result?.content) ? result.content : [])
+    .filter((block: any) => block?.type === "text" && typeof block.text === "string")
+    .map((block: any) => block.text).join("\n");
+  // Edit renderers carry their useful diff separately from the success message.
+  const diff = typeof result?.details?.diff === "string" ? result.details.diff : "";
+  let structured = "";
+  if (!text && result?.structuredContent !== undefined) {
+    try { structured = JSON.stringify(result.structuredContent, null, 2); } catch { /* non-JSON result */ }
+  }
+  const media = (result?.content ?? []).some((block: any) => block?.type === "image")
+    ? "[Image result omitted from nested text preview]" : "";
+  const error = !text && typeof result?.details?.error === "string" ? result.details.error : "";
+  return safeText([text, diff, structured, media, error].filter(Boolean).join("\n"));
+};
+
+const compactArgs = (value: string): string => {
+  try {
+    const args = JSON.parse(value);
+    if (!args || typeof args !== "object" || Array.isArray(args)) return value;
+    return Object.entries(args)
+      .filter(([key]) => !/token|secret|password|credential|authorization|api[_-]?key/iu.test(key))
+      .slice(0, 3).map(([key, entry]) => `${key}=${typeof entry === "string" ? entry : JSON.stringify(entry)}`)
+      .join(" · ").replace(/\s+/gu, " ");
+  } catch { return value.replace(/\s+/gu, " "); }
+};
+
+/** UI-only nested execution state. Never executes tools or alters model results. */
+export class NestedTools {
+  private calls = new Map<string, NestedCall>();
+  private incomplete = new Set<string>();
+  private expanded = new Set<string>();
+  clear() { this.calls.clear(); this.incomplete.clear(); this.expanded.clear(); }
+  toggle(key: string) { this.expanded.has(key) ? this.expanded.delete(key) : this.expanded.add(key); }
+  root(id: string): string {
+    const seen = new Set<string>();
+    while (this.calls.has(id) && !seen.has(id)) {
+      seen.add(id); id = this.calls.get(id)!.parentId;
+    }
+    return id;
+  }
+  children(parentId: string): NestedCall[] {
+    return [...this.calls.values()].filter((call) => call.parentId === parentId);
+  }
+  count(rootId: string): number {
+    return [...this.calls.values()].filter((call) => this.root(call.id) === rootId).length;
+  }
+  start(event: any) {
+    if (!event.parentToolCallId || this.calls.has(event.toolCallId)) return;
+    const rootId = this.root(event.parentToolCallId);
+    if (this.count(rootId) >= NESTED_LIMITS.calls) { this.incomplete.add(rootId); return; }
+    const args = argsText(event.args);
+    const argsTruncated = args.length >= NESTED_LIMITS.args;
+    if (argsTruncated) this.incomplete.add(rootId);
+    this.calls.set(event.toolCallId, {
+      id: event.toolCallId, parentId: event.parentToolCallId, name: bounded(String(event.toolName ?? "tool"), 256),
+      args, argsTruncated, status: "running", startedAt: Date.now(),
+    });
+  }
+  update(event: any, finished = false) {
+    const call = this.calls.get(event.toolCallId);
+    if (!call) return;
+    const text = resultText(finished ? event.result : event.partialResult);
+    const rootId = this.root(call.id);
+    const otherSize = [...this.calls.values()].filter((other) => other.id !== call.id && this.root(other.id) === rootId)
+      .reduce((size, other) => size + other.args.length + (other.output?.length ?? 0), 0);
+    const limit = Math.max(0, Math.min(NESTED_LIMITS.output, NESTED_LIMITS.total - otherSize - call.args.length));
+    call.output = text.slice(0, limit);
+    call.truncated = text.length > limit;
+    if (call.truncated) this.incomplete.add(rootId);
+    if (finished) {
+      call.status = event.isError ? "error" : "ok";
+      call.durationMs = Math.max(0, Date.now() - (call.startedAt ?? Date.now()));
+    }
+  }
+  finish(rootId: string): boolean {
+    let changed = false;
+    for (const call of this.calls.values()) {
+      if (this.root(call.id) === rootId && call.status === "running") {
+        call.status = "cancelled"; changed = true;
+      }
+    }
+    return changed;
+  }
+  finishAll(): string[] {
+    const roots = new Set([...this.calls.values()].map((call) => this.root(call.id)));
+    return [...roots].filter((rootId) => this.finish(rootId));
+  }
+  /** Persisted host metadata is a fallback, not a substitute for actual results. */
+  absorb(rootId: string, records: any, complete = true) {
+    if (records && !Array.isArray(records) && Array.isArray(records.calls)) {
+      complete &&= records.complete !== false;
+      records = records.calls;
+    }
+    if (!Array.isArray(records)) return;
+    for (const record of records) {
+      if (typeof record?.id !== "string" || typeof record?.name !== "string" || record.id.endsWith("/?")) continue;
+      const existing = this.calls.get(record.id);
+      if (existing) {
+        if (record.status === "cancelled" || record.status === "unfinished") existing.status = "cancelled";
+        else if (record.status === "error" || record.status === "ok") existing.status = record.status;
+        if (typeof record.durationMs === "number") existing.durationMs = record.durationMs;
+        continue;
+      }
+      if (this.count(rootId) >= NESTED_LIMITS.calls) { this.incomplete.add(rootId); break; }
+      const slash = record.id.lastIndexOf("/");
+      const candidate = record.id.slice(0, slash);
+      const parentId = this.calls.has(candidate) ? candidate : rootId;
+      this.calls.set(record.id, {
+        id: record.id, parentId, name: bounded(record.name, 256),
+        args: typeof record.args === "string" ? recordedArgs(record.args) : record.argumentsBytes !== undefined ? "[Arguments omitted by Pi]" : argsText(record.arguments),
+        argsTruncated: record.argumentsBytes !== undefined,
+        status: record.status === "error" ? "error" : record.status === "cancelled" || record.status === "unfinished" ? "cancelled" : record.status === "running" ? "running" : "ok",
+        durationMs: typeof record.durationMs === "number" ? record.durationMs : undefined,
+        output: typeof record.error === "string" ? bounded(record.error, NESTED_LIMITS.output) : undefined,
+      });
+    }
+    if (!complete) this.incomplete.add(rootId);
+  }
+  snapshot(rootId: string): NestedSnapshot | undefined {
+    const calls: NestedCall[] = [];
+    let budget = NESTED_LIMITS.total;
+    let incomplete = this.incomplete.has(rootId);
+    for (const call of this.calls.values()) {
+      if (this.root(call.id) !== rootId) continue;
+      const { startedAt: _startedAt, ...copy } = call;
+      copy.args = copy.args.slice(0, Math.max(0, budget));
+      budget -= copy.args.length;
+      if (copy.output !== undefined) {
+        copy.output = copy.output.slice(0, Math.max(0, budget));
+        budget -= copy.output.length;
+        copy.truncated ||= copy.output.length < (call.output?.length ?? 0);
+      }
+      copy.argsTruncated ||= copy.args.length < call.args.length;
+      incomplete ||= Boolean(copy.argsTruncated || copy.truncated);
+      if (copy.status === "running") copy.status = "cancelled";
+      calls.push(copy);
+    }
+    if (!calls.length) return undefined;
+    return { version: 1, rootId, calls, incomplete };
+  }
+  restore(data: any) {
+    if (data?.version !== 1 || typeof data.rootId !== "string" || !Array.isArray(data.calls)) return;
+    // Snapshot entries originate locally; still validate and bound every field.
+    let budget = NESTED_LIMITS.total;
+    for (const call of data.calls.slice(0, NESTED_LIMITS.calls)) {
+      if (typeof call?.id !== "string" || typeof call.parentId !== "string" || typeof call.name !== "string") continue;
+      const args = bounded(String(call.args ?? ""), Math.min(NESTED_LIMITS.args, budget));
+      budget -= args.length;
+      const output = typeof call.output === "string" ? bounded(call.output, Math.min(NESTED_LIMITS.output, budget)) : undefined;
+      budget -= output?.length ?? 0;
+      this.calls.set(call.id, { id: call.id, parentId: call.parentId, name: bounded(call.name, 256), args, output,
+        status: call.status === "error" ? "error" : call.status === "cancelled" || call.status === "running" ? "cancelled" : "ok",
+        durationMs: typeof call.durationMs === "number" ? call.durationMs : undefined, truncated: Boolean(call.truncated), argsTruncated: Boolean(call.argsTruncated) });
+    }
+    if (data.incomplete) this.incomplete.add(data.rootId);
+  }
+  render(owner: any, width: number, theme: any): { lines: string[]; actions: Map<number, string> } {
+    const rootId = owner.toolCallId;
+    const actions = new Map<number, string>();
+    const count = this.count(rootId);
+    const failed = [...this.calls.values()].filter((call) => this.root(call.id) === rootId && call.status === "error").length;
+    const color = owner.result?.isError ? "error" : owner.result && !owner.isPartial ? "success" : "accent";
+    const label = owner.toolDefinition?.label ?? owner.toolName;
+    const lines = [theme.fg(color, "● ") + theme.fg("accent", theme.bold(label)) +
+      theme.fg("muted", `(${count} nested ${count === 1 ? "call" : "calls"}${failed ? ` · ${failed} failed` : ""})`)];
+    const detail = (text: string, prefix: string, action?: string) => {
+      const push = (line: string) => {
+        if (action) actions.set(lines.length, action);
+        lines.push(line);
+      };
+      const available = Math.max(1, width - visibleWidth(prefix));
+      let rows = 0;
+      for (const line of bounded(text, NESTED_LIMITS.output).split("\n")) {
+        for (const wrapped of wrapTextWithAnsi(line || " ", available)) {
+          if (++rows > 200) { push(theme.fg("dim", prefix + "[Preview truncated]")); return; }
+          push(theme.fg("dim", prefix) + theme.fg("toolOutput", wrapped));
+        }
+      }
+      if (safeText(text).length > NESTED_LIMITS.output) push(theme.fg("dim", prefix + "[Preview truncated]"));
+    };
+    const items = this.children(rootId);
+    const visit = (call: NestedCall, indent: string, last: boolean, depth: number) => {
+      const prefix = indent + (last ? "└─ " : "├─ ");
+      const continuation = indent + (last ? "   " : "│  ");
+      const icon = call.status === "running" ? "…" : call.status === "cancelled" ? "⊘" : "●";
+      const callColor = call.status === "ok" ? "success" : call.status === "error" ? "error" : call.status === "running" ? "accent" : "muted";
+      actions.set(lines.length, call.id);
+      const duration = call.durationMs === undefined ? "" : ` · ${call.durationMs < 1000 ? `${Math.round(call.durationMs)}ms` : `${(call.durationMs / 1000).toFixed(1)}s`}`;
+      lines.push(theme.fg("dim", prefix) + theme.fg(callColor, icon + " ") + theme.fg("accent", theme.bold(call.name)) + theme.fg("muted", `(${compactArgs(call.args)})${duration}`));
+      const expanded = owner.expanded || this.expanded.has(call.id);
+      const first = call.output?.split("\n").find((line) => line.trim());
+      const summary = first ?? (call.status === "running" ? "Running…" : call.truncated ? "Output omitted by UI size limit" : call.output === undefined ? "Only call metadata retained" : "No text output");
+      const descendants = this.children(call.id);
+      actions.set(lines.length, call.id);
+      lines.push(theme.fg("dim", continuation + (descendants.length ? "├ " : "└ ")) + theme.fg(call.status === "error" ? "error" : "muted", summary));
+      if (expanded) {
+        detail(`Arguments: ${call.args}`, continuation + "  ", call.id);
+        if (call.output) detail(call.output, continuation + "  ", call.id);
+        if (call.argsTruncated) detail("[Arguments truncated in UI snapshot]", continuation + "  ", call.id);
+        if (call.truncated) detail("[Output truncated in UI snapshot]", continuation + "  ", call.id);
+      }
+      if (depth < 7) descendants.forEach((child, index, children) => visit(child, continuation, index === children.length - 1, depth + 1));
+      else if (descendants.length) detail("[Deeper calls omitted]", continuation);
+    };
+    const code = typeof owner.args?.code === "string" ? owner.args.code : undefined;
+    if (code) {
+      const key = `${rootId}:script`;
+      actions.set(lines.length, key); lines.push(theme.fg("dim", "  ├─ ") + theme.fg("mdLink", "[Script]"));
+      if (owner.expanded || this.expanded.has(key)) detail(code, "  │  ", key);
+    }
+    items.forEach((call) => visit(call, "  ", false, 0));
+    const key = `${rootId}:output`;
+    actions.set(lines.length, key);
+    lines.push(theme.fg("dim", "  └─ ") + theme.fg("mdLink", code ? "[Script output]" : "[Output]"));
+    if (owner.expanded || this.expanded.has(key)) detail(resultText(owner.result) || (owner.isPartial || !owner.result ? "Running…" : "No text output"), "     ", key);
+    if (this.incomplete.has(rootId)) lines.push(theme.fg("warning", "  [Nested call record is incomplete or truncated]"));
+    return { lines: lines.map((line) => truncateToWidth(line, Math.max(1, width), "…")), actions };
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-pretty-tui",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "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": "0.85.1",
-    "@earendil-works/pi-tui": "0.85.1",
+    "@earendil-works/pi-coding-agent": "1.0.0",
+    "@earendil-works/pi-tui": "1.0.0",
     "@types/node": "^24.0.0",
     "jiti": "^2.7.0",
     "typescript": "^5.9.0"