pi-pretty-tui 0.2.4 → 0.2.6

package/extensions/index.ts

@@ -1,3 +1,4 @@
+import { NestedTools, NESTED_SNAPSHOT_ENTRY } from "./nested-tools.js";
 import {
   AssistantMessageComponent,
   CustomEditor,
@@ -26,6 +27,7 @@ import {
   type TuiMouseEvent,
   visibleWidth,
   wrapTextWithAnsi,
+  getOsc8LinkAtColumn,
 } from "@earendil-works/pi-tui";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
@@ -95,6 +97,7 @@ export default function prettyTui(pi: ExtensionAPI) {
   let cleanToolsExpanded = false;
   let cleanContextCompacted = false;
   let fullscreenTui = false;
+  const mouseClickHitTests = new WeakMap<object, (event: any) => boolean>();
   let currentTui: any;
   let currentExtensionUi: any;
   let changingAllToolsExpansion = false;
@@ -192,6 +195,7 @@ export default function prettyTui(pi: ExtensionAPI) {
   };
   const responseAnswerTexts = new Map<string, string>();
   let responseRunStartedAt: number | undefined;
+  const RUNNING_DOT_INTERVAL_MS = 800;
   let workingElapsedTimer: ReturnType<typeof setInterval> | undefined;
   const stopWorkingElapsedTimer = () => {
     if (workingElapsedTimer) clearInterval(workingElapsedTimer);
@@ -199,7 +203,8 @@ export default function prettyTui(pi: ExtensionAPI) {
   };
   const startWorkingElapsedTimer = () => {
     if (workingElapsedTimer) return;
-    workingElapsedTimer = setInterval(() => currentTui?.requestRender?.(), 1000);
+    // Share one redraw clock between the elapsed label and Running-dot pulse.
+    workingElapsedTimer = setInterval(() => currentTui?.requestRender?.(), RUNNING_DOT_INTERVAL_MS);
     workingElapsedTimer.unref?.();
   };
   let responseHasAssistantMessage = false;
@@ -223,6 +228,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 +246,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[]>();
@@ -324,7 +336,7 @@ export default function prettyTui(pi: ExtensionAPI) {
         if (color === "error") return `\x1b[31m${text}\x1b[39m`;
         if (color === "success") return `\x1b[32m${text}\x1b[39m`;
         if (color === "syntaxComment") return markdownTheme.codeBlock(text);
-        if (color === "thinkingLow") return markdownTheme.link(text);
+        if (color === "thinkingLow" || color === "mdLink") return markdownTheme.link(text);
         if (color === "dim" || color === "muted" || color === "thinkingText") {
           return markdownTheme.quote(text);
         }
@@ -373,7 +385,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 +828,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;
@@ -874,8 +892,9 @@ export default function prettyTui(pi: ExtensionAPI) {
         };
       };
       const border = (text: string) => currentExtensionUi?.theme?.fg
-        ? currentExtensionUi.theme.fg("accent", text)
-        : markdownTheme.quoteBorder(text);
+        ? currentExtensionUi.theme.fg("mdLink", text)
+        : markdownTheme.link(text);
+      const userText = typeof this.text === "string" ? this.text : "";
       const frame: Component = {
         render(width: number): string[] {
           const measured = layout(width);
@@ -894,37 +913,51 @@ export default function prettyTui(pi: ExtensionAPI) {
           return [top, ...body, bottom].map((line: string) => left + line + right);
         },
         handleMouse(event: any) {
-          if (!markdown.handleMouse) return undefined;
           const measured = layout(event.width);
-          if (!measured.framed) {
-            return withTranscriptMarkdown(() => markdown.handleMouse({
+          const height = measured.body.length + (measured.framed ? 2 : 0);
+          if (
+            event.x < measured.leftPad ||
+            event.x >= measured.leftPad + measured.frameWidth ||
+            event.y < 0 || event.y >= height
+          ) return undefined;
+
+          // Preserve code-block Copy controls before the enclosing bubble action.
+          const contentX = measured.leftPad + (measured.framed ? 2 : 0);
+          const contentY = measured.framed ? 1 : 0;
+          let result;
+          if (
+            markdown.handleMouse &&
+            event.x >= contentX && event.x < contentX + measured.contentWidth &&
+            event.y >= contentY && event.y < contentY + measured.body.length
+          ) {
+            result = withTranscriptMarkdown(() => markdown.handleMouse({
               ...event,
-              x: event.x - measured.leftPad,
+              x: event.x - contentX,
+              y: event.y - contentY,
               width: measured.contentWidth,
+              height: measured.body.length,
             }));
+            if (result?.handled) return result;
           }
-          const contentX = measured.leftPad + 2;
-          if (
-            event.y <= 0 ||
-            event.y > measured.body.length ||
-            event.x < contentX ||
-            event.x >= contentX + measured.contentWidth
-          ) {
-            return undefined;
+          if (fullscreenTui && event.type === "click" && event.button === "left" && userText.trim()) {
+            copyTranscriptText(userText);
+            return { handled: true };
           }
-          return withTranscriptMarkdown(() => markdown.handleMouse({
-            ...event,
-            x: event.x - contentX,
-            y: event.y - 1,
-            width: measured.contentWidth,
-            height: measured.body.length,
-          }));
+          return result;
         },
         invalidate() {
           markdown.invalidate?.();
         },
       };
 
+      const bubbleClickHitTest = (event: any) => {
+        if (!fullscreenTui || !userText.trim()) return false;
+        const measured = layout(event.width);
+        return event.x >= measured.leftPad && event.x < measured.leftPad + measured.frameWidth &&
+          event.y >= 0 && event.y < measured.body.length + (measured.framed ? 2 : 0);
+      };
+      mouseClickHitTests.set(frame, bubbleClickHitTest);
+      mouseClickHitTests.set(this, bubbleClickHitTest);
       this.clear();
       this.addChild(frame);
     };
@@ -1136,7 +1169,7 @@ export default function prettyTui(pi: ExtensionAPI) {
           text,
           theme,
           component: new Markdown(text, 0, 0, owner.markdownTheme, {
-            color: (line: string) => theme.fg("thinkingText", line),
+            color: (line: string) => theme.fg("muted", line),
             italic: true,
           }),
         };
@@ -1221,11 +1254,15 @@ export default function prettyTui(pi: ExtensionAPI) {
       const terminalLines = terminalMember && visibleLines.length === 0
         ? renderPendingActivityUpdate(terminalMember, width)
         : [];
-      const appendTail = (activityLines: string[]) => [
-        ...activityLines,
-        ...terminalLines,
-        ...visibleLines,
-      ];
+      const appendTail = (activityLines: string[]) => {
+        mouseClickHitTests.set(this, (event) => renderMode === "clean" &&
+          event.y >= (position.first ? 1 : 0) && event.y < activityLines.length);
+        return [
+          ...activityLines,
+          ...terminalLines,
+          ...visibleLines,
+        ];
+      };
       const revealed = activityGroupRevealed(group);
       if (!revealed) {
         const activityLines = position.first
@@ -1268,8 +1305,8 @@ export default function prettyTui(pi: ExtensionAPI) {
       }
       const stateLabel = this.isStreaming ? "thinking" : "thought";
       const label = truncateToWidth(stateLabel, Math.max(1, childWidth - 2), "…");
-      const header = groupTheme.fg("thinkingLow", "● ") +
-        groupTheme.fg("toolTitle", groupTheme.bold(label));
+      const header = groupTheme.fg("mdLink", "● ") +
+        groupTheme.fg("text", groupTheme.bold(label));
       let contentLines: string[] = [header];
       if (expanded) {
         contentLines.push(...thinkingDetailLines(
@@ -1472,6 +1509,7 @@ export default function prettyTui(pi: ExtensionAPI) {
   const toolsExpansionPatchKey = Symbol.for("pretty-tui.clean-tool-expansion");
   if (!interactiveModePrototype[toolsExpansionPatchKey]) {
     const originalSetToolsExpanded = interactiveModePrototype.setToolsExpanded;
+    const originalToggleToolOutputExpansion = interactiveModePrototype.toggleToolOutputExpansion;
     const originalRenderSessionEntries = interactiveModePrototype.renderSessionEntries;
     const originalSwitchTuiMode = interactiveModePrototype.switchTuiMode;
     const originalShowExtensionNotify = interactiveModePrototype.showExtensionNotify;
@@ -1479,8 +1517,28 @@ 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 patchedToggleToolOutputExpansion = function (this: any) {
+      if (renderMode !== "clean") {
+        return originalToggleToolOutputExpansion.call(this);
+      }
+      this.showStatus(
+        "Activity details expand individually in clean mode\nClick a group, tool, thought, or section to expand/collapse it.",
+      );
+    };
     const patchedSetToolsExpanded = function (this: any, expanded: boolean) {
       cleanToolsExpanded = expanded;
+      nestedTools.clearExpansion();
       collapsedActivityGroups.clear();
       changingAllToolsExpansion = true;
       if (!expanded) {
@@ -1504,6 +1562,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);
     };
 
@@ -1559,9 +1629,9 @@ export default function prettyTui(pi: ExtensionAPI) {
       }
       // Do not change Pi's persisted hideThinkingBlock setting in clean mode.
       // Thought details use the activity hierarchy instead: click one thought,
-      // or use Ctrl+O when every member should expand together.
+      // Keyboard visibility toggles only explain these local controls.
       this.showStatus(
-        "Thought details expand individually in clean mode\nClick a thought, or use Ctrl+O to expand all.",
+        "Thought details expand individually in clean mode\nClick a thought to expand/collapse its details.",
       );
     };
 
@@ -1588,9 +1658,168 @@ 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,
+      originalToggleToolOutputExpansion,
+      patchedToggleToolOutputExpansion,
       originalRenderSessionEntries,
       patchedRenderSessionEntries,
       originalSwitchTuiMode,
@@ -1605,8 +1834,15 @@ export default function prettyTui(pi: ExtensionAPI) {
       patchedShowWarning,
       originalShowError,
       patchedShowError,
+      originalAddCacheMissNotice,
+      patchedAddCacheMissNotice,
+      originalMaybeShowCacheMissNotice,
+      patchedMaybeShowCacheMissNotice,
+      originalAddMessageToChat,
+      patchedAddMessageToChat,
     };
     interactiveModePrototype.setToolsExpanded = patchedSetToolsExpanded;
+    interactiveModePrototype.toggleToolOutputExpansion = patchedToggleToolOutputExpansion;
     interactiveModePrototype.renderSessionEntries = patchedRenderSessionEntries;
     interactiveModePrototype.switchTuiMode = patchedSwitchTuiMode;
     interactiveModePrototype.showExtensionNotify = patchedShowExtensionNotify;
@@ -1614,6 +1850,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;
@@ -1622,6 +1867,9 @@ export default function prettyTui(pi: ExtensionAPI) {
       currentExtensionUi = undefined;
       const patch = interactiveModePrototype[toolsExpansionPatchKey];
       if (!patch) return;
+      if (patch.patchedToggleToolOutputExpansion === interactiveModePrototype.toggleToolOutputExpansion) {
+        interactiveModePrototype.toggleToolOutputExpansion = patch.originalToggleToolOutputExpansion;
+      }
       if (patch.patchedSetToolsExpanded === interactiveModePrototype.setToolsExpanded) {
         interactiveModePrototype.setToolsExpanded = patch.originalSetToolsExpanded;
       }
@@ -1646,39 +1894,98 @@ 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.toggleToolOutputExpansion === patch.originalToggleToolOutputExpansion &&
         interactiveModePrototype.renderSessionEntries === patch.originalRenderSessionEntries &&
         interactiveModePrototype.switchTuiMode === patch.originalSwitchTuiMode &&
         interactiveModePrototype.showExtensionNotify === patch.originalShowExtensionNotify &&
         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];
       }
     });
   }
 
-  // Fullscreen selection only emits a component click when press and release
-  // land on the exact same cell. Give clean group rows a tiny horizontal
-  // tolerance so an ordinary click does not turn into an accidental selection.
+  // Allow same-row horizontal jitter only on our interactive regions. Keep
+  // real drags, links, ordinary transcript selection, and multi-click rules native.
   const altScreenPrototype = TuiAltScreen.prototype as any;
   const cleanSummaryClickPatchKey = Symbol.for("pretty-tui.clean-summary-click");
   const cleanSummaryPressKey = Symbol("pretty-tui.clean-summary-press");
+  const cleanControlPressKey = Symbol("pretty-tui.control-press");
   if (!altScreenPrototype[cleanSummaryClickPatchKey]) {
     const originalHandleSelectionMouseEvent = altScreenPrototype.handleSelectionMouseEvent;
+    const originalHandleMouseEvent = altScreenPrototype.handleMouseEvent;
     const summaryAtPoint = (screen: any, x: number, y: number): boolean => {
       const line = stripTerminalSequences(screen.previousScreen?.[y] ?? "");
       const match = /●\s+(?:Done|Running)\([^)]*\)/.exec(line);
-      return Boolean(match && x >= match.index && x < match.index + match[0].length);
+      if (match) {
+        const start = visibleWidth(line.slice(0, match.index));
+        if (x >= start && x < start + visibleWidth(match[0])) return true;
+      }
+      const collapse = line.indexOf(collapseLabel);
+      const start = visibleWidth(line.slice(0, collapse));
+      return renderMode === "clean" && collapse >= 0 && x >= start && x < start + visibleWidth(collapseLabel);
+    };
+    const interactiveAtPoint = (screen: any, x: number, y: number): boolean => {
+      if (screen.hasOverlay?.()) return false;
+      if (getOsc8LinkAtColumn(screen.previousScreen?.[y] ?? "", x)) return false;
+      const visit = (box: any): boolean => {
+        if (!box?.rect || !box?.clip || x < box.clip.x || y < box.clip.y ||
+          x >= box.clip.x + box.clip.width || y >= box.clip.y + box.clip.height) return false;
+        if ((box.children ?? []).some(visit)) return true;
+        const hitTest = mouseClickHitTests.get(box.component);
+        return Boolean(hitTest?.({
+          x: x - box.rect.x, y: y - box.rect.y,
+          width: box.rect.width, height: box.rect.height,
+        }));
+      };
+      return visit(screen.currentLayout?.root) || summaryAtPoint(screen, x, y);
+    };
+    const withinTolerance = (press: any, event: any): boolean =>
+      event.y === press.y && Math.abs(event.x - press.x) <= 2;
+    const isUnmodifiedLeftPress = (event: any): boolean =>
+      !event.release && (event.button & (32 | 64 | 4 | 8 | 16)) === 0 && (event.button & 3) === 0;
+    // Copy controls can consume press, bypassing the selection handler entirely.
+    const patchedHandleMouseEvent = function (this: any, event: any) {
+      if (isUnmodifiedLeftPress(event)) {
+        if (interactiveAtPoint(this, event.x, event.y)) this[cleanControlPressKey] = { x: event.x, y: event.y };
+        else delete this[cleanControlPressKey];
+      } else {
+        const press = this[cleanControlPressKey];
+        if (press && this.mousePressTarget && !this.mouseCapture) {
+          if ((event.button & 32) !== 0 && withinTolerance(press, event)) return;
+          if (event.release) {
+            delete this[cleanControlPressKey];
+            if (withinTolerance(press, event)) {
+              return originalHandleMouseEvent.call(this, { ...event, x: press.x });
+            }
+          } else delete this[cleanControlPressKey];
+        }
+        if (event.release || (event.button & 64) !== 0) delete this[cleanControlPressKey];
+      }
+      return originalHandleMouseEvent.call(this, event);
     };
     const patchedHandleSelectionMouseEvent = function (this: any, event: any) {
       const isMotion = (event.button & 32) !== 0;
-      const isLeftPress = !event.release && !isMotion && (event.button & 3) === 0;
+      const isLeftPress = isUnmodifiedLeftPress(event);
       if (isLeftPress) {
-        if (summaryAtPoint(this, event.x, event.y)) {
+        if (interactiveAtPoint(this, event.x, event.y)) {
           this[cleanSummaryPressKey] = { x: event.x, y: event.y };
         } else {
           delete this[cleanSummaryPressKey];
@@ -1688,8 +1995,7 @@ export default function prettyTui(pi: ExtensionAPI) {
 
       const press = this[cleanSummaryPressKey];
       if (press) {
-        const withinClickTolerance =
-          event.y === press.y && Math.abs(event.x - press.x) <= 2;
+        const withinClickTolerance = withinTolerance(press, event);
         if (isMotion && withinClickTolerance) {
           return;
         }
@@ -1708,17 +2014,24 @@ export default function prettyTui(pi: ExtensionAPI) {
     altScreenPrototype[cleanSummaryClickPatchKey] = {
       originalHandleSelectionMouseEvent,
       patchedHandleSelectionMouseEvent,
+      originalHandleMouseEvent,
+      patchedHandleMouseEvent,
     };
     altScreenPrototype.handleSelectionMouseEvent = patchedHandleSelectionMouseEvent;
+    altScreenPrototype.handleMouseEvent = patchedHandleMouseEvent;
 
     pi.on("session_shutdown", () => {
       const patch = altScreenPrototype[cleanSummaryClickPatchKey];
+      if (patch?.patchedHandleMouseEvent === altScreenPrototype.handleMouseEvent) {
+        altScreenPrototype.handleMouseEvent = patch.originalHandleMouseEvent;
+      }
       if (patch?.patchedHandleSelectionMouseEvent === altScreenPrototype.handleSelectionMouseEvent) {
         altScreenPrototype.handleSelectionMouseEvent = patch.originalHandleSelectionMouseEvent;
       }
       if (
         patch &&
-        altScreenPrototype.handleSelectionMouseEvent === patch.originalHandleSelectionMouseEvent
+        altScreenPrototype.handleSelectionMouseEvent === patch.originalHandleSelectionMouseEvent &&
+        altScreenPrototype.handleMouseEvent === patch.originalHandleMouseEvent
       ) {
         delete altScreenPrototype[cleanSummaryClickPatchKey];
       }
@@ -1747,6 +2060,10 @@ export default function prettyTui(pi: ExtensionAPI) {
 
     const patchedRender = function (this: any, width: number): string[] {
       const scoped = transcriptMarkdownActive();
+      mouseClickHitTests.set(this, (event) => fullscreenTui &&
+        this[transcriptMarkdownStateKey] === true &&
+        (this[codeBlockRegionsKey] ?? []).some((region: any) =>
+          event.y === region.y && event.x >= region.xStart && event.x < region.xEnd));
       if (this[transcriptMarkdownStateKey] !== scoped) {
         delete this[codeBlockCollectionKey];
         delete this[codeBlockRegionsKey];
@@ -2107,31 +2424,17 @@ 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: "  ",
     content:
-      theme.fg("accent", theme.bold(name)) +
+      theme.fg("text", theme.bold(name)) +
       theme.fg("dim", "(") +
-      theme.fg("text", detail) +
+      theme.fg("muted", detail) +
       theme.fg("dim", ")"),
   });
 
@@ -2396,10 +2699,10 @@ export default function prettyTui(pi: ExtensionAPI) {
     const dotColor = component.result?.isError
       ? "error"
       : component.result && !component.isPartial
-        ? successMarkerColor(theme)
-        : "accent";
+        ? "success"
+        : "dim";
     const title = theme.fg(dotColor, "● ") +
-      theme.fg("accent", theme.bold(label)) +
+      theme.fg("text", theme.bold(label)) +
       (args ? theme.fg("muted", `(${args})`) : "");
     const result = thirdPartyResultSummary(component);
     const resultColor = component.result?.isError ? "error" : "muted";
@@ -2568,10 +2871,27 @@ export default function prettyTui(pi: ExtensionAPI) {
       const group = activityTimeline.groupForMember(member.id);
       if (renderMode !== "clean" || !group) return originalToolRender.call(this, width);
       const position = activityMemberPosition(group, member);
+      let renderedHeight = 0;
+      let nestedClickActions: Map<number, string> | undefined;
+      const renderedSummaryHeight = position.first ? renderActivityGroupSummary(group, width).length : 0;
+      mouseClickHitTests.set(this, (event) => {
+        if (renderMode !== "clean") return false;
+        if (event.width !== width) return false;
+        const summaryHeight = renderedSummaryHeight;
+        if (position.first && event.y > 0 && event.y <= summaryHeight) return true;
+        if (!activityGroupRevealed(group)) return false;
+        const height = renderedHeight;
+        if (position.last && event.y === height - 1) {
+          return activityCollapseClicked(group, member, { ...event, type: "click", button: "left" }, height - 1);
+        }
+        const contentY = event.y - (position.first ? summaryHeight + 1 : 0);
+        if (nestedClickActions) return nestedClickActions.has(contentY);
+        return contentY >= 0 && event.y < height - (position.last ? 1 : 0);
+      });
       if (!activityGroupRevealed(group)) {
-        return position.first
-          ? ["", ...renderActivityGroupSummary(group, width, true)]
-          : [];
+        const lines = position.first ? ["", ...renderActivityGroupSummary(group, width, true)] : [];
+        renderedHeight = lines.length;
+        return lines;
       }
 
       const childTheme = cleanThemeForToolCall(this.toolCallId) ?? activityGroupTheme(group);
@@ -2585,7 +2905,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 +2922,11 @@ export default function prettyTui(pi: ExtensionAPI) {
         decoratedContent = cached.lines;
       } else {
         let contentLines: string[];
-        if (thirdParty) {
+        if (nestedTools.count(this.toolCallId) > 0) {
+          const projection = nestedTools.render(this, childWidth, childTheme);
+          contentLines = projection.lines;
+          nestedClickActions = projection.actions;
+        } else if (thirdParty) {
           const summaryLines = renderThirdPartyCompact(this, childWidth, childTheme);
           if (this.expanded) {
             const detailPrefix = "  │ ";
@@ -2650,10 +2974,12 @@ export default function prettyTui(pi: ExtensionAPI) {
           };
         }
       }
-      return withActivityCollapse(
+      const lines = withActivityCollapse(
         group, member, width,
         position.first ? ["", ...renderActivityGroupSummary(group, width), ...decoratedContent] : decoratedContent,
       );
+      renderedHeight = lines.length;
+      return lines;
     };
     const patchedToolHandleMouse = function (this: any, event: any) {
       const member = activityTimeline.memberForTool(this.toolCallId);
@@ -2686,6 +3012,22 @@ 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, Boolean(this.expanded));
+          this.updateDisplay?.();
+          this.ui?.requestRender?.();
+        }
+        // The parent title is informational; only disclosure rows act on clicks.
+        // 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 +3157,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 +3173,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,12 +3183,15 @@ export default function prettyTui(pi: ExtensionAPI) {
     thoughtCount: number,
     activity: DisplayValue = "done",
     collapsedDone = false,
+    nestedCount = 0,
   ): DisplayRow => ({
     prefix: () => {
       const currentActivity = typeof activity === "function" ? activity() : activity;
+      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"
-        : "accent";
+        : dimPhase ? "dim" : "accent";
       return theme.fg(color, "● ");
     },
     continuation: "  ",
@@ -2858,7 +3204,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 +3254,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 +3264,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 +3276,7 @@ export default function prettyTui(pi: ExtensionAPI) {
         group.thoughtCount,
         live,
         collapsedDone,
+        nestedCount,
       )]).render(width));
     }
     if (!owner && !activityTimeline.isSettled(group.id)) {
@@ -2939,6 +3288,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 +3300,7 @@ export default function prettyTui(pi: ExtensionAPI) {
       group.thoughtCount,
       "done",
       collapsedDone,
+      nestedCount,
     )]).render(width));
   };
 
@@ -3042,6 +3393,8 @@ export default function prettyTui(pi: ExtensionAPI) {
     return {
       render(width: number): string[] {
         const data = entry.data;
+        mouseClickHitTests.set(this, (event) => fullscreenTui && copyStart >= 0 &&
+          event.y === 0 && event.x >= copyStart && event.x < copyStart + copyWidth);
         if (!data || width <= 0) return [];
         copyStart = -1;
         copyWidth = 0;
@@ -3148,6 +3501,7 @@ export default function prettyTui(pi: ExtensionAPI) {
     settledSummaries.clear();
     legacySummaryLastToolCallIds.clear();
     activityTimeline.clear();
+    nestedTools.clear();
     responseAnswerTexts.clear();
     responseRunStartedAt = undefined;
     responseHasAssistantMessage = false;
@@ -3307,6 +3661,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 +3749,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 +3835,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 +3932,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 +3950,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 +4005,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.