pi-pretty-tui 0.2.0 → 0.2.2

package/extensions/index.ts

@@ -32,15 +32,18 @@ import { join } from "node:path";
 import {
   ActivityTimeline,
   assistantMessageKey,
-  assistantSystemBoundary,
+  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 RESPONSE_FOOTER_ENTRY_TYPE = "pretty-tui-response-footer";
 const SPECIALIZED_TOOL_NAMES = new Set(["read", "bash", "edit", "write", "grep", "find", "ls"]);
 
 const stripAnsiBackgrounds = (value: string): string =>
@@ -95,14 +98,131 @@ 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 copyTranscriptText = (text: string) => {
+    // Code-block copy must preserve leading/trailing whitespace and indentation.
+    // Answers are normalized separately by assistantAnswerText().
+    if (!text.trim()) return;
+    const copyText = text;
+    if (typeof currentTui?.copyTextToClipboard === "function") {
+      // Fullscreen uses Pi's native clipboard path and native flash feedback.
+      void Promise.resolve(currentTui.copyTextToClipboard(copyText)).catch(() => {
+        currentTui?.flash?.("Copy failed");
+      });
+      return;
+    }
+    void copyToClipboard(copyText)
+      .then(() => setLatestActivityStatus({ title: "Copied!", severity: "success" }))
+      .catch(() => setLatestActivityStatus({ title: "Copy failed", severity: "error" }));
+  };
+  type ResponseFooterData = {
+    answerEntryId?: string;
+    durationMs: number;
+    outcome: "completed" | "stopped";
+  };
+  const responseAnswerTexts = new Map<string, string>();
+  let responseRunStartedAt: number | undefined;
+  let responseHasAssistantMessage = false;
+  const assistantAnswerText = (message: any): string => {
+    if (typeof message?.content === "string") return message.content.trim();
+    if (!Array.isArray(message?.content)) return "";
+    return message.content
+      .filter((item: any) => item?.type === "text" && typeof item.text === "string" && item.text.trim())
+      .map((item: any) => item.text.trim())
+      .join("\n\n")
+      .trim();
+  };
+  const formatResponseDuration = (durationMs: number): string => {
+    const totalSeconds = Math.max(1, Math.round(Math.max(0, durationMs) / 1000));
+    if (totalSeconds < 60) return `${totalSeconds}s`;
+    const totalMinutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    if (totalMinutes < 60) return `${totalMinutes}m ${seconds}s`;
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    return `${hours}h ${String(minutes).padStart(2, "0")}m`;
+  };
   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 customUpdateToolHints = new Map<string, string>();
-  const customUpdateBeforeToolHints = new Set<string>();
+  const activityUpdateMarkdownComponents = new Map<string, {
+    content: string;
+    theme: any;
+    component: Markdown;
+  }>();
   let activityUpdateSequence = 0;
   const assistantBoundaryKeys = new Set<string>();
   const cleanCompactToolCallIds = new Set<string>();
@@ -113,6 +233,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);
@@ -167,11 +301,17 @@ export default function prettyTui(pi: ExtensionAPI) {
   };
 
   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);
