pi-pretty-tui 0.1.8 → 0.2.1

package/extensions/index.ts

@@ -1,6 +1,7 @@
 import {
   AssistantMessageComponent,
   CustomEditor,
+  CustomMessageComponent,
   InteractiveMode,
   ToolExecutionComponent,
   UserMessageComponent,
@@ -13,6 +14,7 @@ import {
   createWriteTool,
   copyToClipboard,
   getAgentDir,
+  getMarkdownTheme,
   type ExtensionAPI,
 } from "@earendil-works/pi-coding-agent";
 import {
@@ -27,10 +29,42 @@ import {
 } from "@earendil-works/pi-tui";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import {
+  ActivityTimeline,
+  assistantMessageKey,
+  assistantTerminalState,
+  thinkingText,
+  visibleAssistantText,
+  type ActivityGroup,
+  type ActivityMember,
+  type ActivitySeverity,
+} from "./activity-timeline.js";
 
 type PrettyTuiMode = "full" | "compact" | "clean";
 const CLEAN_TOOL_ACTIVITY_MIN_MS = 1000;
+const TRANSIENT_UI_STATUS_MS = 10_000;
+const SPECIALIZED_TOOL_NAMES = new Set(["read", "bash", "edit", "write", "grep", "find", "ls"]);
+
+const stripAnsiBackgrounds = (value: string): string =>
+  value.replace(/\x1b\[([0-9:;]*)m/g, (sequence, raw: string) => {
+    const fields = raw === "" ? [0] : raw.split(";").map((field) => Number(field));
+    const kept: number[] = [];
+    for (let index = 0; index < fields.length; index++) {
+      const field = fields[index];
+      if ((field >= 40 && field <= 49) || (field >= 100 && field <= 107)) continue;
+      if (field === 48) {
+        const mode = fields[index + 1];
+        if (mode === 5) index += 2;
+        else if (mode === 2) index += 4;
+        continue;
+      }
+      kept.push(field);
+    }
+    if (raw.includes(":") && /(?:^|;)48:/u.test(raw)) return "";
+    return kept.length > 0 ? `\x1b[${kept.join(";")}m` : "";
+  });
 type PrettyTuiConfig = {
+  enabled?: boolean;
   mode?: PrettyTuiMode;
   /** Legacy location used by the first mode implementation. */
   bash?: {
@@ -52,6 +86,7 @@ export default function prettyTui(pi: ExtensionAPI) {
   const cwd = process.cwd();
   const configPath = join(getAgentDir(), "pretty-tui.json");
   let config = loadConfig(configPath);
+  const activeForSession = config.enabled !== false;
   const configuredMode = config.mode ?? config.bash?.mode;
   let renderMode: PrettyTuiMode = configuredMode === "full" || configuredMode === "compact" || configuredMode === "clean"
     ? configuredMode
@@ -62,6 +97,90 @@ export default function prettyTui(pi: ExtensionAPI) {
   let currentTui: any;
   let currentExtensionUi: any;
   let changingAllToolsExpansion = false;
+  const latestActivityWidgetKey = "pretty-tui-latest-activity";
+  type LatestActivityStatus = {
+    title: string;
+    detail?: string;
+    severity?: TransientStatusSeverity;
+  };
+  // The editor-adjacent flash reports Pi UI state ("status") and pretty-tui's
+  // own UI outcomes, so it has its own severities. Activity members only ever
+  // carry info, warning, or error.
+  type TransientStatusSeverity = "status" | "success" | "error";
+  let latestActivityStatus: LatestActivityStatus | undefined;
+  let latestActivityWidgetInstalled = false;
+  let latestActivityStatusTimer: ReturnType<typeof setTimeout> | undefined;
+  let latestActivityStatusGeneration = 0;
+  const renderLatestActivityStatus = (status: LatestActivityStatus, width: number, theme: any): string => {
+    const severity = status.severity ?? "status";
+    const icon = severity === "error" ? "✕" : severity === "success" ? "✓" : "◇";
+    const color = severity === "error"
+      ? "error"
+      : severity === "success"
+        ? "success"
+        : "dim";
+    const detail = status.detail?.trim() ? ` — ${status.detail.trim()}` : "";
+    return truncateToWidth(` ${theme.fg(color, `${icon} ${status.title}`)}${theme.fg("dim", detail)}`, Math.max(1, width), "…");
+  };
+  const refreshLatestActivityWidget = () => {
+    if (!currentExtensionUi?.setWidget) return;
+    if (renderMode !== "clean" || !latestActivityStatus) {
+      if (latestActivityWidgetInstalled) {
+        currentExtensionUi.setWidget(latestActivityWidgetKey, undefined);
+        latestActivityWidgetInstalled = false;
+      }
+      return;
+    }
+    if (latestActivityWidgetInstalled) {
+      currentTui?.requestRender?.();
+      return;
+    }
+    currentExtensionUi.setWidget(
+      latestActivityWidgetKey,
+      (_tui: any, theme: any) => ({
+        render: (width: number) => latestActivityStatus
+          ? [renderLatestActivityStatus(latestActivityStatus, width, theme)]
+          : [],
+        invalidate() {},
+      }),
+      { placement: "aboveEditor" },
+    );
+    latestActivityWidgetInstalled = true;
+  };
+  const clearLatestActivityStatus = () => {
+    latestActivityStatusGeneration++;
+    if (latestActivityStatusTimer) clearTimeout(latestActivityStatusTimer);
+    latestActivityStatusTimer = undefined;
+    latestActivityStatus = undefined;
+    if (latestActivityWidgetInstalled) {
+      currentExtensionUi?.setWidget?.(latestActivityWidgetKey, undefined);
+      latestActivityWidgetInstalled = false;
+    }
+  };
+  const setLatestActivityStatus = (status: LatestActivityStatus) => {
+    const generation = ++latestActivityStatusGeneration;
+    if (latestActivityStatusTimer) clearTimeout(latestActivityStatusTimer);
+    latestActivityStatus = status;
+    refreshLatestActivityWidget();
+    latestActivityStatusTimer = setTimeout(() => {
+      if (generation !== latestActivityStatusGeneration) return;
+      clearLatestActivityStatus();
+      currentTui?.requestRender?.();
+    }, TRANSIENT_UI_STATUS_MS);
+  };
+  const activityTimeline = new ActivityTimeline();
+  const revealedActivityGroups = new Set<string>();
+  const expandedThinkingMembers = new Set<string>();
+  const thinkingComponents = new Map<string, any>();
+  const activityFallbackThemes = new Map<string, any>();
+  const activityUpdateComponents = new Map<string, Component>();
+  const activityUpdateMarkdownComponents = new Map<string, {
+    content: string;
+    theme: any;
+    component: Markdown;
+  }>();
+  let activityUpdateSequence = 0;
+  const assistantBoundaryKeys = new Set<string>();
   const cleanCompactToolCallIds = new Set<string>();
   const cleanGroupToolCallIds = new Map<string, string[]>();
   const cleanToolCallGroupOwners = new Map<string, string>();
@@ -70,6 +189,20 @@ export default function prettyTui(pi: ExtensionAPI) {
   const cleanToolNames = new Map<string, string>();
   let renderCleanGroupSummary = (_lastToolCallId: string, _width: number): string[] => [];
 
+  // Markdown enhancements are active only while pi-pretty-tui renders the main
+  // conversation transcript. Plugin overlays also use Pi's Markdown class, so
+  // a global always-on prototype patch would leak transcript styling into them.
+  let transcriptMarkdownDepth = 0;
+  const withTranscriptMarkdown = <T>(callback: () => T): T => {
+    transcriptMarkdownDepth++;
+    try {
+      return callback();
+    } finally {
+      transcriptMarkdownDepth--;
+    }
+  };
+  const transcriptMarkdownActive = () => transcriptMarkdownDepth > 0;
+
   const setCleanGroupMembers = (lastToolCallId: string, toolCallIds: string[]) => {
     cleanGroupToolCallIds.set(lastToolCallId, toolCallIds);
     for (const toolCallId of toolCallIds) cleanToolCallGroupOwners.set(toolCallId, lastToolCallId);
@@ -77,31 +210,288 @@ export default function prettyTui(pi: ExtensionAPI) {
 
   const isCleanGroupRevealed = (toolCallId: string): boolean => {
     if (cleanCompactToolCallIds.has(toolCallId)) return true;
-    const groupOwner = cleanToolCallGroupOwners.get(toolCallId);
-    const groupToolCallIds = groupOwner ? cleanGroupToolCallIds.get(groupOwner) : undefined;
-    return groupToolCallIds?.some((id) => cleanCompactToolCallIds.has(id)) ?? false;
+    const activityGroup = activityTimeline.groupForTool(toolCallId);
+    if (activityGroup && activityGroupRevealed(activityGroup)) return true;
+    const legacyOwner = cleanToolCallGroupOwners.get(toolCallId);
+    const legacyIds = legacyOwner ? cleanGroupToolCallIds.get(legacyOwner) : undefined;
+    return legacyIds?.some((id) => cleanCompactToolCallIds.has(id)) ?? false;
   };
 
   const cleanThemeForToolCall = (toolCallId: string): any => {
     const directTheme = cleanToolThemes.get(toolCallId);
     if (directTheme) return directTheme;
-    const groupOwner = cleanToolCallGroupOwners.get(toolCallId);
-    const groupToolCallIds = groupOwner ? cleanGroupToolCallIds.get(groupOwner) : undefined;
-    return groupToolCallIds
-      ?.map((id) => cleanToolThemes.get(id))
-      .find(Boolean);
+    const activityGroup = activityTimeline.groupForTool(toolCallId);
+    // Prefer a real tool renderer theme over the Markdown-derived fallback.
+    // A group that starts with Thought installs the fallback first; returning
+    // it here made later third-party success dots use the heading color.
+    if (activityGroup) {
+      for (const id of activityGroup.toolCallIds) {
+        const activityTheme = cleanToolThemes.get(id);
+        if (activityTheme) {
+          activityFallbackThemes.set(activityGroup.id, activityTheme);
+          return activityTheme;
+        }
+      }
+    }
+    const cachedActivityTheme = activityGroup
+      ? activityFallbackThemes.get(activityGroup.id)
+      : undefined;
+    if (cachedActivityTheme) return cachedActivityTheme;
+    const legacyOwner = cleanToolCallGroupOwners.get(toolCallId);
+    const legacyIds = legacyOwner ? cleanGroupToolCallIds.get(legacyOwner) : undefined;
+    return legacyIds?.map((id) => cleanToolThemes.get(id)).find(Boolean);
+  };
+
+  const activityGroupOwner = (group: ActivityGroup): string | undefined => {
+    for (let index = group.toolCallIds.length - 1; index >= 0; index--) {
+      const toolCallId = group.toolCallIds[index];
+      if (settledSummaries.has(toolCallId)) return toolCallId;
+    }
+    if (cleanRun.activeToolCallId && group.toolCallIds.includes(cleanRun.activeToolCallId)) {
+      return cleanRun.activeToolCallId;
+    }
+    if (cleanRun.lastCompletedToolCallId && group.toolCallIds.includes(cleanRun.lastCompletedToolCallId)) {
+      return cleanRun.lastCompletedToolCallId;
+    }
+    return group.toolCallIds[group.toolCallIds.length - 1];
   };
 
-  const saveRenderMode = (mode: PrettyTuiMode) => {
-    config = { ...config, mode };
+  const defaultActivityTheme = () => {
+    if (currentExtensionUi?.theme?.fg) return currentExtensionUi.theme;
+    const markdownTheme = getMarkdownTheme();
+    return {
+      fg: (color: string, text: string) => {
+        if (color === "accent") return markdownTheme.listBullet(text);
+        // Session UI normally supplies Pi's active Theme above. Keep portable
+        // semantic fallbacks for early startup and isolated renderer tests.
+        if (color === "warning") return `\x1b[33m${text}\x1b[39m`;
+        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 === "dim" || color === "muted" || color === "thinkingText") {
+          return markdownTheme.quote(text);
+        }
+        return text;
+      },
+      bold: markdownTheme.bold,
+      italic: markdownTheme.italic,
+    };
+  };
+
+  const activityGroupTheme = (group: ActivityGroup): any => {
+    // A Thought can render before its tools are constructed and install a
+    // Markdown fallback. Always promote a real tool theme once available so
+    // light mode receives explicit, high-contrast text colors.
+    for (const toolCallId of group.toolCallIds) {
+      const toolTheme = cleanToolThemes.get(toolCallId);
+      if (toolTheme) {
+        activityFallbackThemes.set(group.id, toolTheme);
+        return toolTheme;
+      }
+    }
+    const cached = activityFallbackThemes.get(group.id);
+    if (cached) return cached;
+    const fallback = defaultActivityTheme();
+    activityFallbackThemes.set(group.id, fallback);
+    return fallback;
+  };
+
+  const activityGroupRevealed = (group: ActivityGroup): boolean =>
+    cleanToolsExpanded || revealedActivityGroups.has(group.id);
+
+  // A group is revealable once it owns anything renderable beneath its parent
+  // row. Thinking counts on its own: a tool-free turn still gets a parent row
+  // with its Thought as the child member.
+  const activityGroupCollapsible = (group: ActivityGroup): boolean =>
+    activityTimeline.hasWork(group);
+
+  const activityMemberPosition = (group: ActivityGroup, member: ActivityMember) => ({
+    first: group.members[0]?.id === member.id,
+    last: group.members[group.members.length - 1]?.id === member.id,
+  });
+
+  const activityTreeStyle = (
+    group: ActivityGroup,
+    member: ActivityMember,
+    width: number,
+    memberTheme?: any,
+  ) => {
+    const { last } = activityMemberPosition(group, member);
+    const rawPrefix = last ? "  └─ " : "  ├─ ";
+    const rawContinuation = last ? "     " : "  │  ";
+    const prefixWidth = visibleWidth(rawPrefix);
+    if (width <= prefixWidth) {
+      return { prefix: "", continuation: "", childWidth: Math.max(1, width), prefixWidth: 0 };
+    }
+    const resolvedTheme = memberTheme ?? activityGroupTheme(group);
+    return {
+      prefix: resolvedTheme ? resolvedTheme.fg("dim", rawPrefix) : rawPrefix,
+      continuation: resolvedTheme ? resolvedTheme.fg("dim", rawContinuation) : rawContinuation,
+      childWidth: Math.max(1, width - prefixWidth),
+      prefixWidth,
+    };
+  };
+
+  const humanizeCustomType = (value: string): string =>
+    value
+      .split(/[-_\s]+/u)
+      .filter(Boolean)
+      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+      .join(" ") || "Update";
+
+  const renderActivityUpdateMarkdown = (
+    member: ActivityMember,
+    width: number,
+    theme: any,
+  ): string[] => {
+    const content = member.updateContent ?? "";
+    if (!content) return [];
+    let cached = activityUpdateMarkdownComponents.get(member.id);
+    if (!cached || cached.content !== content || cached.theme !== theme) {
+      cached = {
+        content,
+        theme,
+        component: new Markdown(
+          content,
+          0,
+          0,
+          getMarkdownTheme(),
+          { color: (text: string) => theme.fg("muted", text) },
+        ),
+      };
+      activityUpdateMarkdownComponents.set(member.id, cached);
+    }
+    const lines = withTranscriptMarkdown(() => cached.component.render(Math.max(1, width)));
+    while (lines.length > 0 && stripTerminalSequences(lines[lines.length - 1]).trim() === "") {
+      lines.pop();
+    }
+    return lines;
+  };
+
+  const activityUpdateStyle = (member: ActivityMember, theme: any) => {
+    const severity = member.updateSeverity ?? "info";
+    const styles: Record<ActivitySeverity, { icon: string; color: string }> = {
+      info: { icon: "◇", color: "accent" },
+      warning: { icon: "⚠", color: "warning" },
+      error: { icon: "✕", color: "error" },
+    };
+    const style = styles[severity];
+    return {
+      severity,
+      icon: theme.fg(style.color, `${style.icon} `),
+      title: (text: string) => theme.fg(style.color, theme.bold(text)),
+    };
+  };
+
+  const renderActivityUpdate = (
+    group: ActivityGroup,
+    member: ActivityMember,
+    width: number,
+    theme = activityGroupTheme(group),
+  ): string[] => {
+    if (renderMode !== "clean" || !activityGroupRevealed(group)) return [];
+    const { prefix, continuation, childWidth } = activityTreeStyle(group, member, width, theme);
+    const title = truncateToWidth(member.updateTitle ?? "Update", Math.max(1, childWidth - 2), "…");
+    const style = activityUpdateStyle(member, theme);
+    const lines = [style.icon + style.title(title)];
+    if (member.updateContent) {
+      const detailWidth = Math.max(1, childWidth - visibleWidth("  │ "));
+      const detailLines = renderActivityUpdateMarkdown(member, detailWidth, theme);
+      lines.push(...detailLines.map((line, index) =>
+        theme.fg("dim", index === detailLines.length - 1 ? "  └ " : "  │ ") + line
+      ));
+    }
+    const decorated = lines.map((line, index) =>
+      truncateToWidth((index === 0 ? prefix : continuation) + line, Math.max(1, width), "")
+    );
+    const position = activityMemberPosition(group, member);
+    return position.first
+      ? ["", ...renderActivityGroupSummary(group, width), ...decorated]
+      : decorated;
+  };
+
+  const renderPendingActivityUpdate = (member: ActivityMember, width: number): string[] => {
+    const theme = defaultActivityTheme();
+    const title = truncateToWidth(member.updateTitle ?? "Update", Math.max(1, width - 2), "…");
+    const style = activityUpdateStyle(member, theme);
+    const lines = [style.icon + style.title(title)];
+    if (member.updateContent) {
+      const detailWidth = Math.max(1, width - visibleWidth("  │ "));
+      const details = renderActivityUpdateMarkdown(member, detailWidth, theme);
+      lines.push(...details.map((line, index) =>
+        theme.fg("dim", index === details.length - 1 ? "  └ " : "  │ ") + line
+      ));
+    }
+    return ["", ...lines.map((line) => truncateToWidth(line, Math.max(1, width), ""))];
+  };
+
+  const renderActivityUpdateProjection = (
+    group: ActivityGroup,
+    member: ActivityMember,
+    width: number,
+  ): string[] => {
+    if (!activityGroupCollapsible(group)) return renderPendingActivityUpdate(member, width);
+    const position = activityMemberPosition(group, member);
+    if (!activityGroupRevealed(group)) {
+      return position.first
+        ? ["", ...renderActivityGroupSummary(group, width, true)]
+        : [];
+    }
+    return renderActivityUpdate(group, member, width);
+  };
+
+  const handleActivityUpdateMouse = (
+    group: ActivityGroup,
+    member: ActivityMember,
+    event: any,
+  ) => {
+    const isLeftClick = event.type === "click" && event.button === "left";
+    if (!isLeftClick || !activityGroupCollapsible(group)) return undefined;
+    const position = activityMemberPosition(group, member);
+    if (!activityGroupRevealed(group)) {
+      if (!position.first) return undefined;
+      revealedActivityGroups.add(group.id);
+      for (const toolCallId of group.toolCallIds) cleanCompactToolCallIds.add(toolCallId);
+    } else {
+      const summaryHeight = position.first ? renderActivityGroupSummary(group, event.width).length : 0;
+      if (!position.first || event.y <= 0 || event.y > summaryHeight) return undefined;
+      revealedActivityGroups.delete(group.id);
+      for (const toolCallId of group.toolCallIds) {
+        cleanCompactToolCallIds.delete(toolCallId);
+        const component = cleanToolComponents.get(toolCallId);
+        if (component?.expanded) component.setExpanded(false);
+      }
+      for (const child of group.members) expandedThinkingMembers.delete(child.id);
+    }
+    for (const child of group.members) {
+      if (child.kind === "tool" && child.toolCallId) {
+        cleanToolComponents.get(child.toolCallId)?.updateDisplay?.();
+      } else if (child.kind === "thinking" && child.messageKey) {
+        thinkingComponents.get(child.messageKey)?.invalidate?.();
+      } else if (child.kind === "update") {
+        activityUpdateComponents.get(child.id)?.invalidate?.();
+      }
+    }
+    currentTui?.requestRender?.();
+    return { handled: true };
+  };
+
+  const saveConfig = (nextConfig: Record<string, any>) => {
+    config = nextConfig;
     mkdirSync(getAgentDir(), { recursive: true });
     writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
   };
 
+  const saveRenderMode = (mode: PrettyTuiMode) => saveConfig({ ...config, mode });
+  const saveEnabled = (enabled: boolean) => saveConfig({ ...config, enabled });
+
   pi.registerCommand("pretty-tui", {
-    description: "Configure pi-pretty-tui rendering mode",
+    description: "Configure pi-pretty-tui",
     getArgumentCompletions: (prefix: string) => {
       const items = [
+        { value: "enable", label: "enable", description: "Enable the extension and reload automatically" },
+        { value: "disable", label: "disable", description: "Disable the extension and reload automatically" },
         { value: "full", label: "full", description: "Full tool details and output" },
         { value: "compact", label: "compact", description: "Concise summaries for all built-in tools" },
         { value: "clean", label: "clean", description: "Group supported tools into Running/Done status" },
@@ -115,29 +505,69 @@ export default function prettyTui(pi: ExtensionAPI) {
 
       if (!requested) {
         if (!ctx.hasUI) {
-          ctx.ui.notify(`pi-pretty-tui mode: ${renderMode}`, "info");
+          ctx.ui.notify(
+            `pi-pretty-tui: ${config.enabled !== false ? "enabled" : "disabled"} · mode: ${renderMode}`,
+            "info",
+          );
           return;
         }
+        const enabled = `Enabled — ${config.enabled !== false ? "on" : "off"}`;
         const full = `Full — full tool details and output${renderMode === "full" ? " (current)" : ""}`;
         const compact = `Compact — concise summaries for all built-in tools${renderMode === "compact" ? " (current)" : ""}`;
         const clean = `Clean — group supported tools into Running/Done status${renderMode === "clean" ? " (current)" : ""}`;
-        const selected = await ctx.ui.select("pi-pretty-tui rendering mode", [full, compact, clean]);
+        const selected = await ctx.ui.select("pi-pretty-tui settings", [enabled, full, compact, clean]);
         if (!selected) return;
-        requested = selected === full ? "full" : selected === compact ? "compact" : "clean";
+        requested = selected === enabled
+          ? config.enabled !== false ? "disable" : "enable"
+          : selected === full
+            ? "full"
+            : selected === compact
+              ? "compact"
+              : "clean";
       }
 
       if (requested === "status") {
-        ctx.ui.notify(`pi-pretty-tui mode: ${renderMode}`, "info");
+        ctx.ui.notify(
+          `pi-pretty-tui: ${config.enabled !== false ? "enabled" : "disabled"} · mode: ${renderMode}`,
+          "info",
+        );
         return;
       }
+      if (requested === "enable" || requested === "disable") {
+        const enabled = requested === "enable";
+        try {
+          saveEnabled(enabled);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          ctx.ui.notify(`Could not save pi-pretty-tui setting: ${message}`, "error");
+          return;
+        }
+        ctx.ui.notify(
+          `pi-pretty-tui ${enabled ? "enabled" : "disabled"}; reloading…`,
+          "info",
+        );
+        try {
+          await ctx.reload();
+          return;
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          ctx.ui.notify(`Setting saved, but automatic reload failed: ${message}`, "warning");
+          return;
+        }
+      }
       if (requested !== "full" && requested !== "compact" && requested !== "clean") {
-        ctx.ui.notify("Usage: /pretty-tui [full|compact|clean|status]", "error");
+        ctx.ui.notify("Usage: /pretty-tui [enable|disable|full|compact|clean|status]", "error");
         return;
       }
 
       cleanCompactToolCallIds.clear();
+      revealedActivityGroups.clear();
+      expandedThinkingMembers.clear();
       renderMode = requested;
+      if (renderMode === "clean") refreshLatestActivityWidget();
+      else clearLatestActivityStatus();
       for (const component of cleanToolComponents.values()) component.updateDisplay?.();
+      for (const component of thinkingComponents.values()) component.invalidate?.();
       try {
         saveRenderMode(renderMode);
         ctx.ui.notify(`pi-pretty-tui mode set to: ${renderMode}`, "info");
@@ -148,6 +578,10 @@ export default function prettyTui(pi: ExtensionAPI) {
     },
   });
 
+  // Keep the settings command available while disabled, but do not install
+  // render patches or override built-in tools until the next enabled reload.
+  if (!activeForSession) return;
+
   // Give Pi's main prompt editor a complete rounded frame. Render the native
   // editor at a two-column narrower width so cursor layout, wrapping, IME, and
   // autocomplete remain native, then add one themed border column per side.
@@ -258,12 +692,35 @@ export default function prettyTui(pi: ExtensionAPI) {
           const top = border(topStart + markdownTheme.bold(title) + topTail + "╮");
           const bottom = border("╰" + "─".repeat(Math.max(0, frameWidth - 2)) + "╯");
           const contentWidth = Math.max(1, frameWidth - 4);
-          const body = content.render(contentWidth).map((line: string) => {
+          const body = withTranscriptMarkdown(() => content.render(contentWidth)).map((line: string) => {
             const padding = " ".repeat(Math.max(0, contentWidth - visibleWidth(line)));
             return border("│ ") + line + padding + border(" │");
           });
           return [top, ...body, bottom].map((line: string) => outer + paintBackground(line));
         },
+        handleMouse(event: any) {
+          if (!content.handleMouse) return undefined;
+          const sidePad = Math.min(outputPad, Math.max(0, Math.floor((event.width - 1) / 2)));
+          const frameWidth = Math.max(1, event.width - sidePad * 2);
+          if (frameWidth < 4) {
+            return withTranscriptMarkdown(() => content.handleMouse({
+              ...event,
+              x: event.x - sidePad,
+              width: frameWidth,
+            }));
+          }
+          const contentWidth = Math.max(1, frameWidth - 4);
+          if (event.y <= 0 || event.x < sidePad + 2 || event.x >= sidePad + 2 + contentWidth) {
+            return undefined;
+          }
+          return withTranscriptMarkdown(() => content.handleMouse({
+            ...event,
+            x: event.x - sidePad - 2,
+            y: event.y - 1,
+            width: contentWidth,
+            height: Math.max(0, event.height - 2),
+          }));
+        },
         invalidate() {
           content.invalidate?.();
         },
@@ -291,63 +748,437 @@ export default function prettyTui(pi: ExtensionAPI) {
     });
   }
 
-  // Pi's built-in assistant component turns hidden thinking into a static
-  // "Thinking..." label. In collapsed clean mode, omit that label entirely;
-  // the clean-mode Running(...) row owns activity, while Ctrl+O still reveals
-  // the thinking content. The component is exported by Pi specifically for
-  // extension-level rendering customizations, so patch its public methods
-  // rather than Pi's source.
+  const customMessageKey = (message: any): string => {
+    if (message?.timestamp !== undefined) {
+      const parsed = typeof message.timestamp === "string"
+        ? Date.parse(message.timestamp)
+        : Number(message.timestamp);
+      return Number.isFinite(parsed) ? String(parsed) : String(message.timestamp);
+    }
+    return `${message?.customType ?? "custom"}:${JSON.stringify(message?.content ?? "")}`;
+  };
+
+  const customMessageText = (message: any): string =>
+    typeof message?.content === "string"
+      ? message.content
+      : Array.isArray(message?.content)
+        ? message.content
+          .filter((item: any) => item?.type === "text" && typeof item.text === "string")
+          .map((item: any) => item.text)
+          .join("\n")
+        : "";
+
+  // Delegates to the timeline so the precondition is stated once. The `??` is
+  // deliberate: the callee may still decline, and a dropped notification must
+  // never throw inside a third-party extension's ctx.ui.notify() call.
+  const hasWorkActivity = (group: ActivityGroup | undefined): boolean =>
+    activityTimeline.hasWork(group);
+
+  const addPersistentActivityUpdate = (message: any): ActivityMember => {
+    const key = customMessageKey(message);
+    const title = humanizeCustomType(message?.customType ?? "update");
+    const content = customMessageText(message);
+    const existingGroup = activityTimeline.currentGroup();
+    const joinsWork = hasWorkActivity(existingGroup);
+    const member = joinsWork
+      ? activityTimeline.addUpdate(key, title, content, true, "info") ??
+        activityTimeline.addPendingUpdate(key, title, content, true, "info")
+      : activityTimeline.addPendingUpdate(key, title, content, true, "info");
+    // A displayed custom message without current model/tool work is an
+    // independent durable update, never a pending member of the next run.
+    if (!hasWorkActivity(existingGroup)) activityTimeline.boundary();
+    return member;
+  };
+
+  const nativeCustomBoundaryKeys = new Set<string>();
+  let closeCleanAtNativeCustomBoundary = () => activityTimeline.boundary();
+  let closeCleanAtStandaloneAlert = () => activityTimeline.boundary();
+  const customMessagePrototype = CustomMessageComponent.prototype as any;
+  const customMessagePatchKey = Symbol.for("pretty-tui.clean-custom-message");
+  if (!customMessagePrototype[customMessagePatchKey]) {
+    const originalCustomRender = customMessagePrototype.render;
+    const originalCustomHandleMouse = customMessagePrototype.handleMouse;
+    const releaseSemanticCustomMessage = (component: any): boolean => {
+      if (!component.customRenderer) return false;
+      const key = customMessageKey(component.message);
+      if (!nativeCustomBoundaryKeys.has(key)) {
+        nativeCustomBoundaryKeys.add(key);
+        const member = activityTimeline.memberForUpdate(key);
+        if (member) activityUpdateComponents.delete(member.id);
+        activityTimeline.removeUpdate(key);
+        closeCleanAtNativeCustomBoundary();
+      }
+      return true;
+    };
+    const patchedCustomRender = function (this: any, width: number): string[] {
+      if (releaseSemanticCustomMessage(this)) {
+        return originalCustomRender.call(this, width);
+      }
+      const message = this.message;
+      const key = customMessageKey(message);
+      let member = activityTimeline.memberForUpdate(key);
+      // Extension-injected custom messages do not always emit Pi's model
+      // message_start event. Claim them at the component boundary so live
+      // rendering matches transcript restoration instead of failing open to
+      // the purple native box until the next reload.
+      if (!member && renderMode === "clean") {
+        member = addPersistentActivityUpdate(message);
+      }
+      const group = member ? activityTimeline.groupForMember(member.id) : undefined;
+      if (renderMode !== "clean" || !member || !group) {
+        return originalCustomRender.call(this, width);
+      }
+      activityUpdateComponents.set(member.id, this);
+      return renderActivityUpdateProjection(group, member, width);
+    };
+    const patchedCustomHandleMouse = function (this: any, event: any) {
+      if (releaseSemanticCustomMessage(this)) {
+        return originalCustomHandleMouse?.call(this, event);
+      }
+      const member = activityTimeline.memberForUpdate(customMessageKey(this.message));
+      const group = member ? activityTimeline.groupForMember(member.id) : undefined;
+      if (renderMode !== "clean" || !member || !group) {
+        return originalCustomHandleMouse?.call(this, event);
+      }
+      return handleActivityUpdateMouse(group, member, event);
+    };
+    customMessagePrototype[customMessagePatchKey] = {
+      originalRender: originalCustomRender,
+      patchedRender: patchedCustomRender,
+      originalHandleMouse: originalCustomHandleMouse,
+      patchedHandleMouse: patchedCustomHandleMouse,
+    };
+    customMessagePrototype.render = patchedCustomRender;
+    customMessagePrototype.handleMouse = patchedCustomHandleMouse;
+    pi.on("session_shutdown", () => {
+      const patch = customMessagePrototype[customMessagePatchKey];
+      if (!patch) return;
+      if (patch.patchedRender === customMessagePrototype.render) {
+        customMessagePrototype.render = patch.originalRender;
+      }
+      if (patch.patchedHandleMouse === customMessagePrototype.handleMouse) {
+        customMessagePrototype.handleMouse = patch.originalHandleMouse;
+      }
+      if (
+        customMessagePrototype.render === patch.originalRender &&
+        customMessagePrototype.handleMouse === patch.originalHandleMouse
+      ) {
+        delete customMessagePrototype[customMessagePatchKey];
+      }
+    });
+  }
+
+  // Thinking and tools are peers in the transcript-first activity timeline.
+  // Assistant components keep Pi's native Markdown renderer, while clean mode
+  // projects each thinking run as a compact, independently expandable child.
   const assistantPrototype = AssistantMessageComponent.prototype as any;
   const thinkingPatchKey = Symbol.for("pretty-tui.clean-thinking");
   if (!assistantPrototype[thinkingPatchKey]) {
     const originalUpdateContent = assistantPrototype.updateContent;
     const originalRender = assistantPrototype.render;
+    const originalHandleMouse = assistantPrototype.handleMouse;
     const originalMessageKey = Symbol("pretty-tui.original-assistant-message");
     const renderedModeKey = Symbol("pretty-tui.rendered-assistant-mode");
-    const renderedExpansionKey = Symbol("pretty-tui.rendered-thinking-expansion");
+    const renderedExpansionKey = Symbol("pretty-tui.rendered-assistant-expansion");
+    const cleanThinkingRenderCacheKey = Symbol("pretty-tui.clean-thinking-render-cache");
+    const cleanThinkingDetailKey = Symbol("pretty-tui.clean-thinking-detail");
+
+    const assistantTerminalUpdate = (message: any): ActivityMember | undefined => {
+      if (!assistantTerminalState(message)) return undefined;
+      const hasToolCalls = Array.isArray(message?.content) &&
+        message.content.some((item: any) => item?.type === "toolCall");
+      // Failed tools already preserve the error in their native result details;
+      // avoid duplicating that payload as a second durable member.
+      if (hasToolCalls) return undefined;
+      const key = `assistant-terminal:${assistantMessageKey(message)}`;
+      const existing = activityTimeline.memberForUpdate(key);
+      if (existing) return existing;
+      const stopReason = message?.stopReason;
+      const severity: ActivitySeverity = stopReason === "aborted" ? "warning" : "error";
+      const title = stopReason === "length"
+        ? "Response truncated"
+        : stopReason === "aborted"
+          ? "Operation aborted"
+          : "Error";
+      const content = String(message?.errorMessage ?? "").trim() ||
+        (stopReason === "length" ? "Response was truncated before completion." : "Unknown error");
+      activityTimeline.boundary();
+      const member = activityTimeline.addPendingUpdate(key, title, content, true, severity);
+      activityTimeline.boundary();
+      return member;
+    };
+
+    const eligibleThinking = (message: any) =>
+      Array.isArray(message?.content) &&
+      message.content.some(
+        (item: any) => item?.type === "thinking" &&
+          typeof item.thinking === "string" &&
+          item.thinking.length > 0,
+      );
+
+    const refreshGroup = (group: ActivityGroup) => {
+      for (const member of group.members) {
+        if (member.kind === "tool" && member.toolCallId) {
+          cleanToolComponents.get(member.toolCallId)?.updateDisplay?.();
+        } else if (member.kind === "thinking" && member.messageKey) {
+          thinkingComponents.get(member.messageKey)?.invalidate?.();
+        } else if (member.kind === "update") {
+          activityUpdateComponents.get(member.id)?.invalidate?.();
+        }
+      }
+      currentTui?.requestRender?.();
+    };
+
+    // Shared detail projection for a Thought, used both as a member of a tool
+    // group and as a standalone row. The cache records its theme because the
+    // same component can switch between the Markdown fallback and a real tool
+    // theme once the first tool of the group is constructed.
+    const thinkingDetailLines = (
+      owner: any,
+      text: string,
+      theme: any,
+      childWidth: number,
+    ): string[] => {
+      let detail = owner[cleanThinkingDetailKey];
+      if (!detail || detail.text !== text || detail.theme !== theme) {
+        detail = {
+          text,
+          theme,
+          component: new Markdown(text, 0, 0, owner.markdownTheme, {
+            color: (line: string) => theme.fg("thinkingText", line),
+            italic: true,
+          }),
+        };
+        owner[cleanThinkingDetailKey] = detail;
+      }
+      const lines: string[] = detail.component.render(Math.max(1, childWidth));
+      return lines.map((line, index) =>
+        theme.fg("dim", index === lines.length - 1 ? "  └ " : "  │ ") + line
+      );
+    };
 
     const patchedUpdateContent = function (this: any, message: any, isStreaming = this.isStreaming) {
+      this[originalMessageKey] = message;
+      this[renderedModeKey] = renderMode;
+      this[renderedExpansionKey] = cleanToolsExpanded;
+      this.lastMessage = message;
       if (renderMode !== "clean") {
         originalUpdateContent.call(this, message, isStreaming);
-        this[originalMessageKey] = message;
-        this[renderedModeKey] = renderMode;
-        this[renderedExpansionKey] = undefined;
+        this.lastMessage = message;
         return;
       }
+      const groupedThinking = eligibleThinking(message);
+      if (groupedThinking) {
+        const key = assistantMessageKey(message);
+        activityTimeline.addThinking(key, thinkingText(message));
+        thinkingComponents.set(key, this);
+      }
 
-      const showThinking = cleanToolsExpanded;
-      const content = Array.isArray(message?.content) ? message.content : [];
-      // In collapsed clean mode, omit Pi's built-in Thinking... placeholder
-      // entirely. The clean-mode Running(...) row owns the activity label;
-      // expanded mode still reveals the actual thinking content.
-      const displayMessage = showThinking
-        ? message
-        : { ...message, content: content.filter((item: any) => item.type !== "thinking") };
       const previousHideThinkingBlock = this.hideThinkingBlock;
       this.hideThinkingBlock = false;
+      // Clean mode owns grouped thinking completely. Removing it from Pi's
+      // native content tree also removes the native MouseRegion that would
+      // otherwise toggle a second, unrelated `Thinking...` block.
+      const displayMessage =
+        groupedThinking && Array.isArray(message?.content)
+          ? { ...message, content: message.content.filter((item: any) => item.type !== "thinking") }
+          : message;
       try {
         originalUpdateContent.call(this, displayMessage, isStreaming);
       } finally {
         this.hideThinkingBlock = previousHideThinkingBlock;
       }
-
-      // Pi's invalidate()/setHideThinkingBlock() call updateContent with
-      // lastMessage, so retain the unfiltered message for later mode changes.
-      this[originalMessageKey] = message;
-      this[renderedModeKey] = renderMode;
-      this[renderedExpansionKey] = showThinking;
       this.lastMessage = message;
     };
 
-    const patchedRender = function (this: any, width: number): string[] {
-      const needsRefresh = this[originalMessageKey] && (
-        this[renderedModeKey] !== renderMode ||
-        (renderMode === "clean" && this[renderedExpansionKey] !== cleanToolsExpanded)
+    const renderAssistantTranscript = function (this: any, width: number): string[] {
+      const message = this[originalMessageKey] ?? this.lastMessage;
+      if (
+        message &&
+        (this[renderedModeKey] !== renderMode || this[renderedExpansionKey] !== cleanToolsExpanded)
+      ) {
+        patchedUpdateContent.call(this, message, this.isStreaming);
+      }
+      if (renderMode !== "clean") return originalRender.call(this, width);
+      const terminalMember = assistantTerminalUpdate(message);
+      if (!eligibleThinking(message)) {
+        if (!terminalMember) return originalRender.call(this, width);
+        const terminalGroup = activityTimeline.groupForMember(terminalMember.id);
+        if (!terminalGroup) return originalRender.call(this, width);
+        activityUpdateComponents.set(terminalMember.id, this);
+        return renderActivityUpdateProjection(terminalGroup, terminalMember, width);
+      }
+
+      const key = assistantMessageKey(message);
+      const member = activityTimeline.memberForThinking(key);
+      const group = member ? activityTimeline.groupForMember(member.id) : undefined;
+      if (!member || !group) {
+        // Timeline ownership can be briefly unavailable during transcript
+        // rebuilds. Fail open to Pi's filtered native renderer so visible
+        // assistant text is never lost.
+        return originalRender.call(this, width);
+      }
+      thinkingComponents.set(key, this);
+      if (!activityFallbackThemes.has(group.id)) {
+        activityFallbackThemes.set(group.id, defaultActivityTheme());
+      }
+      const position = activityMemberPosition(group, member);
+      const visibleLines = visibleAssistantText(message) ? originalRender.call(this, width) : [];
+      // Pi's native renderer prints its own error line for messages with no
+      // tool calls, so this component only adds the styled alert card when no
+      // visible text can carry it.
+      const terminalLines = terminalMember && visibleLines.length === 0
+        ? renderPendingActivityUpdate(terminalMember, width)
+        : [];
+      const appendTail = (activityLines: string[]) => [
+        ...activityLines,
+        ...terminalLines,
+        ...visibleLines,
+      ];
+      const revealed = activityGroupRevealed(group);
+      if (!revealed) {
+        const activityLines = position.first
+          ? ["", ...renderActivityGroupSummary(group, width, true)]
+          : [];
+        return appendTail(activityLines);
+      }
+
+      const groupTheme = activityGroupTheme(group);
+      const { prefix, continuation, childWidth } = activityTreeStyle(
+        group,
+        member,
+        width,
+        groupTheme,
+      );
+      // Clean mode owns thought disclosure: revealing a group shows the thought
+      // member, while only a member click (or Ctrl+O) reveals its full text.
+      const expanded = cleanToolsExpanded || expandedThinkingMembers.has(member.id);
+      const settledOwner = position.first ? activityGroupOwner(group) : undefined;
+      // A group without tools has no durable summary, so its own boundary is
+      // the signal that it finished.
+      const stableSummary = !position.first || (
+        settledOwner
+          ? Boolean(settledSummaries.has(settledOwner) && !toolActivityHolds.has(settledOwner))
+          : activityTimeline.isSettled(group.id)
       );
-      if (needsRefresh) {
-        patchedUpdateContent.call(this, this[originalMessageKey], this.isStreaming);
+      const cacheable = !expanded && !this.isStreaming && stableSummary;
+      const cached = cacheable ? this[cleanThinkingRenderCacheKey] : undefined;
+      if (
+        cached?.width === width &&
+        cached?.message === message &&
+        cached?.theme === groupTheme &&
+        cached?.memberCount === group.members.length &&
+        cached?.last === position.last
+      ) {
+        // Only the stable activity projection is cached. Visible assistant
+        // text belongs outside the collapsible group and must be appended on
+        // every render, including cache hits.
+        return appendTail(cached.lines);
+      }
+      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));
+      let contentLines: string[] = [header];
+      if (expanded) {
+        contentLines.push(...thinkingDetailLines(
+          this,
+          member.thinking ?? thinkingText(message),
+          groupTheme,
+          Math.max(1, childWidth - visibleWidth("  │ ")),
+        ));
+      }
+      const decorated = contentLines.map((line, index) =>
+        truncateToWidth((index === 0 ? prefix : continuation) + line, Math.max(1, width), "")
+      );
+      const output = position.first
+        ? ["", ...renderActivityGroupSummary(group, width), ...decorated]
+        : decorated;
+      if (cacheable) {
+        this[cleanThinkingRenderCacheKey] = {
+          width,
+          message,
+          theme: groupTheme,
+          memberCount: group.members.length,
+          last: position.last,
+          lines: output,
+        };
+      }
+      return appendTail(output);
+    };
+
+    const patchedRender = function (this: any, width: number): string[] {
+      return withTranscriptMarkdown(() => renderAssistantTranscript.call(this, width));
+    };
+
+    const handleAssistantTranscriptMouse = function (this: any, event: any) {
+      const message = this[originalMessageKey] ?? this.lastMessage;
+      if (renderMode !== "clean") return originalHandleMouse.call(this, event);
+      if (!eligibleThinking(message)) {
+        const terminalMember = assistantTerminalUpdate(message);
+        const terminalGroup = terminalMember
+          ? activityTimeline.groupForMember(terminalMember.id)
+          : undefined;
+        return terminalMember && terminalGroup && activityGroupCollapsible(terminalGroup)
+          ? handleActivityUpdateMouse(terminalGroup, terminalMember, event)
+          : originalHandleMouse.call(this, event);
+      }
+      const key = assistantMessageKey(message);
+      const member = activityTimeline.memberForThinking(key);
+      const group = member ? activityTimeline.groupForMember(member.id) : undefined;
+      if (!member || !group) return originalHandleMouse.call(this, event);
+      const position = activityMemberPosition(group, member);
+      const isLeftClick = event.type === "click" && event.button === "left";
+
+      // A completed assistant message can contain both the final Thought and
+      // visible Markdown. The Markdown is rendered after the activity rows;
+      // route clicks in that suffix back to Pi's native component so links,
+      // text selection, and code-block Copy controls keep working.
+      if (visibleAssistantText(message)) {
+        const visibleLines = originalRender.call(this, event.width);
+        const renderedLines = patchedRender.call(this, event.width);
+        const activityHeight = Math.max(0, renderedLines.length - visibleLines.length);
+        if (event.y >= activityHeight) {
+          return originalHandleMouse.call(this, {
+            ...event,
+            y: event.y - activityHeight,
+            height: visibleLines.length,
+          });
+        }
+      }
+
+      if (!activityGroupRevealed(group)) {
+        if (!isLeftClick) return undefined;
+        if (position.first) {
+          revealedActivityGroups.add(group.id);
+          for (const toolCallId of group.toolCallIds) cleanCompactToolCallIds.add(toolCallId);
+          refreshGroup(group);
+        }
+        return { handled: true };
+      }
+      const summaryHeight = position.first ? renderActivityGroupSummary(group, event.width).length : 0;
+      if (position.first && event.y > 0 && event.y <= summaryHeight && isLeftClick) {
+        revealedActivityGroups.delete(group.id);
+        for (const toolCallId of group.toolCallIds) {
+          cleanCompactToolCallIds.delete(toolCallId);
+          const component = cleanToolComponents.get(toolCallId);
+          if (component?.expanded) component.setExpanded(false);
+        }
+        for (const child of group.members) expandedThinkingMembers.delete(child.id);
+        refreshGroup(group);
+        return { handled: true };
       }
-      return originalRender.call(this, width);
+      if (isLeftClick) {
+        if (expandedThinkingMembers.has(member.id)) expandedThinkingMembers.delete(member.id);
+        else expandedThinkingMembers.add(member.id);
+        refreshGroup(group);
+        return { handled: true };
+      }
+      return undefined;
+    };
+
+    const patchedHandleMouse = function (this: any, event: any) {
+      return withTranscriptMarkdown(() => handleAssistantTranscriptMouse.call(this, event));
     };
 
     assistantPrototype[thinkingPatchKey] = {
@@ -355,9 +1186,12 @@ export default function prettyTui(pi: ExtensionAPI) {
       patchedUpdateContent,
       originalRender,
       patchedRender,
+      originalHandleMouse,
+      patchedHandleMouse,
     };
     assistantPrototype.updateContent = patchedUpdateContent;
     assistantPrototype.render = patchedRender;
+    assistantPrototype.handleMouse = patchedHandleMouse;
 
     pi.on("session_shutdown", () => {
       const patch = assistantPrototype[thinkingPatchKey];
@@ -368,9 +1202,13 @@ export default function prettyTui(pi: ExtensionAPI) {
       if (patch.patchedRender === assistantPrototype.render) {
         assistantPrototype.render = patch.originalRender;
       }
+      if (patch.patchedHandleMouse === assistantPrototype.handleMouse) {
+        assistantPrototype.handleMouse = patch.originalHandleMouse;
+      }
       if (
         assistantPrototype.updateContent === patch.originalUpdateContent &&
-        assistantPrototype.render === patch.originalRender
+        assistantPrototype.render === patch.originalRender &&
+        assistantPrototype.handleMouse === patch.originalHandleMouse
       ) {
         delete assistantPrototype[thinkingPatchKey];
       }
@@ -403,20 +1241,69 @@ export default function prettyTui(pi: ExtensionAPI) {
     ];
   };
 
+  const appendRuntimeActivityUpdate = (
+    mode: any,
+    message: string,
+    severity: ActivitySeverity,
+  ): boolean => {
+    const [firstLine, ...remainingLines] = String(message).split("\n");
+    const fallbackTitle = severity === "warning"
+      ? "Warning"
+      : severity === "error"
+        ? "Error"
+        : "Info";
+    const title = firstLine || fallbackTitle;
+    const content = remainingLines.join("\n");
+    // Warnings and errors are standalone hard boundaries; only ordinary notices
+    // join the work in progress.
+    const standalone = severity === "warning" || severity === "error";
+    const updateKey = `runtime:${severity}:${++activityUpdateSequence}`;
+    if (standalone) closeCleanAtStandaloneAlert();
+    const existingGroup = activityTimeline.currentGroup();
+    const joinsWork = !standalone && hasWorkActivity(existingGroup);
+    const member = joinsWork
+      ? activityTimeline.addUpdate(updateKey, title, content, false, severity) ??
+        activityTimeline.addPendingUpdate(updateKey, title, content, false, severity)
+      : activityTimeline.addPendingUpdate(updateKey, title, content, false, severity);
+    if (!joinsWork) activityTimeline.boundary();
+    const group = activityTimeline.groupForMember(member.id);
+    if (!group || !mode.chatContainer?.addChild) return false;
+    const component: Component = {
+      render: (width: number) => renderActivityUpdateProjection(group, member, width),
+      invalidate() {},
+      handleMouse: (event: any) => handleActivityUpdateMouse(group, member, event),
+    } as Component;
+    activityUpdateComponents.set(member.id, component);
+    mode.chatContainer.addChild(component);
+    mode.ui?.requestRender?.();
+    return true;
+  };
+
   const interactiveModePrototype = InteractiveMode.prototype as any;
   const toolsExpansionPatchKey = Symbol.for("pretty-tui.clean-tool-expansion");
   if (!interactiveModePrototype[toolsExpansionPatchKey]) {
     const originalSetToolsExpanded = interactiveModePrototype.setToolsExpanded;
     const originalRenderSessionEntries = interactiveModePrototype.renderSessionEntries;
     const originalSwitchTuiMode = interactiveModePrototype.switchTuiMode;
+    const originalShowExtensionNotify = interactiveModePrototype.showExtensionNotify;
+    const originalToggleThinkingBlockVisibility = interactiveModePrototype.toggleThinkingBlockVisibility;
+    const originalShowStatus = interactiveModePrototype.showStatus;
+    const originalShowWarning = interactiveModePrototype.showWarning;
+    const originalShowError = interactiveModePrototype.showError;
     const patchedSetToolsExpanded = function (this: any, expanded: boolean) {
       cleanToolsExpanded = expanded;
       changingAllToolsExpansion = true;
-      if (!expanded) cleanCompactToolCallIds.clear();
+      if (!expanded) {
+        cleanCompactToolCallIds.clear();
+        revealedActivityGroups.clear();
+        expandedThinkingMembers.clear();
+      }
       try {
         return originalSetToolsExpanded.call(this, expanded);
       } finally {
         changingAllToolsExpansion = false;
+        for (const component of thinkingComponents.values()) component.invalidate?.();
+        this.ui?.requestRender?.();
       }
     };
 
@@ -426,11 +1313,8 @@ export default function prettyTui(pi: ExtensionAPI) {
       // buildContextEntries() prepends the latest compaction for model context,
       // while Pi's live compaction UI appends it chronologically. Keep reloads
       // and transcript rebuilds consistent with that live presentation.
-      return originalRenderSessionEntries.call(
-        this,
-        orderContextEntriesForTranscript(entries),
-        options,
-      );
+      const orderedEntries = orderContextEntriesForTranscript(entries);
+      return originalRenderSessionEntries.call(this, orderedEntries, options);
     };
 
     const patchedSwitchTuiMode = function (this: any, ...args: any[]) {
@@ -440,6 +1324,80 @@ export default function prettyTui(pi: ExtensionAPI) {
       return result;
     };
 
+    // Pi's own showExtensionNotify only dispatches to showStatus/showWarning/
+    // showError, and all three are replaced above. Delegating back to it would
+    // therefore re-enter these patches instead of restoring native behaviour,
+    // which sent info notifications into the transient UI flash. Route straight
+    // to the original method that matches the severity instead.
+    const nativeExtensionNotify = function (
+      this: any,
+      text: string,
+      severity: ActivitySeverity,
+    ): void {
+      const direct = severity === "error"
+        ? originalShowError
+        : severity === "warning"
+          ? originalShowWarning
+          : originalShowStatus;
+      try {
+        if (typeof direct === "function") direct.call(this, text);
+        else originalShowExtensionNotify.call(this, text, severity === "info" ? undefined : severity);
+      } catch {
+        // This host has no transcript to write to. The notification is already
+        // recorded in the activity timeline, and it does not belong in the
+        // transient UI flash, which only carries Pi UI state messages.
+      }
+    };
+
+    const patchedShowExtensionNotify = function (
+      this: any,
+      message: string,
+      type?: "info" | "warning" | "error",
+    ) {
+      if (renderMode !== "clean") {
+        return originalShowExtensionNotify.call(this, message, type);
+      }
+      const severity: ActivitySeverity = type ?? "info";
+      if (!appendRuntimeActivityUpdate(this, message, severity)) {
+        nativeExtensionNotify.call(this, message, severity);
+      }
+    };
+
+    const patchedToggleThinkingBlockVisibility = function (this: any) {
+      if (renderMode !== "clean") {
+        return originalToggleThinkingBlockVisibility.call(this);
+      }
+      // 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.
+      this.showStatus(
+        "Thought details expand individually in clean mode\nClick a thought, or use Ctrl+O to expand all.",
+      );
+    };
+
+    const patchedShowStatus = function (this: any, message: string) {
+      if (renderMode !== "clean") return originalShowStatus.call(this, message);
+      const [firstLine, ...remainingLines] = String(message).split("\n");
+      setLatestActivityStatus({
+        title: firstLine || "Status",
+        detail: remainingLines.join("\n"),
+        severity: "status",
+      });
+      this.ui?.requestRender?.();
+    };
+
+    const patchedShowWarning = function (this: any, message: string) {
+      if (renderMode !== "clean" || !appendRuntimeActivityUpdate(this, message, "warning")) {
+        return originalShowWarning.call(this, message);
+      }
+    };
+
+    const patchedShowError = function (this: any, message: string) {
+      if (renderMode !== "clean" || !appendRuntimeActivityUpdate(this, message, "error")) {
+        return originalShowError.call(this, message);
+      }
+    };
+
     interactiveModePrototype[toolsExpansionPatchKey] = {
       originalSetToolsExpanded,
       patchedSetToolsExpanded,
@@ -447,14 +1405,30 @@ export default function prettyTui(pi: ExtensionAPI) {
       patchedRenderSessionEntries,
       originalSwitchTuiMode,
       patchedSwitchTuiMode,
+      originalShowExtensionNotify,
+      patchedShowExtensionNotify,
+      originalToggleThinkingBlockVisibility,
+      patchedToggleThinkingBlockVisibility,
+      originalShowStatus,
+      patchedShowStatus,
+      originalShowWarning,
+      patchedShowWarning,
+      originalShowError,
+      patchedShowError,
     };
     interactiveModePrototype.setToolsExpanded = patchedSetToolsExpanded;
     interactiveModePrototype.renderSessionEntries = patchedRenderSessionEntries;
     interactiveModePrototype.switchTuiMode = patchedSwitchTuiMode;
+    interactiveModePrototype.showExtensionNotify = patchedShowExtensionNotify;
+    interactiveModePrototype.toggleThinkingBlockVisibility = patchedToggleThinkingBlockVisibility;
+    interactiveModePrototype.showStatus = patchedShowStatus;
+    interactiveModePrototype.showWarning = patchedShowWarning;
+    interactiveModePrototype.showError = patchedShowError;
 
     pi.on("session_shutdown", () => {
       fullscreenTui = false;
       currentTui = undefined;
+      clearLatestActivityStatus();
       currentExtensionUi = undefined;
       const patch = interactiveModePrototype[toolsExpansionPatchKey];
       if (!patch) return;
@@ -467,10 +1441,30 @@ export default function prettyTui(pi: ExtensionAPI) {
       if (patch.patchedSwitchTuiMode === interactiveModePrototype.switchTuiMode) {
         interactiveModePrototype.switchTuiMode = patch.originalSwitchTuiMode;
       }
+      if (patch.patchedShowExtensionNotify === interactiveModePrototype.showExtensionNotify) {
+        interactiveModePrototype.showExtensionNotify = patch.originalShowExtensionNotify;
+      }
+      if (patch.patchedToggleThinkingBlockVisibility === interactiveModePrototype.toggleThinkingBlockVisibility) {
+        interactiveModePrototype.toggleThinkingBlockVisibility = patch.originalToggleThinkingBlockVisibility;
+      }
+      if (patch.patchedShowStatus === interactiveModePrototype.showStatus) {
+        interactiveModePrototype.showStatus = patch.originalShowStatus;
+      }
+      if (patch.patchedShowWarning === interactiveModePrototype.showWarning) {
+        interactiveModePrototype.showWarning = patch.originalShowWarning;
+      }
+      if (patch.patchedShowError === interactiveModePrototype.showError) {
+        interactiveModePrototype.showError = patch.originalShowError;
+      }
       if (
         interactiveModePrototype.setToolsExpanded === patch.originalSetToolsExpanded &&
         interactiveModePrototype.renderSessionEntries === patch.originalRenderSessionEntries &&
-        interactiveModePrototype.switchTuiMode === patch.originalSwitchTuiMode
+        interactiveModePrototype.switchTuiMode === patch.originalSwitchTuiMode &&
+        interactiveModePrototype.showExtensionNotify === patch.originalShowExtensionNotify &&
+        interactiveModePrototype.toggleThinkingBlockVisibility === patch.originalToggleThinkingBlockVisibility &&
+        interactiveModePrototype.showStatus === patch.originalShowStatus &&
+        interactiveModePrototype.showWarning === patch.originalShowWarning &&
+        interactiveModePrototype.showError === patch.originalShowError
       ) {
         delete interactiveModePrototype[toolsExpansionPatchKey];
       }
@@ -546,6 +1540,7 @@ export default function prettyTui(pi: ExtensionAPI) {
   const codeBlockPatchKey = Symbol.for("pretty-tui.code-blocks");
   const codeBlockCollectionKey = Symbol("pretty-tui.code-block-collection");
   const codeBlockRegionsKey = Symbol("pretty-tui.code-block-regions");
+  const transcriptMarkdownStateKey = Symbol("pretty-tui.transcript-markdown-state");
   if (!markdownPrototype[codeBlockPatchKey]) {
     const originalInvalidate = markdownPrototype.invalidate;
     const originalRender = markdownPrototype.render;
@@ -561,6 +1556,15 @@ export default function prettyTui(pi: ExtensionAPI) {
     };
 
     const patchedRender = function (this: any, width: number): string[] {
+      const scoped = transcriptMarkdownActive();
+      if (this[transcriptMarkdownStateKey] !== scoped) {
+        delete this[codeBlockCollectionKey];
+        delete this[codeBlockRegionsKey];
+        originalInvalidate.call(this);
+        this[transcriptMarkdownStateKey] = scoped;
+      }
+      if (!scoped) return originalRender.call(this, width);
+
       const needsRender =
         !this.cachedLines || this.cachedText !== this.text || this.cachedWidth !== width;
       if (needsRender) this[codeBlockCollectionKey] = [];
@@ -604,6 +1608,10 @@ export default function prettyTui(pi: ExtensionAPI) {
       nextTokenType?: string,
       styleContext?: any,
     ): string[] {
+      if (!transcriptMarkdownActive()) {
+        return originalRenderToken.call(this, token, width, nextTokenType, styleContext);
+      }
+
       if (token?.type === "heading") {
         const level = Math.max(1, Math.min(6, Number(token.depth) || 1));
         const maxWidth = Math.max(1, width);
@@ -766,6 +1774,15 @@ export default function prettyTui(pi: ExtensionAPI) {
     };
 
     const patchedHandleMouse = function (this: any, event: TuiMouseEvent) {
+      // Fullscreen layout hit-testing may dispatch directly to this Markdown
+      // leaf instead of traversing AssistantMessageComponent.handleMouse. The
+      // most recent render therefore records whether this instance belongs to
+      // the main transcript; dynamic render scope alone is not sufficient.
+      const transcriptOwned = transcriptMarkdownActive() || this[transcriptMarkdownStateKey] === true;
+      if (!transcriptOwned) {
+        delete this[codeBlockRegionsKey];
+        return originalHandleMouse?.call(this, event);
+      }
       if (event.button === "left" && (event.type === "press" || event.type === "click")) {
         const region = (this[codeBlockRegionsKey] ?? []).find(
           (candidate: any) =>
@@ -782,8 +1799,14 @@ export default function prettyTui(pi: ExtensionAPI) {
             } else {
               // Defensive fallback for older Pi versions without the fullscreen helper.
               void copyToClipboard(region.code)
-                .then(() => currentExtensionUi?.notify("Copied!", "info"))
-                .catch(() => currentExtensionUi?.notify("Copy failed", "error"));
+                .then(() => setLatestActivityStatus({
+                  title: "Copied!",
+                  severity: "success",
+                }))
+                .catch(() => setLatestActivityStatus({
+                  title: "Copy failed",
+                  severity: "error",
+                }));
             }
           }
           return { handled: true, render: false };
@@ -913,10 +1936,24 @@ 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" ? "success" : status === "error" ? "error" : "dim";
+      const color = status === "success" ? successMarkerColor(theme) : status === "error" ? "error" : "dim";
       return theme.fg(color, "● ");
     },
     continuation: "  ",
@@ -930,7 +1967,7 @@ export default function prettyTui(pi: ExtensionAPI) {
   const call = (theme: any, name: string, detail: string, state: any) =>
     block([callRow(theme, name, detail, state)]);
 
-  const writeCall = (theme: any, path: string, content: string, expanded: boolean, state: any) => {
+  const writeCall = (theme: any, name: string, path: string, content: string, expanded: boolean, state: any) => {
     const lines = content.replace(/\t/g, "    ").split("\n");
     while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
 
@@ -938,14 +1975,14 @@ export default function prettyTui(pi: ExtensionAPI) {
     const shown = lines.slice(0, expanded ? total : 10);
     const remaining = total - shown.length;
     const rows: DisplayRow[] = [
-      callRow(theme, "Write", `${path} · ${total} ${total === 1 ? "line" : "lines"}`, state),
+      callRow(theme, name, `${path} · ${total} ${total === 1 ? "line" : "lines"}`, state),
     ];
 
     for (let index = 0; index < shown.length; index++) {
       const isLast = index === shown.length - 1 && remaining === 0;
       rows.push({
         prefix: theme.fg("dim", isLast ? "   └ " : "   │ "),
-        continuation: theme.fg("dim", "   │ "),
+        continuation: isLast ? "     " : theme.fg("dim", "   │ "),
         content: theme.fg("toolOutput", shown[index] || " "),
       });
     }
@@ -978,19 +2015,22 @@ export default function prettyTui(pi: ExtensionAPI) {
 
     if (expanded && output) {
       const lines = output.split("\n");
+      while (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
       const shown = lines.slice(0, 40);
-      for (const line of shown) {
+      const omitted = lines.length - shown.length;
+      for (let index = 0; index < shown.length; index++) {
+        const isLast = index === shown.length - 1 && omitted === 0;
         rows.push({
-          prefix: theme.fg("dim", "   │ "),
-          continuation: theme.fg("dim", "   │ "),
-          content: outputStyle(line || " "),
+          prefix: theme.fg("dim", isLast ? "   └ " : "   │ "),
+          continuation: isLast ? "     " : theme.fg("dim", "   │ "),
+          content: outputStyle(shown[index] || " "),
         });
       }
-      if (lines.length > shown.length) {
+      if (omitted > 0) {
         rows.push({
           prefix: theme.fg("muted", "   └ "),
           continuation: "     ",
-          content: theme.fg("muted", `… ${lines.length - shown.length} more lines`),
+          content: theme.fg("muted", `… ${omitted} more lines`),
         });
       }
     }
@@ -998,8 +2038,11 @@ export default function prettyTui(pi: ExtensionAPI) {
     return block(rows);
   };
 
-  const isError = (renderContext: any, output: string): boolean =>
-    Boolean(renderContext?.isError) || /^(error|failed|access denied)\b/i.test(output.trim());
+  // Pi's render context always carries the authoritative failure flag
+  // (tool-execution.js builds it from result.isError). A tool's own output text
+  // must never decide this: `grep -n Error`, `cat error.log`, or a test runner
+  // printing "failed 0" would otherwise mark a successful call as failed.
+  const isError = (renderContext: any): boolean => Boolean(renderContext?.isError);
 
   const partialResult = (context: any, theme: any, label: string): Component => {
     setStatus(context, "running");
@@ -1064,7 +2107,7 @@ export default function prettyTui(pi: ExtensionAPI) {
       const isLast = index === shown.length - 1;
       rows.push({
         prefix: theme.fg("dim", isLast ? "   └ " : "   │ "),
-        continuation: theme.fg("dim", "   │ "),
+        continuation: isLast ? "     " : theme.fg("dim", "   │ "),
         content: theme.fg("toolOutput", shown[index] || " "),
       });
     }
@@ -1072,8 +2115,8 @@ export default function prettyTui(pi: ExtensionAPI) {
     return block(rows);
   };
 
-  const completeStatus = (context: any, output: string): boolean => {
-    const failed = isError(context, output);
+  const completeStatus = (context: any): boolean => {
+    const failed = isError(context);
     setStatus(context, failed ? "error" : "success");
     return failed;
   };
@@ -1081,6 +2124,7 @@ export default function prettyTui(pi: ExtensionAPI) {
   type ToolSummaryGroup = {
     count: number;
     failed: number;
+    thoughtCount?: number;
     lastToolCallId: string;
     toolCallIds?: string[];
     activity?: string;
@@ -1088,12 +2132,12 @@ export default function prettyTui(pi: ExtensionAPI) {
   type ToolSummaryData = {
     count?: number;
     failed?: number;
+    thoughtCount?: number;
     /** Identifies the last tool component for older single-group entries. */
     lastToolCallId?: string;
     /** All groups from a run, used to restore summaries after reload. */
     groups?: ToolSummaryGroup[];
   };
-  const supportedTools = new Set(["read", "bash", "edit", "write", "grep", "find", "ls"]);
   type ToolActivityHold = {
     toolCallId: string;
     name: string;
@@ -1102,7 +2146,12 @@ export default function prettyTui(pi: ExtensionAPI) {
     started: boolean;
     timer?: ReturnType<typeof setTimeout>;
   };
-  const settledSummaries = new Map<string, { count: number; failed: number; activity: DisplayValue }>();
+  const settledSummaries = new Map<string, {
+    count: number;
+    failed: number;
+    thoughtCount: number;
+    activity: DisplayValue;
+  }>();
   const toolActivityHolds = new Map<string, ToolActivityHold>();
   const legacySummaryLastToolCallIds = new Map<string, string>();
   const knownToolCallIds = new Set<string>();
@@ -1130,8 +2179,64 @@ export default function prettyTui(pi: ExtensionAPI) {
     settled: false,
   };
 
-  const toolDisplayName = (name: string): string =>
-    name === "ls" ? "List" : name.charAt(0).toUpperCase() + name.slice(1);
+  const toolLabel = (toolName: string, label?: string): string => label || toolName;
+
+  const conciseThirdPartyArgs = (args: any): string => {
+    if (!args || typeof args !== "object" || Array.isArray(args)) return "";
+    const sensitive = /(?:token|secret|password|authorization|credential|api[_-]?key)/iu;
+    const preferred = ["path", "query", "url", "offset", "id"];
+    const entries = Object.entries(args)
+      .filter(([key, value]) => !sensitive.test(key) && ["string", "number", "boolean"].includes(typeof value))
+      .sort(([left], [right]) => {
+        const leftRank = preferred.indexOf(left);
+        const rightRank = preferred.indexOf(right);
+        return (leftRank < 0 ? preferred.length : leftRank) -
+          (rightRank < 0 ? preferred.length : rightRank);
+      })
+      .slice(0, 2)
+      .map(([key, value]) => {
+        const safeValue = String(value)
+          .replace(/(https?:\/\/)[^\s/@:]+:[^\s/@]+@/giu, "$1…:…@")
+          .replace(/([?&](?:token|secret|password|api[_-]?key)=)[^&\s]+/giu, "$1…");
+        const rendered = truncateToWidth(safeValue, 36, "…");
+        return `${key}=${rendered}`;
+      });
+    return entries.join(" · ");
+  };
+
+  const thirdPartyResultSummary = (component: any): string => {
+    const detailsError = component.result?.details?.error;
+    const firstText = component.result?.content?.find(
+      (item: any) => item?.type === "text" && typeof item.text === "string" && item.text.length > 0,
+    )?.text;
+    const text = String(typeof detailsError === "string" ? detailsError : firstText ?? "");
+    const boundedText = text.slice(0, 512);
+    const newline = boundedText.indexOf("\n");
+    const boundedFirstLine = boundedText.slice(0, newline < 0 ? boundedText.length : newline);
+    const firstLine = stripTerminalSequences(boundedFirstLine).trim();
+    if (firstLine) return truncateToWidth(firstLine, 72, "…");
+    if (component.result) return component.result.isError ? "Failed" : "Done";
+    return component.executionStarted ? "Running…" : "Pending";
+  };
+
+  const renderThirdPartyCompact = (component: any, width: number, theme: any): string[] => {
+    const label = toolLabel(component.toolName, component.toolDefinition?.label);
+    const args = conciseThirdPartyArgs(component.args);
+    const dotColor = component.result?.isError
+      ? "error"
+      : component.result && !component.isPartial
+        ? successMarkerColor(theme)
+        : "accent";
+    const title = theme.fg(dotColor, "● ") +
+      theme.fg("accent", theme.bold(label)) +
+      (args ? theme.fg("muted", `(${args})`) : "");
+    const result = thirdPartyResultSummary(component);
+    const resultColor = component.result?.isError ? "error" : "muted";
+    return [
+      truncateToWidth(title, Math.max(1, width), "…"),
+      theme.fg(resultColor, truncateToWidth(`  └ ${result}`, Math.max(1, width), "…")),
+    ];
+  };
 
   const clearToolActivityHolds = () => {
     for (const hold of toolActivityHolds.values()) {
@@ -1178,7 +2283,7 @@ export default function prettyTui(pi: ExtensionAPI) {
       toolCallId,
       name,
       until: startedAt + CLEAN_TOOL_ACTIVITY_MIN_MS,
-      after: "thinking...",
+      after: "thinking",
       started,
     });
     cleanRun.activeToolName = name;
@@ -1193,14 +2298,14 @@ export default function prettyTui(pi: ExtensionAPI) {
         toolCallId,
         name,
         until: now + CLEAN_TOOL_ACTIVITY_MIN_MS,
-        after: "thinking...",
+        after: "thinking",
         started: true,
       };
       toolActivityHolds.set(toolCallId, hold);
     }
     hold.name = name;
     hold.started = true;
-    hold.after = "thinking...";
+    hold.after = "thinking";
     scheduleToolActivityRelease(hold);
   };
 
@@ -1214,15 +2319,18 @@ export default function prettyTui(pi: ExtensionAPI) {
   const liveCleanToolCount = (): number =>
     Math.max(cleanRun.count, cleanRun.currentToolCallIds.length);
 
+  const thoughtCountForTool = (toolCallId: string | undefined): number =>
+    toolCallId ? activityTimeline.groupForTool(toolCallId)?.thoughtCount ?? 0 : 0;
+
   const currentCleanActivity = (): string => {
     if (cleanRun.activeToolCallId) {
-      return cleanRun.activeToolName ?? cleanRun.activity ?? "thinking...";
+      return cleanRun.activeToolName ?? cleanRun.activity ?? "thinking";
     }
     if (cleanRun.lastCompletedToolCallId) {
       const hold = toolActivityHolds.get(cleanRun.lastCompletedToolCallId);
       if (hold) return heldActivity(hold);
     }
-    return cleanRun.activeToolName ?? cleanRun.activity ?? (cleanRun.active ? "thinking..." : "done");
+    return cleanRun.activeToolName ?? cleanRun.activity ?? (cleanRun.active ? "thinking" : "done");
   };
 
   pi.on("session_shutdown", clearToolActivityHolds);
@@ -1238,116 +2346,198 @@ export default function prettyTui(pi: ExtensionAPI) {
     const originalToolRender = toolExecutionPrototype.render;
     const originalToolHandleMouse = toolExecutionPrototype.handleMouse;
     const renderedModeKey = Symbol("pretty-tui.tool-rendered-mode");
-    const revealCleanGroup = (groupToolCallIds: string[], ui?: any) => {
-      for (const toolCallId of groupToolCallIds) cleanCompactToolCallIds.add(toolCallId);
-      for (const toolCallId of groupToolCallIds) cleanToolComponents.get(toolCallId)?.updateDisplay();
+    const cleanChildRenderCacheKey = Symbol("pretty-tui.clean-child-render-cache");
+    const refreshActivityGroup = (group: ActivityGroup) => {
+      for (const member of group.members) {
+        if (member.kind === "tool" && member.toolCallId) {
+          cleanToolComponents.get(member.toolCallId)?.updateDisplay();
+        } else if (member.kind === "thinking" && member.messageKey) {
+          thinkingComponents.get(member.messageKey)?.invalidate?.();
+        }
+      }
+    };
+    const revealCleanGroup = (group: ActivityGroup, ui?: any) => {
+      revealedActivityGroups.add(group.id);
+      for (const toolCallId of group.toolCallIds) cleanCompactToolCallIds.add(toolCallId);
+      refreshActivityGroup(group);
+      ui?.requestRender?.();
+    };
+    const collapseCleanGroup = (group: ActivityGroup, ui?: any) => {
+      revealedActivityGroups.delete(group.id);
+      for (const toolCallId of group.toolCallIds) {
+        const component = cleanToolComponents.get(toolCallId);
+        if (component?.expanded) originalSetExpanded.call(component, false);
+        cleanCompactToolCallIds.delete(toolCallId);
+      }
+      for (const member of group.members) expandedThinkingMembers.delete(member.id);
+      refreshActivityGroup(group);
       ui?.requestRender?.();
     };
     const patchedMarkExecutionStarted = function (this: any) {
-      if (supportedTools.has(this.toolName)) {
-        if (!cleanRun.currentToolCallIds.includes(this.toolCallId)) {
-          cleanRun.currentToolCallIds.push(this.toolCallId);
-        }
-        cleanRun.activeToolCallIds.add(this.toolCallId);
-        cleanToolNames.set(this.toolCallId, toolDisplayName(this.toolName));
-        setCleanGroupMembers(this.toolCallId, cleanRun.currentToolCallIds.slice());
-        if (typeof this.ui?.requestRender === "function") {
-          cleanRun.requestRender = () => this.ui.requestRender();
-        }
-        cleanRun.active = true;
-        cleanRun.activeToolCallId = this.toolCallId;
-        beginToolActivity(this.toolCallId, toolDisplayName(this.toolName), true);
-      }
+      activityTimeline.addTool(this.toolCallId, this.toolName);
+      if (!cleanRun.currentToolCallIds.includes(this.toolCallId)) {
+        cleanRun.currentToolCallIds.push(this.toolCallId);
+      }
+      cleanRun.activeToolCallIds.add(this.toolCallId);
+      const displayName = toolLabel(this.toolName, this.toolDefinition?.label);
+      cleanToolNames.set(this.toolCallId, displayName);
+      setCleanGroupMembers(this.toolCallId, cleanRun.currentToolCallIds.slice());
+      if (typeof this.ui?.requestRender === "function") {
+        cleanRun.requestRender = () => this.ui.requestRender();
+      }
+      cleanRun.active = true;
+      cleanRun.activeToolCallId = this.toolCallId;
+      beginToolActivity(this.toolCallId, displayName, true);
       return originalMarkExecutionStarted.call(this);
     };
     const patchedSetExpanded = function (this: any, expanded: boolean) {
-      const groupToolCallIds = cleanGroupToolCallIds.get(this.toolCallId);
+      const group = activityTimeline.groupForTool(this.toolCallId);
       if (
         renderMode === "clean" &&
         !changingAllToolsExpansion &&
         expanded &&
         !this.expanded &&
-        !isCleanGroupRevealed(this.toolCallId) &&
-        groupToolCallIds?.length
+        group &&
+        !activityGroupRevealed(group)
       ) {
-        revealCleanGroup(groupToolCallIds, this.ui);
+        revealCleanGroup(group, this.ui);
         return;
       }
       return originalSetExpanded.call(this, expanded);
     };
     const patchedToolRender = function (this: any, width: number): string[] {
-      if (supportedTools.has(this.toolName)) {
-        cleanToolComponents.set(this.toolCallId, this);
-        knownToolCallIds.add(this.toolCallId);
-      }
+      cleanToolComponents.set(this.toolCallId, this);
+      knownToolCallIds.add(this.toolCallId);
+      const member = activityTimeline.addTool(this.toolCallId, this.toolName);
+      cleanToolNames.set(
+        this.toolCallId,
+        toolLabel(this.toolName, this.toolDefinition?.label),
+      );
       if (this[renderedModeKey] !== renderMode) {
         this[renderedModeKey] = renderMode;
         this.updateDisplay();
       }
 
-      const groupOwner = cleanToolCallGroupOwners.get(this.toolCallId);
-      const groupToolCallIds = groupOwner ? cleanGroupToolCallIds.get(groupOwner) : undefined;
-      const childIndex = groupToolCallIds?.indexOf(this.toolCallId) ?? -1;
-      const showAsChild = renderMode === "clean" && childIndex >= 0 && isCleanGroupRevealed(this.toolCallId);
-      if (!showAsChild || !groupOwner || !groupToolCallIds) {
-        return originalToolRender.call(this, width);
+      const group = activityTimeline.groupForMember(member.id);
+      if (renderMode !== "clean" || !group) return originalToolRender.call(this, width);
+      const position = activityMemberPosition(group, member);
+      if (!activityGroupRevealed(group)) {
+        return position.first
+          ? ["", ...renderActivityGroupSummary(group, width, true)]
+          : [];
+      }
+
+      const childTheme = cleanThemeForToolCall(this.toolCallId) ?? activityGroupTheme(group);
+      const {
+        prefix: childPrefix,
+        continuation,
+        childWidth,
+      } = activityTreeStyle(group, member, width, childTheme);
+      const thirdParty = !SPECIALIZED_TOOL_NAMES.has(this.toolName);
+      const cacheable = !this.expanded && Boolean(this.result) && !this.isPartial;
+      const cached = cacheable ? this[cleanChildRenderCacheKey] : undefined;
+      let decoratedContent: string[];
+      if (
+        cached?.width === width &&
+        cached?.childWidth === childWidth &&
+        cached?.result === this.result &&
+        cached?.args === this.args &&
+        cached?.callRenderer === this.callRendererComponent &&
+        cached?.resultRenderer === this.resultRendererComponent &&
+        cached?.theme === childTheme &&
+        cached?.last === position.last &&
+        cached?.memberCount === group.members.length
+      ) {
+        decoratedContent = cached.lines;
+      } else {
+        let contentLines: string[];
+        if (thirdParty) {
+          const summaryLines = renderThirdPartyCompact(this, childWidth, childTheme);
+          if (this.expanded) {
+            const detailPrefix = "  │ ";
+            const nativeLines = originalToolRender.call(
+              this,
+              Math.max(1, childWidth - visibleWidth(detailPrefix)),
+            );
+            const nativeContentLines = nativeLines[0] === "" ? nativeLines.slice(1) : nativeLines;
+            contentLines = [
+              summaryLines[0],
+              ...nativeContentLines.map((line: string, index: number) =>
+                childTheme.fg(
+                  "dim",
+                  index === nativeContentLines.length - 1 ? "  └ " : detailPrefix,
+                ) + stripAnsiBackgrounds(line)
+              ),
+            ];
+          } else {
+            contentLines = summaryLines;
+          }
+        } else {
+          const lines = originalToolRender.call(this, childWidth);
+          if (lines.length === 0) return lines;
+          contentLines = lines[0] === "" ? lines.slice(1) : lines;
+        }
+        decoratedContent = contentLines.map((line: string, index: number) =>
+          truncateToWidth(
+            (index === 0 ? childPrefix : continuation) + line,
+            Math.max(1, width),
+            "",
+          )
+        );
+        if (cacheable) {
+          this[cleanChildRenderCacheKey] = {
+            width,
+            childWidth,
+            result: this.result,
+            args: this.args,
+            callRenderer: this.callRendererComponent,
+            resultRenderer: this.resultRendererComponent,
+            theme: childTheme,
+            last: position.last,
+            memberCount: group.members.length,
+            lines: decoratedContent,
+          };
+        }
       }
-
-      const rawChildPrefix = childIndex === groupToolCallIds.length - 1 ? "  └─ " : "  ├─ ";
-      const rawContinuation = childIndex === groupToolCallIds.length - 1 ? "     " : "  │  ";
-      const childTheme = cleanThemeForToolCall(this.toolCallId);
-      const childPrefix = childTheme ? childTheme.fg("dim", rawChildPrefix) : rawChildPrefix;
-      const continuation = childTheme ? childTheme.fg("dim", rawContinuation) : rawContinuation;
-      const childWidth = Math.max(1, width - visibleWidth(rawChildPrefix));
-      const lines = originalToolRender.call(this, childWidth);
-      if (lines.length === 0) return lines;
-
-      const decoratedContent = lines.slice(1).map((line: string, index: number) =>
-        (index === 0 ? childPrefix : continuation) + line
-      );
-      if (childIndex !== 0) return decoratedContent;
-      return [lines[0], ...renderCleanGroupSummary(groupOwner, width), ...decoratedContent];
+      if (!position.first) return decoratedContent;
+      return ["", ...renderActivityGroupSummary(group, width), ...decoratedContent];
     };
     const patchedToolHandleMouse = function (this: any, event: any) {
-      const groupOwner = cleanToolCallGroupOwners.get(this.toolCallId);
-      const groupToolCallIds = groupOwner ? cleanGroupToolCallIds.get(groupOwner) : undefined;
-      const childIndex = groupToolCallIds?.indexOf(this.toolCallId) ?? -1;
-      const showAsChild = renderMode === "clean" && childIndex >= 0 && isCleanGroupRevealed(this.toolCallId);
+      const member = activityTimeline.memberForTool(this.toolCallId);
+      const group = member ? activityTimeline.groupForMember(member.id) : undefined;
       const isLeftClick = event.type === "click" && event.button === "left";
+      if (renderMode !== "clean" || !member || !group) {
+        return originalToolHandleMouse.call(this, event);
+      }
+      const position = activityMemberPosition(group, member);
+      const revealed = activityGroupRevealed(group);
 
-      // Pi normally ignores tool clicks until a result exists. Clean mode can
-      // still reveal the active call safely because this changes presentation
-      // only; it does not affect or delay execution.
-      if (
-        renderMode === "clean" &&
-        !showAsChild &&
-        isLeftClick &&
-        this.toolCallId === groupOwner &&
-        groupToolCallIds?.length
-      ) {
-        revealCleanGroup(groupToolCallIds, this.ui);
+      if (!revealed && position.first && isLeftClick) {
+        revealCleanGroup(group, this.ui);
         return { handled: true };
       }
-      if (!showAsChild || !groupToolCallIds) return originalToolHandleMouse.call(this, event);
+      if (!revealed) return isLeftClick ? { handled: true } : undefined;
 
-      const summaryHeight = childIndex === 0 ? renderCleanGroupSummary(groupOwner!, event.width).length : 0;
-      if (
-        childIndex === 0 &&
-        event.y > 0 &&
-        event.y <= summaryHeight &&
-        isLeftClick
-      ) {
+      const summaryHeight = position.first ? renderActivityGroupSummary(group, event.width).length : 0;
+      if (position.first && event.y > 0 && event.y <= summaryHeight && isLeftClick) {
         changingAllToolsExpansion = true;
         try {
-          for (const toolCallId of groupToolCallIds) {
-            const component = cleanToolComponents.get(toolCallId);
-            if (component?.expanded) originalSetExpanded.call(component, false);
-            cleanCompactToolCallIds.delete(toolCallId);
-          }
-          for (const toolCallId of groupToolCallIds) cleanToolComponents.get(toolCallId)?.updateDisplay();
+          collapseCleanGroup(group, this.ui);
         } finally {
           changingAllToolsExpansion = false;
         }
+        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;
+      if (
+        !SPECIALIZED_TOOL_NAMES.has(this.toolName) &&
+        isLeftClick &&
+        event.y === thirdPartyHeaderY
+      ) {
+        originalSetExpanded.call(this, !this.expanded);
         this.ui?.requestRender?.();
         return { handled: true };
       }
@@ -1358,12 +2548,17 @@ export default function prettyTui(pi: ExtensionAPI) {
         return { handled: true };
       }
 
-      const childPrefixWidth = visibleWidth("  ├─ ");
+      const { prefixWidth } = activityTreeStyle(
+        group,
+        member,
+        event.width,
+        cleanThemeForToolCall(this.toolCallId),
+      );
       return originalToolHandleMouse.call(this, {
         ...event,
-        x: Math.max(0, event.x - childPrefixWidth),
-        y: event.y - summaryHeight + (childIndex === 0 ? 0 : 1),
-        width: Math.max(1, event.width - childPrefixWidth),
+        x: Math.max(0, event.x - prefixWidth),
+        y: event.y - summaryHeight + (position.first ? 0 : 1),
+        width: Math.max(1, event.width - prefixWidth),
       });
     };
 
@@ -1413,6 +2608,7 @@ export default function prettyTui(pi: ExtensionAPI) {
       const group: ToolSummaryGroup = {
         count: cleanRun.count,
         failed: cleanRun.failed,
+        thoughtCount: thoughtCountForTool(cleanRun.lastCompletedToolCallId),
         lastToolCallId: cleanRun.lastCompletedToolCallId,
         toolCallIds: cleanRun.currentToolCallIds.slice(),
         activity,
@@ -1421,6 +2617,7 @@ export default function prettyTui(pi: ExtensionAPI) {
       settledSummaries.set(group.lastToolCallId, {
         count: group.count,
         failed: group.failed,
+        thoughtCount: group.thoughtCount ?? 0,
         activity: activityValueForHold(group.lastToolCallId, activity),
       });
       setCleanGroupMembers(group.lastToolCallId, group.toolCallIds ?? []);
@@ -1432,6 +2629,16 @@ export default function prettyTui(pi: ExtensionAPI) {
     cleanRun.lastCompletedToolCallId = undefined;
     cleanRun.activeToolCallId = undefined;
     cleanRun.activeToolName = undefined;
+    activityTimeline.boundary();
+  };
+
+  closeCleanAtNativeCustomBoundary = () => {
+    finishCleanGroup("done");
+    settleLastCleanGroup();
+  };
+  closeCleanAtStandaloneAlert = () => {
+    finishCleanGroup("done");
+    settleLastCleanGroup();
   };
 
   const settleLastCleanGroup = () => {
@@ -1441,30 +2648,46 @@ export default function prettyTui(pi: ExtensionAPI) {
     settledSummaries.set(group.lastToolCallId, {
       count: group.count,
       failed: group.failed,
+      thoughtCount: group.thoughtCount ?? 0,
       activity: activityValueForHold(group.lastToolCallId, "done"),
     });
   };
 
-  const summaryText = (count: number, _failed: number, activity = "done"): string => {
-    const activityText = typeof activity === "string" ? activity : "done";
-    const countLabel = `${count} tool ${count === 1 ? "call" : "calls"}`;
-    const activityLabel = activityText !== "done" && activityText.trim()
-      ? ` · ${activityText}`
+  const summaryText = (
+    count: number,
+    _failed: number,
+    thoughtCount: number,
+    activity = "done",
+  ): string => {
+    const rawActivityText = typeof activity === "string" ? activity : "done";
+    const normalizedActivityText = rawActivityText.trim();
+    const activityText = /^thinking(?:\.\.\.)?$/iu.test(normalizedActivityText)
+      ? "thinking"
+      : rawActivityText;
+    const countLabel = count > 0 ? `${count} tool ${count === 1 ? "call" : "calls"}` : "";
+    const thoughtLabel = thoughtCount > 0
+      ? `${thoughtCount} ${thoughtCount === 1 ? "thought" : "thoughts"}`
       : "";
-    return `${countLabel}${activityLabel}`;
+    // Without tools there is no current tool name to report, and the generic
+    // "thinking" placeholder would only repeat the thought count.
+    const activityLabel = count > 0 && activityText !== "done" && activityText.trim()
+      ? activityText
+      : "";
+    return [countLabel, thoughtLabel, activityLabel].filter(Boolean).join(" · ");
   };
 
   const summaryRow = (
     theme: any,
     count: number,
     failed: number,
+    thoughtCount: number,
     activity: DisplayValue = "done",
     collapsedDone = false,
   ): DisplayRow => ({
     prefix: () => {
       const currentActivity = typeof activity === "function" ? activity() : activity;
       const color = currentActivity === "done"
-        ? collapsedDone ? "thinkingText" : "success"
+        ? collapsedDone ? "thinkingText" : successMarkerColor(theme)
         : "accent";
       return theme.fg(color, "● ");
     },
@@ -1473,12 +2696,13 @@ export default function prettyTui(pi: ExtensionAPI) {
       const currentActivity = typeof activity === "function" ? activity() : activity;
       const label = currentActivity === "done" ? "Done" : "Running";
       const color = label === "Done"
-        ? collapsedDone ? "thinkingText" : "success"
+        ? collapsedDone ? "thinkingText" : successMarkerColor(theme)
         : "accent";
       const detailColor = label === "Done" && collapsedDone ? "thinkingText" : "text";
       return theme.fg(color, theme.bold(label)) +
         theme.fg("dim", "(") +
-        theme.fg(detailColor, summaryText(count, failed, currentActivity)) + theme.fg("dim", ")");
+        theme.fg(detailColor, summaryText(count, failed, thoughtCount, currentActivity)) +
+        theme.fg("dim", ")");
     },
   });
 
@@ -1487,22 +2711,91 @@ export default function prettyTui(pi: ExtensionAPI) {
     if (!summaryTheme) return [];
     const settled = settledSummaries.get(lastToolCallId);
     if (settled) {
-      return block([summaryRow(summaryTheme, settled.count, settled.failed, settled.activity)]).render(width);
+      return block([summaryRow(
+        summaryTheme,
+        settled.count,
+        settled.failed,
+        settled.thoughtCount,
+        settled.activity,
+      )]).render(width);
     }
     if (cleanRun.activeToolCallId === lastToolCallId) {
       return block([summaryRow(
         summaryTheme,
         liveCleanToolCount(),
         cleanRun.failed,
+        thoughtCountForTool(lastToolCallId),
         () => cleanRun.activeToolName ?? currentCleanActivity(),
       )]).render(width);
     }
     if (cleanRun.lastCompletedToolCallId === lastToolCallId && cleanRun.count > 0) {
-      return block([summaryRow(summaryTheme, cleanRun.count, cleanRun.failed, currentCleanActivity)]).render(width);
+      return block([summaryRow(
+        summaryTheme,
+        cleanRun.count,
+        cleanRun.failed,
+        thoughtCountForTool(lastToolCallId),
+        currentCleanActivity,
+      )]).render(width);
     }
     return [];
   };
 
+  const renderActivityGroupSummary = (
+    group: ActivityGroup,
+    width: number,
+    collapsedDone = false,
+  ): string[] => {
+    const fit = (lines: string[]) => lines.map((line) => truncateToWidth(line, Math.max(1, width), ""));
+    const summaryTheme = activityGroupTheme(group);
+    if (!summaryTheme || !activityTimeline.hasWork(group)) return [];
+    const owner = activityGroupOwner(group);
+    const settled = owner ? settledSummaries.get(owner) : undefined;
+    const toolCount = group.toolCallIds.length;
+    const live = () => cleanRun.activeToolName ?? currentCleanActivity();
+    if (settled) {
+      return fit(block([summaryRow(
+        summaryTheme,
+        group.hardBoundarySplit ? toolCount : Math.max(settled.count, toolCount),
+        group.hardBoundarySplit ? 0 : settled.failed,
+        Math.max(settled.thoughtCount, group.thoughtCount),
+        settled.activity,
+        collapsedDone,
+      )]).render(width));
+    }
+    if (owner && !cleanRun.settled) {
+      // Live tool group: keep the current tool name and the running count.
+      return fit(block([summaryRow(
+        summaryTheme,
+        Math.max(toolCount, liveCleanToolCount()),
+        cleanRun.failed,
+        group.thoughtCount,
+        live,
+        collapsedDone,
+      )]).render(width));
+    }
+    if (!owner && !activityTimeline.isSettled(group.id)) {
+      // Thought-only group while the model is still working.
+      return fit(block([summaryRow(
+        summaryTheme,
+        toolCount,
+        cleanRun.failed,
+        group.thoughtCount,
+        "thinking",
+        collapsedDone,
+      )]).render(width));
+    }
+    // Finished group with no durable summary: a completed Thought-only turn, or
+    // a group split apart by a native custom renderer.
+    return fit(block([summaryRow(
+      summaryTheme,
+      toolCount,
+      0,
+      group.thoughtCount,
+      "done",
+      collapsedDone,
+    )]).render(width));
+  };
+
   /**
    * Clean mode keeps Running/Done rows in the existing tool components. This
    * avoids waiting for agent_end (which can be followed by retry/compaction),
@@ -1511,6 +2804,8 @@ export default function prettyTui(pi: ExtensionAPI) {
   const cleanToolCall = (theme: any, name: string, toolCallId: string): Component => {
     knownToolCallIds.add(toolCallId);
     cleanToolThemes.set(toolCallId, theme);
+    const activityGroup = activityTimeline.groupForTool(toolCallId);
+    if (activityGroup) activityFallbackThemes.set(activityGroup.id, theme);
     return {
       render(width: number): string[] {
         if (renderMode !== "clean") return [];
@@ -1521,6 +2816,7 @@ export default function prettyTui(pi: ExtensionAPI) {
             theme,
             settledSummary.count,
             settledSummary.failed,
+            settledSummary.thoughtCount,
             settledSummary.activity,
             true,
           )]).render(width);
@@ -1532,6 +2828,7 @@ export default function prettyTui(pi: ExtensionAPI) {
             theme,
             liveCleanToolCount(),
             cleanRun.failed,
+            thoughtCountForTool(toolCallId),
             () => cleanRun.activeToolName ?? name,
           )]).render(width);
         }
@@ -1543,7 +2840,13 @@ export default function prettyTui(pi: ExtensionAPI) {
           cleanRun.count > 0 &&
           !cleanRun.activeToolCallId
         ) {
-          return block([summaryRow(theme, cleanRun.count, cleanRun.failed, currentCleanActivity)]).render(width);
+          return block([summaryRow(
+            theme,
+            cleanRun.count,
+            cleanRun.failed,
+            thoughtCountForTool(toolCallId),
+            currentCleanActivity,
+          )]).render(width);
         }
 
         // Do not fall back to the per-component pending state here: Pi may
@@ -1558,12 +2861,12 @@ export default function prettyTui(pi: ExtensionAPI) {
 
   const hiddenToolResult = (context: any, options: any, output: string): Component => {
     if (options.isPartial) setStatus(context, "running");
-    else completeStatus(context, output);
+    else completeStatus(context);
     return block([]);
   };
 
-  // In collapsed clean mode, every supported tool call is represented by its
-  // Running row. Ctrl+O bypasses this and restores the normal full renderer.
+  // Built-ins use specialized compact renderers, while the activity timeline
+  // controls grouping for every tool, including third-party definitions.
   const hideCleanTool = (
     toolCallId: string,
     expanded: boolean,
@@ -1586,6 +2889,7 @@ export default function prettyTui(pi: ExtensionAPI) {
           ? [{
               count: data.count ?? 0,
               failed: data.failed ?? 0,
+              thoughtCount: data.thoughtCount ?? 0,
               lastToolCallId: data.lastToolCallId,
             }]
           : (() => {
@@ -1594,6 +2898,7 @@ export default function prettyTui(pi: ExtensionAPI) {
                 ? [{
                     count: data?.count ?? 0,
                     failed: data?.failed ?? 0,
+                    thoughtCount: data?.thoughtCount ?? 0,
                     lastToolCallId: summaryCallId,
                   }]
                 : [];
@@ -1603,11 +2908,10 @@ export default function prettyTui(pi: ExtensionAPI) {
       // absent from an uncompacted branch.
       const missingGroups = groups.filter((group) => !knownToolCallIds.has(group.lastToolCallId));
       if (missingGroups.length === 0) return [];
-      // Persisted entries represent settled groups. Older versions could
-      // accidentally store the transient responding... activity, so always
-      // normalize their display to Done.
+      // Persisted entries represent settled groups, so always normalize their
+      // display to Done even when an older entry stored a transient activity.
       return block(missingGroups.map((group) =>
-        summaryRow(theme, group.count, group.failed, "done", true)
+        summaryRow(theme, group.count, group.failed, group.thoughtCount ?? 0, "done", true)
       )).render(width);
     },
     invalidate() {},
@@ -1625,9 +2929,20 @@ export default function prettyTui(pi: ExtensionAPI) {
 
   const restoreCleanSession = (ctx: any) => {
     currentExtensionUi = ctx.ui;
+    clearLatestActivityStatus();
     cleanToolsExpanded = ctx.ui.getToolsExpanded();
     settledSummaries.clear();
     legacySummaryLastToolCallIds.clear();
+    activityTimeline.clear();
+    nativeCustomBoundaryKeys.clear();
+    revealedActivityGroups.clear();
+    expandedThinkingMembers.clear();
+    thinkingComponents.clear();
+    activityFallbackThemes.clear();
+    activityUpdateComponents.clear();
+    activityUpdateMarkdownComponents.clear();
+    activityUpdateSequence = 0;
+    assistantBoundaryKeys.clear();
     knownToolCallIds.clear();
     cleanCompactToolCallIds.clear();
     cleanGroupToolCallIds.clear();
@@ -1659,9 +2974,15 @@ export default function prettyTui(pi: ExtensionAPI) {
     const explicitSummaryIds = new Set<string>();
 
     const rememberGroup = (group: ToolSummaryGroup, entryId?: string) => {
+      const thoughtCount = Math.max(
+        group.thoughtCount ?? 0,
+        thoughtCountForTool(group.lastToolCallId),
+      );
+      group.thoughtCount = thoughtCount;
       settledSummaries.set(group.lastToolCallId, {
         count: group.count,
         failed: group.failed,
+        thoughtCount,
         activity: "done",
       });
       if (group.toolCallIds?.length) {
@@ -1673,11 +2994,22 @@ export default function prettyTui(pi: ExtensionAPI) {
 
     const finishGroup = () => {
       if (lastToolCallId && count > 0) {
-        lastFinishedGroup = { count, failed, lastToolCallId, toolCallIds: [...toolCalls] };
+        lastFinishedGroup = {
+          count,
+          failed,
+          thoughtCount: thoughtCountForTool(lastToolCallId),
+          lastToolCallId,
+          toolCallIds: [...toolCalls],
+        };
         inferredGroups.push(lastFinishedGroup);
         setCleanGroupMembers(lastToolCallId, [...toolCalls]);
         if (!explicitSummaryIds.has(lastToolCallId)) {
-          settledSummaries.set(lastToolCallId, { count, failed, activity: "done" });
+          settledSummaries.set(lastToolCallId, {
+            count,
+            failed,
+            thoughtCount: lastFinishedGroup.thoughtCount ?? 0,
+            activity: "done",
+          });
         }
       }
       count = 0;
@@ -1685,13 +3017,20 @@ export default function prettyTui(pi: ExtensionAPI) {
       lastToolCallId = undefined;
       toolCalls.clear();
       completedToolCalls.clear();
+      activityTimeline.boundary();
     };
 
     const inferredGroupsOverlapping = (group: ToolSummaryGroup): ToolSummaryGroup[] => {
       if (!group.toolCallIds?.length) return [];
       const persistedIds = new Set(group.toolCallIds);
       const currentGroup = lastToolCallId && count > 0
-        ? [{ count, failed, lastToolCallId, toolCallIds: [...toolCalls] }]
+        ? [{
+            count,
+            failed,
+            thoughtCount: thoughtCountForTool(lastToolCallId),
+            lastToolCallId,
+            toolCallIds: [...toolCalls],
+          }]
         : [];
       return [...inferredGroups, ...currentGroup].filter((inferred) =>
         inferred.toolCallIds?.some((toolCallId) => persistedIds.has(toolCallId)),
@@ -1770,6 +3109,7 @@ export default function prettyTui(pi: ExtensionAPI) {
           const group = {
             count: data.count ?? 0,
             failed: data.failed ?? 0,
+            thoughtCount: data.thoughtCount ?? 0,
             lastToolCallId: data.lastToolCallId,
           };
           rememberGroup(group);
@@ -1781,6 +3121,7 @@ export default function prettyTui(pi: ExtensionAPI) {
           rememberGroup({
             count: data?.count ?? lastFinishedGroup.count,
             failed: data?.failed ?? lastFinishedGroup.failed,
+            thoughtCount: data?.thoughtCount ?? lastFinishedGroup.thoughtCount ?? 0,
             lastToolCallId: lastFinishedGroup.lastToolCallId,
           }, entry.id);
         } else if (lastToolCallId && count > 0) {
@@ -1788,9 +3129,16 @@ export default function prettyTui(pi: ExtensionAPI) {
           rememberGroup({
             count: data?.count ?? count,
             failed: data?.failed ?? failed,
+            thoughtCount: data?.thoughtCount ?? thoughtCountForTool(lastToolCallId),
             lastToolCallId,
           }, entry.id);
         }
+        activityTimeline.boundary();
+        continue;
+      }
+
+      if (entry.type === "custom_message") {
+        if (entry.display !== false) addPersistentActivityUpdate(entry);
         continue;
       }
 
@@ -1803,12 +3151,23 @@ export default function prettyTui(pi: ExtensionAPI) {
         continue;
       }
 
+      if (message.role === "custom") {
+        if (message.display !== false) addPersistentActivityUpdate(message);
+        continue;
+      }
+
       if (message.role === "assistant") {
+        const thinking = thinkingText(message);
+        if (thinking) {
+          activityTimeline.addThinking(assistantMessageKey(message), thinking);
+        }
         if (messageHasVisibleText(message)) finishGroup();
         for (const item of messageContentItems(message)) {
-          if (item.type !== "toolCall" || !supportedTools.has(item.name)) continue;
+          if (item.type !== "toolCall" || !item.id) continue;
           toolCalls.add(item.id);
+          activityTimeline.addTool(item.id, item.name ?? "tool");
         }
+        if (assistantTerminalState(message)) finishGroup();
         continue;
       }
 
@@ -1829,6 +3188,17 @@ export default function prettyTui(pi: ExtensionAPI) {
 
   pi.on("session_start", (_event, ctx) => restoreCleanSession(ctx));
   pi.on("session_tree", (_event, ctx) => restoreCleanSession(ctx));
+  pi.on("session_before_compact", () => {
+    // Pi emits this for manual, threshold, and overflow-recovery compaction.
+    // Seal the activity group before the compaction indicator is rendered so
+    // completed work never remains labelled Running(... · thinking). A
+    // lifecycle boundary overrides the minimum per-tool activity hold.
+    clearToolActivityHolds();
+    finishCleanGroup("done");
+    settleLastCleanGroup();
+    cleanRun.activity = "done";
+    cleanRun.requestRender?.();
+  });
   pi.on("session_compact", () => {
     // Compaction is a hard chronological boundary. Keep tools completed before
     // it in their own group so expanded hierarchy lines never cross the summary.
@@ -1837,31 +3207,63 @@ export default function prettyTui(pi: ExtensionAPI) {
     // Pre-compaction tools have been summarized intentionally. Their durable
     // fallback rows should not be replayed beside the compacted transcript.
     cleanContextCompacted = true;
+    cleanRun.requestRender?.();
+  });
+  pi.on("session_compact_failed", () => {
+    // The pre-compaction work is still complete even when compaction is
+    // cancelled or fails. Keep it settled and let a retry start a new group.
+    settleLastCleanGroup();
+    cleanRun.activity = "done";
+    cleanRun.requestRender?.();
   });
 
   const hasVisibleAssistantText = (message: any): boolean =>
     message?.role === "assistant" && messageHasVisibleText(message);
 
+  const closeAtAssistantBoundary = (message: any, activity: string): boolean => {
+    const key = assistantMessageKey(message);
+    if (assistantBoundaryKeys.has(key)) return false;
+    assistantBoundaryKeys.add(key);
+    cleanRun.activity = activity;
+    finishCleanGroup(activity);
+    return true;
+  };
+
   const pendingToolCalls = (message: any): any[] =>
     messageContentItems(message).filter(
-      (item: any) => item.type === "toolCall" && supportedTools.has(item.name) && item.id,
+      (item: any) => item.type === "toolCall" && item.id,
     );
 
+  const conciseActivityText = (value: string): string =>
+    value
+      .split("\n")
+      .map((line) => line.trim())
+      .find(Boolean)
+      ?.replace(/^#{1,6}\s+/u, "")
+      .replace(/^\*\*(.*?)\*\*$/u, "$1") ?? "";
+
+  const trackThinkingActivity = (message: any): void => {
+    if (message?.role !== "assistant") return;
+    const thinking = thinkingText(message);
+    if (thinking) activityTimeline.addThinking(assistantMessageKey(message), thinking);
+  };
+
   const trackPendingToolActivity = (message: any): boolean => {
     const toolCalls = pendingToolCalls(message);
     if (toolCalls.length === 0) return false;
     for (const toolCall of toolCalls) {
+      activityTimeline.addTool(toolCall.id, toolCall.name ?? "tool");
       if (!cleanRun.currentToolCallIds.includes(toolCall.id)) {
         cleanRun.currentToolCallIds.push(toolCall.id);
       }
-      cleanToolNames.set(toolCall.id, toolDisplayName(toolCall.name));
+      cleanToolNames.set(toolCall.id, cleanToolNames.get(toolCall.id) ?? toolCall.name);
     }
     const toolCall = toolCalls[toolCalls.length - 1];
     if (cleanRun.lastCompletedToolCallId === toolCall.id) return false;
     setCleanGroupMembers(toolCall.id, cleanRun.currentToolCallIds.slice());
     cleanRun.active = true;
     cleanRun.activeToolCallId = toolCall.id;
-    beginToolActivity(toolCall.id, toolDisplayName(toolCall.name));
+    beginToolActivity(toolCall.id, cleanToolNames.get(toolCall.id) ?? toolCall.name);
     return true;
   };
 
@@ -1881,30 +3283,44 @@ export default function prettyTui(pi: ExtensionAPI) {
   // message_start runs before Pi adds the user component to the transcript,
   // so settling here keeps the previous parent row above that message.
   pi.on("message_start", (event) => {
+    if (event.message.role === "custom" && event.message.display !== false) {
+      addPersistentActivityUpdate(event.message);
+      return;
+    }
     if (event.message.role !== "user") return;
     finishCleanGroup("done");
     settleLastCleanGroup();
   });
 
-  // A visible assistant response is the boundary between tool groups. Do
-  // this during streaming so a following tool call cannot inherit the prior
-  // summary, while message_end keeps the rule correct for non-streaming paths.
+  // A visible assistant response is the boundary between tool groups. Seal
+  // the prior group directly as Done; the response text already communicates
+  // current activity and does not need a duplicate response status.
   pi.on("message_update", (event) => {
     if (hasVisibleAssistantText(event.message)) {
-      cleanRun.activity = "responding...";
-      finishCleanGroup("responding...");
+      trackThinkingActivity(event.message);
+      clearToolActivityHolds();
+      closeAtAssistantBoundary(event.message, "done");
       return;
     }
+    trackThinkingActivity(event.message);
     trackPendingToolActivity(event.message);
   });
   pi.on("message_end", (event) => {
     if (hasVisibleAssistantText(event.message)) {
+      trackThinkingActivity(event.message);
+      closeAtAssistantBoundary(event.message, "done");
       cleanRun.activity = "done";
-      finishCleanGroup("done");
       settleLastCleanGroup();
       return;
     }
+    trackThinkingActivity(event.message);
     trackPendingToolActivity(event.message);
+    if (assistantTerminalState(event.message)) {
+      clearToolActivityHolds();
+      finishCleanGroup("done");
+      settleLastCleanGroup();
+      cleanRun.activity = "done";
+    }
   });
 
   pi.on("agent_start", () => {
@@ -1924,25 +3340,25 @@ export default function prettyTui(pi: ExtensionAPI) {
     cleanRun.activeToolCallIds.clear();
     cleanRun.activeToolCallId = undefined;
     cleanRun.activeToolName = undefined;
-    cleanRun.activity = "thinking...";
+    cleanRun.activity = "thinking";
   });
   pi.on("tool_execution_start", (event) => {
-    if (!supportedTools.has(event.toolName)) return;
+    activityTimeline.addTool(event.toolCallId, event.toolName);
     if (!cleanRun.currentToolCallIds.includes(event.toolCallId)) {
       cleanRun.currentToolCallIds.push(event.toolCallId);
     }
     cleanRun.activeToolCallIds.add(event.toolCallId);
-    cleanToolNames.set(event.toolCallId, toolDisplayName(event.toolName));
+    const displayName = cleanToolNames.get(event.toolCallId) ?? event.toolName;
+    cleanToolNames.set(event.toolCallId, displayName);
     setCleanGroupMembers(event.toolCallId, cleanRun.currentToolCallIds.slice());
     cleanRun.active = true;
     cleanRun.activeToolCallId = event.toolCallId;
-    beginToolActivity(event.toolCallId, toolDisplayName(event.toolName), true);
+    beginToolActivity(event.toolCallId, displayName, true);
   });
   pi.on("tool_execution_end", (event) => {
-    if (!supportedTools.has(event.toolName)) return;
     const activityName = cleanRun.activeToolCallId === event.toolCallId
-      ? cleanRun.activeToolName ?? toolDisplayName(event.toolName)
-      : toolDisplayName(event.toolName);
+      ? cleanRun.activeToolName ?? cleanToolNames.get(event.toolCallId) ?? event.toolName
+      : cleanToolNames.get(event.toolCallId) ?? event.toolName;
     // Keep the tool activity visible until at least one second after start;
     // this only delays the status transition, never the tool result itself.
     holdToolActivity(event.toolCallId, activityName);
@@ -1957,10 +3373,12 @@ export default function prettyTui(pi: ExtensionAPI) {
       cleanRun.activeToolName = cleanRun.activeToolCallId
         ? cleanToolNames.get(cleanRun.activeToolCallId)
         : undefined;
-      cleanRun.activity = cleanRun.activeToolName ?? "thinking...";
+      cleanRun.activity = cleanRun.activeToolName ?? "thinking";
     }
     const visibleSummaryToolCallId = cleanRun.activeToolCallId ?? cleanRun.lastCompletedToolCallId;
     setCleanGroupMembers(visibleSummaryToolCallId, cleanRun.currentToolCallIds.slice());
+    // Tool success and failure remain owned by the activity group. The bottom
+    // line is reserved for transient UI status messages.
   });
   pi.on("agent_end", () => {
     // No summary is appended here: this event may be followed by an automatic
@@ -1969,7 +3387,7 @@ export default function prettyTui(pi: ExtensionAPI) {
     cleanRun.activeToolCallIds.clear();
     cleanRun.activeToolCallId = undefined;
     cleanRun.activeToolName = undefined;
-    cleanRun.activity = "thinking...";
+    cleanRun.activity = "thinking";
   });
   pi.on("agent_settled", () => {
     if (cleanRun.settled) return;
@@ -1982,6 +3400,7 @@ export default function prettyTui(pi: ExtensionAPI) {
       settledSummaries.set(group.lastToolCallId, {
         count: group.count,
         failed: group.failed,
+        thoughtCount: group.thoughtCount ?? 0,
         activity: activityValueForHold(group.lastToolCallId, "done"),
       });
     }
@@ -1997,14 +3416,17 @@ export default function prettyTui(pi: ExtensionAPI) {
 
     const count = groups.reduce((total, group) => total + group.count, 0);
     const failed = groups.reduce((total, group) => total + group.failed, 0);
+    const thoughtCount = groups.reduce((total, group) => total + (group.thoughtCount ?? 0), 0);
     const lastToolCallId = groups[groups.length - 1]?.lastToolCallId;
     pi.appendEntry<ToolSummaryData>("pretty-tui-tool-summary", {
       count,
       failed,
+      thoughtCount,
       lastToolCallId,
-      groups: groups.map(({ count, failed, lastToolCallId, toolCallIds }) => ({
+      groups: groups.map(({ count, failed, thoughtCount, lastToolCallId, toolCallIds }) => ({
         count,
         failed,
+        thoughtCount,
         lastToolCallId,
         toolCallIds,
       })),
@@ -2012,22 +3434,23 @@ export default function prettyTui(pi: ExtensionAPI) {
   });
 
   const read = createReadTool(cwd);
+  const readLabel = read.label || read.name;
   pi.registerTool({
     ...read,
     renderShell: "self",
     renderCall(args: any, theme: any, context: any) {
-      if (hideCleanTool(context.toolCallId, context.expanded, context.executionStarted)) return cleanToolCall(theme, "Read", context.toolCallId);
+      if (hideCleanTool(context.toolCallId, context.expanded, context.executionStarted)) return cleanToolCall(theme, readLabel, context.toolCallId);
       const range = args.offset || args.limit
         ? ` · lines ${args.offset ?? 1}${args.limit ? `–${(args.offset ?? 1) + args.limit - 1}` : "+"}`
         : "";
-      return call(theme, "Read", `${args.path}${range}`, context.state);
+      return call(theme, readLabel, `${args.path}${range}`, context.state);
     },
     renderResult(toolResult: any, options: any, theme: any, context: any) {
       const output = textContent(toolResult);
       if (hideCleanTool(context.toolCallId, options.expanded, context.executionStarted)) return hiddenToolResult(context, options, output);
       if (options.isPartial) return partialResult(context, theme, "Reading…");
       const image = toolResult.content?.find((item: any) => item.type === "image");
-      const failed = completeStatus(context, output);
+      const failed = completeStatus(context);
       if (image) return result(theme, "Read image", "", false, failed);
       const lines = nonEmptyLines(output);
       const truncated = toolResult.details?.truncation?.truncated ? " · truncated" : "";
@@ -2042,11 +3465,12 @@ export default function prettyTui(pi: ExtensionAPI) {
   } as any);
 
   const bash = createBashTool(cwd);
+  const bashLabel = bash.label || bash.name;
   pi.registerTool({
     ...bash,
     renderShell: "self",
     renderCall(args: any, theme: any, context: any) {
-      if (hideCleanTool(context.toolCallId, context.expanded, context.executionStarted)) return cleanToolCall(theme, "Bash", context.toolCallId);
+      if (hideCleanTool(context.toolCallId, context.expanded, context.executionStarted)) return cleanToolCall(theme, bashLabel, context.toolCallId);
       const command = typeof args.command === "string" ? args.command : "";
       if (useCompactToolView(context.toolCallId, context.expanded)) {
         const commandLines = command.split(/\r\n|\r|\n/);
@@ -2055,16 +3479,16 @@ export default function prettyTui(pi: ExtensionAPI) {
         const detail = omitted > 0
           ? `${firstLine} … (${omitted} more ${omitted === 1 ? "line" : "lines"})`
           : firstLine;
-        return call(theme, "Bash", detail, context.state);
+        return call(theme, bashLabel, detail, context.state);
       }
-      return call(theme, "Bash", command, context.state);
+      return call(theme, bashLabel, command, context.state);
     },
     renderResult(toolResult: any, options: any, theme: any, context: any) {
       const output = textContent(toolResult);
       if (hideCleanTool(context.toolCallId, options.expanded, context.executionStarted)) return hiddenToolResult(context, options, output);
       if (useCompactToolView(context.toolCallId, options.expanded)) {
         if (options.isPartial) return partialResult(context, theme, "Running…");
-        const failed = completeStatus(context, output);
+        const failed = completeStatus(context);
         return result(theme, failed ? "Command failed" : "Done", "", false, failed);
       }
 
@@ -2072,7 +3496,7 @@ export default function prettyTui(pi: ExtensionAPI) {
         return bashResult(context, theme, "Running…", output, options.expanded, "running");
       }
 
-      const failed = isError(context, output);
+      const failed = isError(context);
       const outputLines = terminalOutputLines(output);
       const lineCount = outputLines.filter((line) => line.length > 0).length;
       const summary = failed
@@ -2092,19 +3516,20 @@ export default function prettyTui(pi: ExtensionAPI) {
   } as any);
 
   const edit = createEditTool(cwd);
+  const editLabel = edit.label || edit.name;
   pi.registerTool({
     ...edit,
     renderShell: "self",
     renderCall(args: any, theme: any, context: any) {
-      if (hideCleanTool(context.toolCallId, context.expanded, context.executionStarted)) return cleanToolCall(theme, "Edit", context.toolCallId);
+      if (hideCleanTool(context.toolCallId, context.expanded, context.executionStarted)) return cleanToolCall(theme, editLabel, context.toolCallId);
       const count = Array.isArray(args.edits) ? ` · ${args.edits.length} changes` : "";
-      return call(theme, "Edit", `${args.path}${count}`, context.state);
+      return call(theme, editLabel, `${args.path}${count}`, context.state);
     },
     renderResult(toolResult: any, options: any, theme: any, context: any) {
       const output = textContent(toolResult);
       if (hideCleanTool(context.toolCallId, options.expanded, context.executionStarted)) return hiddenToolResult(context, options, output);
       if (options.isPartial) return partialResult(context, theme, "Editing…");
-      const failed = completeStatus(context, output);
+      const failed = completeStatus(context);
       const diff = toolResult.details?.diff ?? "";
       const additions = diff.split("\n").filter((line: string) => line.startsWith("+") && !line.startsWith("+++")).length;
       const removals = diff.split("\n").filter((line: string) => line.startsWith("-") && !line.startsWith("---")).length;
@@ -2133,26 +3558,27 @@ export default function prettyTui(pi: ExtensionAPI) {
   } as any);
 
   const write = createWriteTool(cwd);
+  const writeLabel = write.label || write.name;
   pi.registerTool({
     ...write,
     renderShell: "self",
     renderCall(args: any, theme: any, context: any) {
-      if (hideCleanTool(context.toolCallId, context.expanded, context.executionStarted)) return cleanToolCall(theme, "Write", context.toolCallId);
+      if (hideCleanTool(context.toolCallId, context.expanded, context.executionStarted)) return cleanToolCall(theme, writeLabel, context.toolCallId);
       const content = typeof args.content === "string" ? args.content : "";
       const path = String(args.path ?? "");
       if (useCompactToolView(context.toolCallId, context.expanded)) {
         const lines = content.replace(/\t/g, "    ").split("\n");
         while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
         const total = lines.length;
-        return call(theme, "Write", `${path} · ${total} ${total === 1 ? "line" : "lines"}`, context.state);
+        return call(theme, writeLabel, `${path} · ${total} ${total === 1 ? "line" : "lines"}`, context.state);
       }
-      return writeCall(theme, path, content, context.expanded, context.state);
+      return writeCall(theme, writeLabel, path, content, context.expanded, context.state);
     },
     renderResult(toolResult: any, options: any, theme: any, context: any) {
       const output = textContent(toolResult);
       if (hideCleanTool(context.toolCallId, options.expanded, context.executionStarted)) return hiddenToolResult(context, options, output);
       if (options.isPartial) return partialResult(context, theme, "Writing…");
-      const failed = completeStatus(context, output);
+      const failed = completeStatus(context);
       return result(
         theme,
         failed ? output.split("\n")[0] || "Write failed" : "Written",
@@ -2164,56 +3590,59 @@ export default function prettyTui(pi: ExtensionAPI) {
   } as any);
 
   const grep = createGrepTool(cwd);
+  const grepLabel = grep.label || grep.name;
   pi.registerTool({
     ...grep,
     renderShell: "self",
     renderCall(args: any, theme: any, context: any) {
-      if (hideCleanTool(context.toolCallId, context.expanded, context.executionStarted)) return cleanToolCall(theme, "Grep", context.toolCallId);
+      if (hideCleanTool(context.toolCallId, context.expanded, context.executionStarted)) return cleanToolCall(theme, grepLabel, context.toolCallId);
       const where = args.path ? ` · ${args.path}` : "";
       const glob = args.glob ? ` · ${args.glob}` : "";
-      return call(theme, "Grep", `${args.pattern}${where}${glob}`, context.state);
+      return call(theme, grepLabel, `${args.pattern}${where}${glob}`, context.state);
     },
     renderResult(toolResult: any, options: any, theme: any, context: any) {
       const output = textContent(toolResult);
       if (hideCleanTool(context.toolCallId, options.expanded, context.executionStarted)) return hiddenToolResult(context, options, output);
       if (options.isPartial) return partialResult(context, theme, "Searching…");
-      const failed = completeStatus(context, output);
+      const failed = completeStatus(context);
       const matches = nonEmptyLines(output);
       return result(theme, failed ? output.split("\n")[0] : `Found ${matches} matches`, output, options.expanded, failed);
     },
   } as any);
 
   const find = createFindTool(cwd);
+  const findLabel = find.label || find.name;
   pi.registerTool({
     ...find,
     renderShell: "self",
     renderCall(args: any, theme: any, context: any) {
-      if (hideCleanTool(context.toolCallId, context.expanded, context.executionStarted)) return cleanToolCall(theme, "Find", context.toolCallId);
-      return call(theme, "Find", `${args.pattern}${args.path ? ` · ${args.path}` : ""}`, context.state);
+      if (hideCleanTool(context.toolCallId, context.expanded, context.executionStarted)) return cleanToolCall(theme, findLabel, context.toolCallId);
+      return call(theme, findLabel, `${args.pattern}${args.path ? ` · ${args.path}` : ""}`, context.state);
     },
     renderResult(toolResult: any, options: any, theme: any, context: any) {
       const output = textContent(toolResult);
       if (hideCleanTool(context.toolCallId, options.expanded, context.executionStarted)) return hiddenToolResult(context, options, output);
       if (options.isPartial) return partialResult(context, theme, "Searching…");
-      const failed = completeStatus(context, output);
+      const failed = completeStatus(context);
       const matches = nonEmptyLines(output);
       return result(theme, failed ? output.split("\n")[0] : `Found ${matches} paths`, output, options.expanded, failed);
     },
   } as any);
 
   const ls = createLsTool(cwd);
+  const lsLabel = ls.label || ls.name;
   pi.registerTool({
     ...ls,
     renderShell: "self",
     renderCall(args: any, theme: any, context: any) {
-      if (hideCleanTool(context.toolCallId, context.expanded, context.executionStarted)) return cleanToolCall(theme, "List", context.toolCallId);
-      return call(theme, "List", args.path ?? ".", context.state);
+      if (hideCleanTool(context.toolCallId, context.expanded, context.executionStarted)) return cleanToolCall(theme, lsLabel, context.toolCallId);
+      return call(theme, lsLabel, args.path ?? ".", context.state);
     },
     renderResult(toolResult: any, options: any, theme: any, context: any) {
       const output = textContent(toolResult);
       if (hideCleanTool(context.toolCallId, options.expanded, context.executionStarted)) return hiddenToolResult(context, options, output);
       if (options.isPartial) return partialResult(context, theme, "Listing…");
-      const failed = completeStatus(context, output);
+      const failed = completeStatus(context);
       const entries = nonEmptyLines(output);
       return result(theme, failed ? output.split("\n")[0] : `Listed ${entries} entries`, output, options.expanded, failed);
     },