-        if (color === "success" || color === "syntaxComment") return markdownTheme.codeBlock(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);
@@ -204,6 +344,12 @@ export default function prettyTui(pi: ExtensionAPI) {
   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,
@@ -238,6 +384,50 @@ export default function prettyTui(pi: ExtensionAPI) {
       .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,
@@ -247,10 +437,11 @@ export default function prettyTui(pi: ExtensionAPI) {
     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 lines = [theme.fg("accent", "◇ ") + theme.fg("toolTitle", theme.bold(title))];
+    const style = activityUpdateStyle(member, theme);
+    const lines = [style.icon + style.title(title)];
     if (member.updateContent) {
       const detailWidth = Math.max(1, childWidth - visibleWidth("  │ "));
-      const detailLines = wrapTextWithAnsi(theme.fg("muted", member.updateContent), detailWidth);
+      const detailLines = renderActivityUpdateMarkdown(member, detailWidth, theme);
       lines.push(...detailLines.map((line, index) =>
         theme.fg("dim", index === detailLines.length - 1 ? "  └ " : "  │ ") + line
       ));
@@ -267,10 +458,11 @@ export default function prettyTui(pi: ExtensionAPI) {
   const renderPendingActivityUpdate = (member: ActivityMember, width: number): string[] => {
     const theme = defaultActivityTheme();
     const title = truncateToWidth(member.updateTitle ?? "Update", Math.max(1, width - 2), "…");
-    const lines = [theme.fg("accent", "◇ ") + theme.fg("toolTitle", theme.bold(title))];
+    const style = activityUpdateStyle(member, theme);
+    const lines = [style.icon + style.title(title)];
     if (member.updateContent) {
       const detailWidth = Math.max(1, width - visibleWidth("  │ "));
-      const details = wrapTextWithAnsi(theme.fg("muted", member.updateContent), detailWidth);
+      const details = renderActivityUpdateMarkdown(member, detailWidth, theme);
       lines.push(...details.map((line, index) =>
         theme.fg("dim", index === details.length - 1 ? "  └ " : "  │ ") + line
       ));
@@ -278,13 +470,28 @@ export default function prettyTui(pi: ExtensionAPI) {
     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 || group.toolCallIds.length === 0) return undefined;
+    if (!isLeftClick || !activityGroupCollapsible(group)) return undefined;
     const position = activityMemberPosition(group, member);
     if (!activityGroupRevealed(group)) {
       if (!position.first) return undefined;
@@ -306,6 +513,8 @@ export default function prettyTui(pi: ExtensionAPI) {
         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?.();
@@ -399,6 +608,8 @@ export default function prettyTui(pi: ExtensionAPI) {
       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 {
@@ -415,20 +626,6 @@ export default function prettyTui(pi: ExtensionAPI) {
   // render patches or override built-in tools until the next enabled reload.
   if (!activeForSession) return;
 
-  // 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;
-
   // 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.
@@ -499,8 +696,10 @@ export default function prettyTui(pi: ExtensionAPI) {
     });
   }
 
-  // Render user prompts as a titled, rounded frame while preserving Pi's
-  // original Markdown component, wrapping, output padding, and OSC 133 zones.
+  // Render user prompts as right-aligned, content-sized chat bubbles while
+  // preserving Pi's Markdown component, wrapping, output padding, and OSC 133
+  // zones. Long messages stop at 75% of the terminal width; narrow terminals
+  // trade away the left gap before sacrificing readability.
   const userMessagePrototype = UserMessageComponent.prototype as any;
   const userMessagePatchKey = Symbol.for("pretty-tui.user-message-frame");
   if (!userMessagePrototype[userMessagePatchKey]) {
@@ -510,66 +709,118 @@ export default function prettyTui(pi: ExtensionAPI) {
       const content = this.children?.[0] as any;
       if (!content) return;
 
-      // Reuse Pi's theme-aware user background across the complete frame.
-      const userMessageBg = content.bgFn as ((text: string) => string) | undefined;
+      // Remove Pi's full-width user-message background. The Markdown keeps its
+      // native foreground styling, while the surrounding bubble stays transparent.
       content.paddingX = 0;
       content.paddingY = 0;
       content.setBgFn?.(undefined);
       content.invalidate?.();
+      // Pi wraps the Markdown in a full-width Box. Render the Markdown child
+      // directly so short messages expose their natural visible width instead
+      // of inheriting the Box's width-filling padding.
+      const markdown = content.children?.[0] ?? content;
 
       const outputPad = Math.max(0, Number(this.outputPad) || 0);
       const markdownTheme = this.markdownTheme;
-      const border = (text: string) => markdownTheme.quoteBorder(text);
+      // Markdown deliberately pads every rendered line to the requested width.
+      // Remove only that trailing layout padding before measuring or framing;
+      // ANSI styling and the visible content remain untouched.
+      const renderMarkdown = (width: number): string[] =>
+        withTranscriptMarkdown(() => markdown.render(width))
+          .map((line: string) => line.replace(/ +$/u, ""));
+      const layout = (width: number) => {
+        const terminalWidth = Math.max(1, width);
+        const rightPad = Math.min(outputPad, Math.max(0, terminalWidth - 1));
+        const availableWidth = Math.max(1, terminalWidth - rightPad);
+        if (availableWidth < 4) {
+          return {
+            framed: false,
+            rightPad,
+            leftPad: 0,
+            frameWidth: availableWidth,
+            contentWidth: availableWidth,
+            body: renderMarkdown(availableWidth),
+          };
+        }
+
+        const preferredMaximum = Math.max(4, Math.floor(terminalWidth * 0.75));
+        // Keep at least one blank column on the left whenever a framed bubble
+        // fits, even after a narrow terminal relaxes the usual 75% maximum.
+        const bubbleAvailable = availableWidth >= 5 ? availableWidth - 1 : availableWidth;
+        const narrowReadableMinimum = Math.min(bubbleAvailable, 24);
+        const frameMaximum = Math.min(
+          bubbleAvailable,
+          Math.max(preferredMaximum, narrowReadableMinimum),
+        );
+        const measuringWidth = Math.max(1, frameMaximum - 4);
+        const measuredBody = renderMarkdown(measuringWidth);
+        const naturalContentWidth = Math.max(
+          1,
+          ...measuredBody.map((line: string) => visibleWidth(line)),
+        );
+        const frameWidth = Math.min(frameMaximum, naturalContentWidth + 4);
+        const contentWidth = Math.max(1, frameWidth - 4);
+        const body = contentWidth === measuringWidth
+          ? measuredBody
+          : renderMarkdown(contentWidth);
+        return {
+          framed: true,
+          rightPad,
+          leftPad: Math.max(0, terminalWidth - rightPad - frameWidth),
+          frameWidth,
+          contentWidth,
+          body,
+        };
+      };
+      const border = (text: string) => currentExtensionUi?.theme?.fg
+        ? currentExtensionUi.theme.fg("accent", text)
+        : markdownTheme.quoteBorder(text);
       const frame: Component = {
         render(width: number): string[] {
-          const sidePad = Math.min(outputPad, Math.max(0, Math.floor((width - 1) / 2)));
-          const outer = " ".repeat(sidePad);
-          const frameWidth = Math.max(1, width - sidePad * 2);
-          const paintBackground = (line: string) => {
-            const padding = " ".repeat(Math.max(0, frameWidth - visibleWidth(line)));
-            return userMessageBg ? userMessageBg(line + padding) : line + padding;
-          };
-          if (frameWidth < 4) {
-            return content.render(frameWidth).map((line: string) => outer + paintBackground(line));
+          const measured = layout(width);
+          const left = " ".repeat(measured.leftPad);
+          const right = " ".repeat(measured.rightPad);
+          if (!measured.framed) {
+            return measured.body.map((line: string) => left + line + right);
           }
 
-          const title = " User ";
-          const topStart = "╭─";
-          const topTail = "─".repeat(Math.max(0, frameWidth - visibleWidth(topStart) - visibleWidth(title) - 1));
-          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 = withTranscriptMarkdown(() => content.render(contentWidth)).map((line: string) => {
-            const padding = " ".repeat(Math.max(0, contentWidth - visibleWidth(line)));
+          const top = border("╭" + "─".repeat(Math.max(0, measured.frameWidth - 2)) + "╮");
+          const bottom = border("╰" + "─".repeat(Math.max(0, measured.frameWidth - 2)) + "╯");
+          const body = measured.body.map((line: string) => {
+            const padding = " ".repeat(Math.max(0, measured.contentWidth - visibleWidth(line)));
             return border("│ ") + line + padding + border(" │");
           });
-          return [top, ...body, bottom].map((line: string) => outer + paintBackground(line));
+          return [top, ...body, bottom].map((line: string) => left + line + right);
         },
         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({
+          if (!markdown.handleMouse) return undefined;
+          const measured = layout(event.width);
+          if (!measured.framed) {
+            return withTranscriptMarkdown(() => markdown.handleMouse({
               ...event,
-              x: event.x - sidePad,
-              width: frameWidth,
+              x: event.x - measured.leftPad,
+              width: measured.contentWidth,
             }));
           }
-          const contentWidth = Math.max(1, frameWidth - 4);
-          if (event.y <= 0 || event.x < sidePad + 2 || event.x >= sidePad + 2 + contentWidth) {
+          const contentX = measured.leftPad + 2;
+          if (
+            event.y <= 0 ||
+            event.y > measured.body.length ||
+            event.x < contentX ||
+            event.x >= contentX + measured.contentWidth
+          ) {
             return undefined;
           }
-          return withTranscriptMarkdown(() => content.handleMouse({
+          return withTranscriptMarkdown(() => markdown.handleMouse({
             ...event,
-            x: event.x - sidePad - 2,
+            x: event.x - contentX,
             y: event.y - 1,
-            width: contentWidth,
-            height: Math.max(0, event.height - 2),
+            width: measured.contentWidth,
+            height: measured.body.length,
           }));
         },
         invalidate() {
-          content.invalidate?.();
+          markdown.invalidate?.();
         },
       };
 
@@ -615,14 +866,31 @@ export default function prettyTui(pi: ExtensionAPI) {
           .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);
-    return activityTimeline.addUpdate(key, title, content, true) ??
-      activityTimeline.addPendingUpdate(key, title, content, true);
+    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]) {
@@ -631,9 +899,13 @@ export default function prettyTui(pi: ExtensionAPI) {
     const releaseSemanticCustomMessage = (component: any): boolean => {
       if (!component.customRenderer) return false;
       const key = customMessageKey(component.message);
-      const member = activityTimeline.memberForUpdate(key);
-      if (member) activityUpdateComponents.delete(member.id);
-      activityTimeline.removeUpdate(key);
+      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[] {
@@ -643,37 +915,19 @@ export default function prettyTui(pi: ExtensionAPI) {
       const message = this.message;
       const key = customMessageKey(message);
       let member = activityTimeline.memberForUpdate(key);
-      if (!member) {
-        const hintedToolCallId = customUpdateToolHints.get(key);
-        const hintedGroup = hintedToolCallId
-          ? activityTimeline.groupForTool(hintedToolCallId)
-          : undefined;
-        if (hintedGroup) {
-          const attach = customUpdateBeforeToolHints.has(key)
-            ? activityTimeline.addUpdateToGroupStart.bind(activityTimeline)
-            : activityTimeline.addUpdateToGroup.bind(activityTimeline);
-          member = attach(
-            hintedGroup.id,
-            key,
-            humanizeCustomType(message?.customType ?? "update"),
-            customMessageText(message),
-            true,
-          );
-        }
+      // 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);
-      if (group.toolCallIds.length === 0) return renderPendingActivityUpdate(member, width);
-      const position = activityMemberPosition(group, member);
-      if (!activityGroupRevealed(group)) {
-        return position.first
-          ? ["", ...renderActivityGroupSummary(group, width, true)]
-          : [];
-      }
-      return renderActivityUpdate(group, member, width);
+      return renderActivityUpdateProjection(group, member, width);
     };
     const patchedCustomHandleMouse = function (this: any, event: any) {
       if (releaseSemanticCustomMessage(this)) {
@@ -684,7 +938,6 @@ export default function prettyTui(pi: ExtensionAPI) {
       if (renderMode !== "clean" || !member || !group) {
         return originalCustomHandleMouse?.call(this, event);
       }
-      if (group.toolCallIds.length === 0) return undefined;
       return handleActivityUpdateMouse(group, member, event);
     };
     customMessagePrototype[customMessagePatchKey] = {
@@ -728,14 +981,38 @@ export default function prettyTui(pi: ExtensionAPI) {
     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,
-      ) &&
-      !assistantSystemBoundary(message);
+      );
 
     const refreshGroup = (group: ActivityGroup) => {
       for (const member of group.members) {
@@ -743,11 +1020,41 @@ export default function prettyTui(pi: ExtensionAPI) {
           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;
@@ -790,8 +1097,14 @@ export default function prettyTui(pi: ExtensionAPI) {
       ) {
         patchedUpdateContent.call(this, message, this.isStreaming);
       }
-      if (renderMode !== "clean" || !eligibleThinking(message)) {
-        return originalRender.call(this, width);
+      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);
@@ -803,25 +1116,29 @@ export default function prettyTui(pi: ExtensionAPI) {
         // assistant text is never lost.
         return originalRender.call(this, width);
       }
-      if (group.toolCallIds.length === 0) {
-        // Activity groups are tool-oriented. A model may finish with Thinking
-        // and visible text without calling a tool; only the Thinking portion
-        // is filtered from Pi's native component, so always preserve the
-        // visible response here instead of returning an empty projection.
-        return visibleAssistantText(message) ? 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 [...activityLines, ...visibleLines];
+        return appendTail(activityLines);
       }
 
       const groupTheme = activityGroupTheme(group);
@@ -831,10 +1148,16 @@ export default function prettyTui(pi: ExtensionAPI) {
         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;
-      const stableSummary = !position.first || Boolean(
-        settledOwner && settledSummaries.has(settledOwner) && !toolActivityHolds.has(settledOwner),
+      // 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)
       );
       const cacheable = !expanded && !this.isStreaming && stableSummary;
       const cached = cacheable ? this[cleanThinkingRenderCacheKey] : undefined;
@@ -848,7 +1171,7 @@ export default function prettyTui(pi: ExtensionAPI) {
         // 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 [...cached.lines, ...visibleLines];
+        return appendTail(cached.lines);
       }
       const stateLabel = this.isStreaming ? "thinking" : "thought";
       const label = truncateToWidth(stateLabel, Math.max(1, childWidth - 2), "…");
@@ -856,28 +1179,11 @@ export default function prettyTui(pi: ExtensionAPI) {
         groupTheme.fg("toolTitle", groupTheme.bold(label));
       let contentLines: string[] = [header];
       if (expanded) {
-        const detailWidth = Math.max(1, childWidth - visibleWidth("  │ "));
-        const detailText = member.thinking ?? thinkingText(message);
-        let detail = this[cleanThinkingDetailKey];
-        if (!detail || detail.text !== detailText) {
-          detail = {
-            text: detailText,
-            component: new Markdown(
-              detailText,
-              0,
-              0,
-              this.markdownTheme,
-              {
-                color: (text: string) => groupTheme.fg("thinkingText", text),
-                italic: true,
-              },
-            ),
-          };
-          this[cleanThinkingDetailKey] = detail;
-        }
-        const detailLines = detail.component.render(detailWidth);
-        contentLines.push(...detailLines.map((line: string, index: number) =>
-          groupTheme.fg("dim", index === detailLines.length - 1 ? "  └ " : "  │ ") + line
+        contentLines.push(...thinkingDetailLines(
+          this,
+          member.thinking ?? thinkingText(message),
+          groupTheme,
+          Math.max(1, childWidth - visibleWidth("  │ ")),
         ));
       }
       const decorated = contentLines.map((line, index) =>
@@ -896,7 +1202,7 @@ export default function prettyTui(pi: ExtensionAPI) {
           lines: output,
         };
       }
-      return [...output, ...visibleLines];
+      return appendTail(output);
     };
 
     const patchedRender = function (this: any, width: number): string[] {
@@ -905,14 +1211,20 @@ export default function prettyTui(pi: ExtensionAPI) {
 
     const handleAssistantTranscriptMouse = function (this: any, event: any) {
       const message = this[originalMessageKey] ?? this.lastMessage;
-      if (renderMode !== "clean" || !eligibleThinking(message)) {
-        return originalHandleMouse.call(this, event);
+      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);
-      if (group.toolCallIds.length === 0) return originalHandleMouse.call(this, event);
       const position = activityMemberPosition(group, member);
       const isLeftClick = event.type === "click" && event.button === "left";
 
@@ -1027,53 +1339,42 @@ export default function prettyTui(pi: ExtensionAPI) {
     ];
   };
 
-  const indexDisplayedCustomUpdateHints = (entries: any[]) => {
-    customUpdateToolHints.clear();
-    customUpdateBeforeToolHints.clear();
-    let lastToolCallId: string | undefined;
-    let pendingCustomKeys: string[] = [];
-    for (const entry of entries) {
-      if (entry?.type === "compaction") {
-        lastToolCallId = undefined;
-        pendingCustomKeys = [];
-        continue;
-      }
-      if (entry?.type === "custom_message") {
-        if (entry.display !== false) {
-          const key = customMessageKey(entry);
-          if (lastToolCallId) customUpdateToolHints.set(key, lastToolCallId);
-          else pendingCustomKeys.push(key);
-        }
-        continue;
-      }
-      if (entry?.type !== "message") continue;
-      const message = entry.message;
-      if (message?.role === "user") {
-        lastToolCallId = undefined;
-        pendingCustomKeys = [];
-        continue;
-      }
-      if (message?.role === "assistant") {
-        const toolCalls = (Array.isArray(message.content) ? message.content : [])
-          .filter((item: any) => item?.type === "toolCall" && item.id);
-        if (toolCalls.length > 0 && pendingCustomKeys.length > 0) {
-          for (const key of pendingCustomKeys) {
-            customUpdateToolHints.set(key, toolCalls[0].id);
-            customUpdateBeforeToolHints.add(key);
-          }
-          pendingCustomKeys = [];
-        }
-        if (visibleAssistantText(message) || assistantSystemBoundary(message)) {
-          lastToolCallId = undefined;
-          pendingCustomKeys = [];
-        }
-        for (const item of toolCalls) lastToolCallId = item.id;
-        continue;
-      }
-      if (message?.role === "toolResult" && message.toolCallId) {
-        lastToolCallId = message.toolCallId;
-      }
-    }
+  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;
@@ -1083,6 +1384,10 @@ export default function prettyTui(pi: ExtensionAPI) {
     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;
@@ -1107,7 +1412,6 @@ export default function prettyTui(pi: ExtensionAPI) {
       // while Pi's live compaction UI appends it chronologically. Keep reloads
       // and transcript rebuilds consistent with that live presentation.
       const orderedEntries = orderContextEntriesForTranscript(entries);
-      indexDisplayedCustomUpdateHints(orderedEntries);
       return originalRenderSessionEntries.call(this, orderedEntries, options);
     };
 
@@ -1118,43 +1422,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" || (type !== undefined && type !== "info")) {
+      if (renderMode !== "clean") {
         return originalShowExtensionNotify.call(this, message, type);
       }
-      const [firstLine, ...remainingLines] = String(message).split("\n");
-      const updateKey = `info:${++activityUpdateSequence}`;
-      const title = firstLine || "Info";
-      const content = remainingLines.join("\n");
-      const member = activityTimeline.addUpdate(updateKey, title, content, false) ??
-        activityTimeline.addPendingUpdate(updateKey, title, content, false);
-      const group = activityTimeline.groupForMember(member.id);
-      if (!group || !this.chatContainer?.addChild) {
-        return originalShowExtensionNotify.call(this, message, type);
+      const severity: ActivitySeverity = type ?? "info";
+      if (!appendRuntimeActivityUpdate(this, message, severity)) {
+        nativeExtensionNotify.call(this, message, severity);
       }
-      const component: Component = {
-        render: (width: number) => {
-          if (group.toolCallIds.length === 0) return renderPendingActivityUpdate(member, width);
-          const position = activityMemberPosition(group, member);
-          if (!activityGroupRevealed(group)) {
-            return position.first
-              ? ["", ...renderActivityGroupSummary(group, width, true)]
-              : [];
-          }
-          return renderActivityUpdate(group, member, width);
-        },
-        invalidate() {},
-        handleMouse: (event: any) => handleActivityUpdateMouse(group, member, event),
-      } as Component;
-      activityUpdateComponents.set(member.id, component);
-      this.chatContainer.addChild(component);
+    };
+
+    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,
@@ -1164,15 +1505,28 @@ export default function prettyTui(pi: ExtensionAPI) {
       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;
@@ -1188,11 +1542,27 @@ export default function prettyTui(pi: ExtensionAPI) {
       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.showExtensionNotify === patch.originalShowExtensionNotify
+        interactiveModePrototype.showExtensionNotify === patch.originalShowExtensionNotify &&
+        interactiveModePrototype.toggleThinkingBlockVisibility === patch.originalToggleThinkingBlockVisibility &&
+        interactiveModePrototype.showStatus === patch.originalShowStatus &&
+        interactiveModePrototype.showWarning === patch.originalShowWarning &&
+        interactiveModePrototype.showError === patch.originalShowError
       ) {
         delete interactiveModePrototype[toolsExpansionPatchKey];
       }
@@ -1517,20 +1887,7 @@ export default function prettyTui(pi: ExtensionAPI) {
             event.y === candidate.y && event.x >= candidate.xStart && event.x < candidate.xEnd,
         );
         if (region) {
-          if (event.type === "click") {
-            if (typeof currentTui?.copyTextToClipboard === "function") {
-              // Match fullscreen selection exactly: use Pi TUI's clipboard path
-              // and its transient "Copied!" / "Copy failed" flash feedback.
-              void Promise.resolve(currentTui.copyTextToClipboard(region.code)).catch(() => {
-                currentTui?.flash?.("Copy failed");
-              });
-            } 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"));
-            }
-          }
+          if (event.type === "click") copyTranscriptText(region.code);
           return { handled: true, render: false };
         }
       }
@@ -1760,8 +2117,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");
@@ -1834,8 +2194,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;
   };
@@ -2351,6 +2711,15 @@ export default function prettyTui(pi: ExtensionAPI) {
     activityTimeline.boundary();
   };
 
+  closeCleanAtNativeCustomBoundary = () => {
+    finishCleanGroup("done");
+    settleLastCleanGroup();
+  };
+  closeCleanAtStandaloneAlert = () => {
+    finishCleanGroup("done");
+    settleLastCleanGroup();
+  };
+
   const settleLastCleanGroup = () => {
     const group = cleanRun.groups[cleanRun.groups.length - 1];
     if (!group) return;
@@ -2374,14 +2743,16 @@ export default function prettyTui(pi: ExtensionAPI) {
     const activityText = /^thinking(?:\.\.\.)?$/iu.test(normalizedActivityText)
       ? "thinking"
       : rawActivityText;
-    const countLabel = `${count} tool ${count === 1 ? "call" : "calls"}`;
+    const countLabel = count > 0 ? `${count} tool ${count === 1 ? "call" : "calls"}` : "";
     const thoughtLabel = thoughtCount > 0
-      ? ` · ${thoughtCount} ${thoughtCount === 1 ? "thought" : "thoughts"}`
+      ? `${thoughtCount} ${thoughtCount === 1 ? "thought" : "thoughts"}`
       : "";
-    const activityLabel = activityText !== "done" && activityText.trim()
-      ? ` · ${activityText}`
+    // 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}`;
+    return [countLabel, thoughtLabel, activityLabel].filter(Boolean).join(" · ");
   };
 
   const summaryRow = (
@@ -2455,36 +2826,53 @@ export default function prettyTui(pi: ExtensionAPI) {
   ): 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);
-    if (!summaryTheme || !owner || group.toolCallIds.length === 0) return [];
-    const settled = settledSummaries.get(owner);
+    const settled = owner ? settledSummaries.get(owner) : undefined;
+    const toolCount = group.toolCallIds.length;
+    const live = () => cleanRun.activeToolName ?? currentCleanActivity();
     if (settled) {
       return fit(block([summaryRow(
         summaryTheme,
-        Math.max(settled.count, group.toolCallIds.length),
-        settled.failed,
+        group.hardBoundarySplit ? toolCount : Math.max(settled.count, toolCount),
+        group.hardBoundarySplit ? 0 : settled.failed,
         Math.max(settled.thoughtCount, group.thoughtCount),
         settled.activity,
         collapsedDone,
       )]).render(width));
     }
-    const currentBelongs = cleanRun.activeToolCallId
-      ? group.toolCallIds.includes(cleanRun.activeToolCallId)
-      : false;
-    const lastBelongs = cleanRun.lastCompletedToolCallId
-      ? group.toolCallIds.includes(cleanRun.lastCompletedToolCallId)
-      : false;
-    if (currentBelongs || lastBelongs || !cleanRun.settled) {
+    if (owner && !cleanRun.settled) {
+      // Live tool group: keep the current tool name and the running count.
       return fit(block([summaryRow(
         summaryTheme,
-        Math.max(group.toolCallIds.length, liveCleanToolCount()),
+        Math.max(toolCount, liveCleanToolCount()),
         cleanRun.failed,
         group.thoughtCount,
-        () => cleanRun.activeToolName ?? currentCleanActivity(),
+        live,
         collapsedDone,
       )]).render(width));
     }
-    return [];
+    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));
   };
 
   /**
@@ -2552,7 +2940,7 @@ 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([]);
   };
 
@@ -2570,6 +2958,62 @@ export default function prettyTui(pi: ExtensionAPI) {
       (renderMode === "clean" && isCleanGroupRevealed(toolCallId))
     );
 
+  pi.registerEntryRenderer<ResponseFooterData>(RESPONSE_FOOTER_ENTRY_TYPE, (entry, _options, theme) => {
+    let copyStart = -1;
+    let copyWidth = 0;
+    return {
+      render(width: number): string[] {
+        const data = entry.data;
+        if (!data || width <= 0) return [];
+        copyStart = -1;
+        copyWidth = 0;
+        const answer = data.answerEntryId ? responseAnswerTexts.get(data.answerEntryId) ?? "" : "";
+        const copyLabel = "[Copy]";
+        const showCopy = fullscreenTui && Boolean(answer.trim()) && width >= 30;
+        const duration = formatResponseDuration(data.durationMs);
+        const statusText = data.outcome === "stopped"
+          ? `⚠ Stopped after ${duration}`
+          : `✓ Completed in ${duration}`;
+        const leading = "── ";
+        const trailing = showCopy ? ` ${copyLabel} ──` : "──";
+        const fixedWidth = visibleWidth(leading) + visibleWidth(trailing) + 1;
+        if (width <= fixedWidth) return [theme.fg("dim", "─".repeat(width))];
+
+        const statusWidth = Math.max(1, width - fixedWidth);
+        const visibleStatus = truncateToWidth(statusText, statusWidth, "…");
+        const prefix = leading + visibleStatus + " ";
+        const fill = "─".repeat(Math.max(0, width - visibleWidth(prefix) - visibleWidth(trailing)));
+        const line = prefix + fill + trailing;
+        if (showCopy) {
+          const copyIndex = line.indexOf(copyLabel);
+          copyStart = visibleWidth(line.slice(0, copyIndex));
+          copyWidth = visibleWidth(copyLabel);
+        }
+        // The divider, completion text, and Copy control intentionally share
+        // one quiet gray treatment; position alone communicates the hierarchy.
+        return [theme.fg("dim", line)];
+      },
+      handleMouse(event: TuiMouseEvent) {
+        if (
+          copyStart < 0 ||
+          event.button !== "left" ||
+          (event.type !== "press" && event.type !== "click") ||
+          event.y !== 0 ||
+          event.x < copyStart ||
+          event.x >= copyStart + copyWidth
+        ) {
+          return undefined;
+        }
+        if (event.type === "click" && entry.data?.answerEntryId) {
+          const answer = responseAnswerTexts.get(entry.data.answerEntryId);
+          if (answer) copyTranscriptText(answer);
+        }
+        return { handled: true, render: false };
+      },
+      invalidate() {},
+    };
+  });
+
   pi.registerEntryRenderer<ToolSummaryData>("pretty-tui-tool-summary", (entry, { expanded }, theme) => ({
     render(width: number): string[] {
       if (renderMode !== "clean" || expanded || cleanContextCompacted) return [];
@@ -2620,17 +3064,21 @@ export default function prettyTui(pi: ExtensionAPI) {
 
   const restoreCleanSession = (ctx: any) => {
     currentExtensionUi = ctx.ui;
+    clearLatestActivityStatus();
     cleanToolsExpanded = ctx.ui.getToolsExpanded();
     settledSummaries.clear();
     legacySummaryLastToolCallIds.clear();
     activityTimeline.clear();
+    responseAnswerTexts.clear();
+    responseRunStartedAt = undefined;
+    responseHasAssistantMessage = false;
+    nativeCustomBoundaryKeys.clear();
     revealedActivityGroups.clear();
     expandedThinkingMembers.clear();
     thinkingComponents.clear();
     activityFallbackThemes.clear();
     activityUpdateComponents.clear();
-    customUpdateToolHints.clear();
-    customUpdateBeforeToolHints.clear();
+    activityUpdateMarkdownComponents.clear();
     activityUpdateSequence = 0;
     assistantBoundaryKeys.clear();
     knownToolCallIds.clear();
@@ -2847,8 +3295,10 @@ export default function prettyTui(pi: ExtensionAPI) {
       }
 
       if (message.role === "assistant") {
+        const answerText = assistantAnswerText(message);
+        if (answerText) responseAnswerTexts.set(entry.id, answerText);
         const thinking = thinkingText(message);
-        if (thinking && !assistantSystemBoundary(message)) {
+        if (thinking) {
           activityTimeline.addThinking(assistantMessageKey(message), thinking);
         }
         if (messageHasVisibleText(message)) finishGroup();
@@ -2857,7 +3307,7 @@ export default function prettyTui(pi: ExtensionAPI) {
           toolCalls.add(item.id);
           activityTimeline.addTool(item.id, item.name ?? "tool");
         }
-        if (assistantSystemBoundary(message)) finishGroup();
+        if (assistantTerminalState(message)) finishGroup();
         continue;
       }
 
@@ -2924,8 +3374,16 @@ export default function prettyTui(pi: ExtensionAPI) {
       (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" || assistantSystemBoundary(message)) return;
+    if (message?.role !== "assistant") return;
     const thinking = thinkingText(message);
     if (thinking) activityTimeline.addThinking(assistantMessageKey(message), thinking);
   };
@@ -2984,16 +3442,12 @@ export default function prettyTui(pi: ExtensionAPI) {
       closeAtAssistantBoundary(event.message, "done");
       return;
     }
-    if (assistantSystemBoundary(event.message)) {
-      closeAtAssistantBoundary(event.message, "done");
-      settleLastCleanGroup();
-      return;
-    }
     trackThinkingActivity(event.message);
     trackPendingToolActivity(event.message);
   });
   pi.on("message_end", (event) => {
-    if (hasVisibleAssistantText(event.message) || assistantSystemBoundary(event.message)) {
+    if (event.message?.role === "assistant") responseHasAssistantMessage = true;
+    if (hasVisibleAssistantText(event.message)) {
       trackThinkingActivity(event.message);
       closeAtAssistantBoundary(event.message, "done");
       cleanRun.activity = "done";
@@ -3002,6 +3456,12 @@ export default function prettyTui(pi: ExtensionAPI) {
     }
     trackThinkingActivity(event.message);
     trackPendingToolActivity(event.message);
+    if (assistantTerminalState(event.message)) {
+      clearToolActivityHolds();
+      finishCleanGroup("done");
+      settleLastCleanGroup();
+      cleanRun.activity = "done";
+    }
   });
 
   pi.on("agent_start", () => {
@@ -3009,6 +3469,7 @@ export default function prettyTui(pi: ExtensionAPI) {
     // count until the whole run reaches agent_settled.
     if (!cleanRun.active) {
       clearToolActivityHolds();
+      responseRunStartedAt = Date.now();
       cleanRun.count = 0;
       cleanRun.failed = 0;
       cleanRun.currentToolCallIds = [];
@@ -3017,6 +3478,9 @@ export default function prettyTui(pi: ExtensionAPI) {
       cleanRun.lastCompletedToolCallId = undefined;
       cleanRun.settled = false;
     }
+    // Retries share the original start time but only the newest low-level
+    // run may supply a candidate final answer.
+    responseHasAssistantMessage = false;
     cleanRun.active = true;
     cleanRun.activeToolCallIds.clear();
     cleanRun.activeToolCallId = undefined;
@@ -3058,6 +3522,8 @@ export default function prettyTui(pi: ExtensionAPI) {
     }
     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
@@ -3068,7 +3534,7 @@ export default function prettyTui(pi: ExtensionAPI) {
     cleanRun.activeToolName = undefined;
     cleanRun.activity = "thinking";
   });
-  pi.on("agent_settled", () => {
+  pi.on("agent_settled", (_event, ctx) => {
     if (cleanRun.settled) return;
 
     clearPendingToolActivities();
@@ -3090,6 +3556,30 @@ export default function prettyTui(pi: ExtensionAPI) {
     cleanRun.activity = "done";
     cleanRun.settled = true;
 
+    if (responseRunStartedAt !== undefined) {
+      // message_end runs before later extensions can replace the message and
+      // before Pi persists it. Read the committed branch at the final boundary
+      // so Copy matches the transcript even when another extension redacts it.
+      const finalEntry = responseHasAssistantMessage
+        ? ctx.sessionManager.getBranch().reverse().find(
+            (entry) => entry.type === "message" && entry.message.role === "assistant",
+          )
+        : undefined;
+      const answer = finalEntry && finalEntry.type === "message"
+        ? assistantAnswerText(finalEntry.message)
+        : "";
+      if (answer && finalEntry) responseAnswerTexts.set(finalEntry.id, answer);
+      pi.appendEntry<ResponseFooterData>(RESPONSE_FOOTER_ENTRY_TYPE, {
+        answerEntryId: answer ? finalEntry?.id : undefined,
+        durationMs: Math.max(0, Date.now() - responseRunStartedAt),
+        outcome: finalEntry?.type === "message" && assistantTerminalState(finalEntry.message)
+          ? "stopped"
+          : "completed",
+      });
+      responseRunStartedAt = undefined;
+      responseHasAssistantMessage = false;
+    }
+
     const groups = cleanRun.groups.slice();
     if (renderMode !== "clean" || groups.length === 0) return;
 
@@ -3129,7 +3619,7 @@ export default function prettyTui(pi: ExtensionAPI) {
       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" : "";
@@ -3167,7 +3657,7 @@ export default function prettyTui(pi: ExtensionAPI) {
       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);
       }
 
@@ -3175,7 +3665,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
@@ -3208,7 +3698,7 @@ export default function prettyTui(pi: ExtensionAPI) {
       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;
@@ -3257,7 +3747,7 @@ export default function prettyTui(pi: ExtensionAPI) {
       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",
@@ -3283,7 +3773,7 @@ export default function prettyTui(pi: ExtensionAPI) {
       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);
     },
@@ -3302,7 +3792,7 @@ export default function prettyTui(pi: ExtensionAPI) {
       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);
     },
@@ -3321,7 +3811,7 @@ export default function prettyTui(pi: ExtensionAPI) {
       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);
     },