pi-pretty-tui 0.1.3 → 0.1.4

package/README.md

@@ -7,10 +7,11 @@ A visual refinement extension for the [Pi coding agent](https://pi.dev/). It pro
 ## Features
 
 - Compact `Read`, `Bash`, `Edit`, `Write`, `Grep`, `Find`, and `List` calls
-- Gray running, green success, and red failure indicators
-- Concise result summaries with expandable output
-- Native-style `Write` previews: first 10 lines when collapsed, full content when expanded
-- Live `Bash` output: latest 5 lines when collapsed, all available output when expanded
+- Concise per-tool call and result summaries with expandable details
+- Native-style `Write` previews in `full` mode: first 10 lines when collapsed, full content when expanded
+- Live `Bash` output in `full` mode: latest 5 lines when collapsed, all available output when expanded
+- Switchable `full`, `compact`, and `clean` rendering modes with persistent settings
+- Clean mode hides thinking blocks (including Pi's standalone `Thinking...` placeholder) while collapsed and reveals the original thinking content when expanded
 - Colored `+added` and `-removed` edit statistics and diffs
 - Correct hanging indentation for long paths and wrapped tool output
 - Bullet (`•`) markers for unordered Markdown lists
@@ -25,13 +26,32 @@ Restart Pi or run `/reload` after installation.
 
 Pi may warn that built-in tools are being overridden. This is expected: pi-pretty-tui re-registers Pi's built-in tools and delegates execution to their original implementations, changing only their TUI renderers.
 
+## Rendering modes
+
+Run `/pretty-tui` to choose a mode interactively, or set one directly:
+
+```text
+/pretty-tui full
+/pretty-tui compact
+/pretty-tui clean
+/pretty-tui status
+```
+
+- `full` (default): preserve each tool's detailed call renderer and normal result preview. Press `Ctrl+O` to expand available output, diffs, and content.
+- `compact`: when collapsed, all supported built-in tools use concise one-line call summaries and final result summaries. Long commands, written content, edit diffs, and tool output stay hidden until expanded; press `Ctrl+O` to reveal the full details.
+- `clean`: collapse supported tool calls into a single `Running(...)` status; the activity slot shows a tool name as soon as its streamed tool call appears, such as `Running(3 tool calls · Read)`, and remains visible for at least 1 second before changing to `thinking...`. Once settled, the label becomes `Done(...)`. Visible assistant text starts a new tool group, so later calls get a separate status. Collapsed thinking blocks stay hidden without Pi's `Thinking...` placeholder; press `Ctrl+O` to reveal thinking content and normal expanded tool calls/output in transcript order.
+
+Clean mode covers the built-in tools managed by this package: `read`, `bash`, `edit`, `write`, `grep`, `find`, and `ls`. Third-party tools keep their own rendering.
+
+The selected mode applies immediately and persists in `~/.pi/agent/pretty-tui.json` (or the directory selected by `PI_CODING_AGENT_DIR`).
+
 ## Expand tool output
 
-Press `Ctrl+O` (Pi's default `app.tools.expand` keybinding) to show or hide detailed output, edit diffs, and complete `Write` content.
+Press `Ctrl+O` (Pi's default `app.tools.expand` keybinding) to show or hide detailed output, edit diffs, complete `Write` content, full tool details, and thinking content in `compact` or `clean` mode.
 
 ## Compatibility notice
 
-Tool rendering uses Pi's documented extension APIs. Changing unordered-list markers currently requires runtime patching of an internal `@earendil-works/pi-tui` Markdown renderer method because Pi does not expose a public hook for that presentation detail. Code blocks use Pi's original renderer without modification.
+Tool rendering uses Pi's documented extension APIs. Clean thinking and active-tool state follow Pi's built-in expansion and execution transitions through its exported interactive components. Changing unordered-list markers currently requires runtime patching of an internal `@earendil-works/pi-tui` Markdown renderer method because Pi does not expose a public hook for that presentation detail. Code blocks use Pi's original renderer without modification.
 
 No Pi source files are modified. The list-marker patch is removed during session shutdown, but a future Pi release may require this extension to be updated.
 

package/extensions/index.ts

@@ -1,5 +1,7 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import {
+  AssistantMessageComponent,
+  InteractiveMode,
+  ToolExecutionComponent,
   createBashTool,
   createEditTool,
   createFindTool,
@@ -7,6 +9,8 @@ import {
   createLsTool,
   createReadTool,
   createWriteTool,
+  getAgentDir,
+  type ExtensionAPI,
 } from "@earendil-works/pi-coding-agent";
 import {
   type Component,
@@ -14,10 +18,208 @@ import {
   visibleWidth,
   wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+type PrettyTuiMode = "full" | "compact" | "clean";
+const CLEAN_TOOL_ACTIVITY_MIN_MS = 1000;
+type PrettyTuiConfig = {
+  mode?: PrettyTuiMode;
+  /** Legacy location used by the first mode implementation. */
+  bash?: {
+    mode?: "full" | "compact";
+  };
+};
+
+const loadConfig = (path: string): PrettyTuiConfig => {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+};
 
 /** Polished tool calls and list rendering for Pi's TUI. */
 export default function prettyTui(pi: ExtensionAPI) {
   const cwd = process.cwd();
+  const configPath = join(getAgentDir(), "pretty-tui.json");
+  let config = loadConfig(configPath);
+  const configuredMode = config.mode ?? config.bash?.mode;
+  let renderMode: PrettyTuiMode = configuredMode === "compact" || configuredMode === "clean"
+    ? configuredMode
+    : "full";
+  let cleanToolsExpanded = false;
+
+  const saveRenderMode = (mode: PrettyTuiMode) => {
+    config = { ...config, mode };
+    mkdirSync(getAgentDir(), { recursive: true });
+    writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+  };
+
+  pi.registerCommand("pretty-tui", {
+    description: "Configure pi-pretty-tui rendering mode",
+    getArgumentCompletions: (prefix: string) => {
+      const items = [
+        { 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" },
+        { value: "status", label: "status", description: "Show the current mode" },
+      ];
+      const filtered = items.filter((item) => item.value.startsWith(prefix.trim().toLowerCase()));
+      return filtered.length > 0 ? filtered : null;
+    },
+    handler: async (args, ctx) => {
+      let requested = args.trim().toLowerCase();
+
+      if (!requested) {
+        if (!ctx.hasUI) {
+          ctx.ui.notify(`pi-pretty-tui mode: ${renderMode}`, "info");
+          return;
+        }
+        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]);
+        if (!selected) return;
+        requested = selected === full ? "full" : selected === compact ? "compact" : "clean";
+      }
+
+      if (requested === "status") {
+        ctx.ui.notify(`pi-pretty-tui mode: ${renderMode}`, "info");
+        return;
+      }
+      if (requested !== "full" && requested !== "compact" && requested !== "clean") {
+        ctx.ui.notify("Usage: /pretty-tui [full|compact|clean|status]", "error");
+        return;
+      }
+
+      renderMode = requested;
+      try {
+        saveRenderMode(renderMode);
+        ctx.ui.notify(`pi-pretty-tui mode set to: ${renderMode}`, "info");
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        ctx.ui.notify(`Mode changed for this session, but could not save settings: ${message}`, "warning");
+      }
+    },
+  });
+
+  // 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 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 originalMessageKey = Symbol("pretty-tui.original-assistant-message");
+    const renderedModeKey = Symbol("pretty-tui.rendered-assistant-mode");
+    const renderedExpansionKey = Symbol("pretty-tui.rendered-thinking-expansion");
+
+    const patchedUpdateContent = function (this: any, message: any, isStreaming = this.isStreaming) {
+      if (renderMode !== "clean") {
+        originalUpdateContent.call(this, message, isStreaming);
+        this[originalMessageKey] = message;
+        this[renderedModeKey] = renderMode;
+        this[renderedExpansionKey] = undefined;
+        return;
+      }
+
+      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;
+      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)
+      );
+      if (needsRefresh) {
+        patchedUpdateContent.call(this, this[originalMessageKey], this.isStreaming);
+      }
+      return originalRender.call(this, width);
+    };
+
+    assistantPrototype[thinkingPatchKey] = {
+      originalUpdateContent,
+      patchedUpdateContent,
+      originalRender,
+      patchedRender,
+    };
+    assistantPrototype.updateContent = patchedUpdateContent;
+    assistantPrototype.render = patchedRender;
+
+    pi.on("session_shutdown", () => {
+      const patch = assistantPrototype[thinkingPatchKey];
+      if (!patch) return;
+      if (patch.patchedUpdateContent === assistantPrototype.updateContent) {
+        assistantPrototype.updateContent = patch.originalUpdateContent;
+      }
+      if (patch.patchedRender === assistantPrototype.render) {
+        assistantPrototype.render = patch.originalRender;
+      }
+      if (
+        assistantPrototype.updateContent === patch.originalUpdateContent &&
+        assistantPrototype.render === patch.originalRender
+      ) {
+        delete assistantPrototype[thinkingPatchKey];
+      }
+    });
+  }
+
+  // Extension shortcuts cannot replace Pi's built-in Ctrl+O binding. Wrap
+  // the exported state transition instead, so both Ctrl+O and UI callers keep
+  // their normal behavior while clean thinking follows the same state.
+  const interactiveModePrototype = InteractiveMode.prototype as any;
+  const toolsExpansionPatchKey = Symbol.for("pretty-tui.clean-tool-expansion");
+  if (!interactiveModePrototype[toolsExpansionPatchKey]) {
+    const originalSetToolsExpanded = interactiveModePrototype.setToolsExpanded;
+    const patchedSetToolsExpanded = function (this: any, expanded: boolean) {
+      cleanToolsExpanded = expanded;
+      return originalSetToolsExpanded.call(this, expanded);
+    };
+
+    interactiveModePrototype[toolsExpansionPatchKey] = {
+      originalSetToolsExpanded,
+      patchedSetToolsExpanded,
+    };
+    interactiveModePrototype.setToolsExpanded = patchedSetToolsExpanded;
+
+    pi.on("session_shutdown", () => {
+      const patch = interactiveModePrototype[toolsExpansionPatchKey];
+      if (!patch) return;
+      if (patch.patchedSetToolsExpanded === interactiveModePrototype.setToolsExpanded) {
+        interactiveModePrototype.setToolsExpanded = patch.originalSetToolsExpanded;
+      }
+      if (interactiveModePrototype.setToolsExpanded === patch.originalSetToolsExpanded) {
+        delete interactiveModePrototype[toolsExpansionPatchKey];
+      }
+    });
+  }
 
   // Pi normalizes unordered-list markers to "-". Replace only that marker;
   // leave code-block rendering entirely to Pi's built-in Markdown renderer.
@@ -266,19 +468,623 @@ export default function prettyTui(pi: ExtensionAPI) {
     return failed;
   };
 
+  type ToolSummaryGroup = {
+    count: number;
+    failed: number;
+    lastToolCallId: string;
+    activity?: string;
+  };
+  type ToolSummaryData = {
+    count?: number;
+    failed?: 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;
+    until: number;
+    after: string;
+    started: boolean;
+    timer?: ReturnType<typeof setTimeout>;
+  };
+  const settledSummaries = new Map<string, { count: number; failed: number; activity: DisplayValue }>();
+  const toolActivityHolds = new Map<string, ToolActivityHold>();
+  const legacySummaryLastToolCallIds = new Map<string, string>();
+  const knownToolCallIds = new Set<string>();
+  type CleanRunState = {
+    activeToolCallId?: string;
+    lastCompletedToolCallId?: string;
+    activeToolName?: string;
+    activity?: string;
+    requestRender?: () => void;
+    count: number;
+    failed: number;
+    groups: ToolSummaryGroup[];
+    active: boolean;
+    settled: boolean;
+  };
+  const cleanRun: CleanRunState = {
+    count: 0,
+    failed: 0,
+    groups: [],
+    active: false,
+    settled: false,
+  };
+
+  const toolDisplayName = (name: string): string =>
+    name === "ls" ? "List" : name.charAt(0).toUpperCase() + name.slice(1);
+
+  const clearToolActivityHolds = () => {
+    for (const hold of toolActivityHolds.values()) {
+      if (hold.timer) clearTimeout(hold.timer);
+    }
+    toolActivityHolds.clear();
+  };
+
+  const heldActivity = (hold: ToolActivityHold): string =>
+    Date.now() < hold.until ? hold.name : hold.after;
+
+  const scheduleToolActivityRelease = (hold: ToolActivityHold) => {
+    if (hold.timer) clearTimeout(hold.timer);
+    const delay = Math.max(0, hold.until - Date.now());
+    hold.timer = setTimeout(() => {
+      hold.timer = undefined;
+      if (Date.now() < hold.until) {
+        scheduleToolActivityRelease(hold);
+        return;
+      }
+      if (toolActivityHolds.get(hold.toolCallId) === hold) {
+        toolActivityHolds.delete(hold.toolCallId);
+      }
+      if (cleanRun.lastCompletedToolCallId === hold.toolCallId && !cleanRun.activeToolCallId) {
+        cleanRun.activeToolName = undefined;
+        cleanRun.activity = hold.after;
+      }
+      cleanRun.requestRender?.();
+    }, delay);
+  };
+
+  const beginToolActivity = (toolCallId: string, name: string, started = false) => {
+    const previous = toolActivityHolds.get(toolCallId);
+    if (previous) {
+      if (previous.timer) clearTimeout(previous.timer);
+      previous.name = name;
+      previous.started ||= started;
+      cleanRun.activeToolName = name;
+      cleanRun.activity = name;
+      return;
+    }
+    const startedAt = Date.now();
+    toolActivityHolds.set(toolCallId, {
+      toolCallId,
+      name,
+      until: startedAt + CLEAN_TOOL_ACTIVITY_MIN_MS,
+      after: "thinking...",
+      started,
+    });
+    cleanRun.activeToolName = name;
+    cleanRun.activity = name;
+  };
+
+  const holdToolActivity = (toolCallId: string, name: string) => {
+    let hold = toolActivityHolds.get(toolCallId);
+    if (!hold) {
+      const now = Date.now();
+      hold = {
+        toolCallId,
+        name,
+        until: now + CLEAN_TOOL_ACTIVITY_MIN_MS,
+        after: "thinking...",
+        started: true,
+      };
+      toolActivityHolds.set(toolCallId, hold);
+    }
+    hold.name = name;
+    hold.started = true;
+    hold.after = "thinking...";
+    scheduleToolActivityRelease(hold);
+  };
+
+  const activityValueForHold = (toolCallId: string, after: string): DisplayValue => {
+    const hold = toolActivityHolds.get(toolCallId);
+    if (!hold) return after;
+    hold.after = after;
+    return () => heldActivity(hold);
+  };
+
+  const currentCleanActivity = (): string => {
+    if (cleanRun.activeToolCallId) {
+      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");
+  };
+
+  pi.on("session_shutdown", clearToolActivityHolds);
+
+  // A tool component can be created from the streamed assistant message
+  // before Pi dispatches tool_execution_start. Mark its activity at the
+  // component's own execution boundary too, so the first clean render names it.
+  const toolExecutionPrototype = ToolExecutionComponent.prototype as any;
+  const toolExecutionPatchKey = Symbol.for("pretty-tui.clean-tool-execution");
+  if (!toolExecutionPrototype[toolExecutionPatchKey]) {
+    const originalMarkExecutionStarted = toolExecutionPrototype.markExecutionStarted;
+    const originalToolRender = toolExecutionPrototype.render;
+    const renderedModeKey = Symbol("pretty-tui.tool-rendered-mode");
+    const patchedMarkExecutionStarted = function (this: any) {
+      if (supportedTools.has(this.toolName)) {
+        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);
+      }
+      return originalMarkExecutionStarted.call(this);
+    };
+    const patchedToolRender = function (this: any, width: number): string[] {
+      if (this[renderedModeKey] !== renderMode) {
+        this[renderedModeKey] = renderMode;
+        this.updateDisplay();
+      }
+      return originalToolRender.call(this, width);
+    };
+
+    toolExecutionPrototype[toolExecutionPatchKey] = {
+      originalMarkExecutionStarted,
+      patchedMarkExecutionStarted,
+      originalRender: originalToolRender,
+      patchedRender: patchedToolRender,
+    };
+    toolExecutionPrototype.markExecutionStarted = patchedMarkExecutionStarted;
+    toolExecutionPrototype.render = patchedToolRender;
+
+    pi.on("session_shutdown", () => {
+      const patch = toolExecutionPrototype[toolExecutionPatchKey];
+      if (!patch) return;
+      if (patch.patchedMarkExecutionStarted === toolExecutionPrototype.markExecutionStarted) {
+        toolExecutionPrototype.markExecutionStarted = patch.originalMarkExecutionStarted;
+      }
+      if (patch.patchedRender === toolExecutionPrototype.render) {
+        toolExecutionPrototype.render = patch.originalRender;
+      }
+      if (
+        toolExecutionPrototype.markExecutionStarted === patch.originalMarkExecutionStarted &&
+        toolExecutionPrototype.render === patch.originalRender
+      ) {
+        delete toolExecutionPrototype[toolExecutionPatchKey];
+      }
+    });
+  }
+
+  const finishCleanGroup = (activity = cleanRun.activity ?? "done") => {
+    if (cleanRun.lastCompletedToolCallId && cleanRun.count > 0) {
+      const group: ToolSummaryGroup = {
+        count: cleanRun.count,
+        failed: cleanRun.failed,
+        lastToolCallId: cleanRun.lastCompletedToolCallId,
+        activity,
+      };
+      cleanRun.groups.push(group);
+      settledSummaries.set(group.lastToolCallId, {
+        count: group.count,
+        failed: group.failed,
+        activity: activityValueForHold(group.lastToolCallId, activity),
+      });
+    }
+    cleanRun.count = 0;
+    cleanRun.failed = 0;
+    cleanRun.lastCompletedToolCallId = undefined;
+    cleanRun.activeToolCallId = undefined;
+    cleanRun.activeToolName = undefined;
+  };
+
+  const settleLastCleanGroup = () => {
+    const group = cleanRun.groups[cleanRun.groups.length - 1];
+    if (!group) return;
+    group.activity = "done";
+    settledSummaries.set(group.lastToolCallId, {
+      count: group.count,
+      failed: group.failed,
+      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}`
+      : "";
+    return `${countLabel}${activityLabel}`;
+  };
+
+  const summaryRow = (
+    theme: any,
+    count: number,
+    failed: number,
+    activity: DisplayValue = "done",
+  ): DisplayRow => ({
+    prefix: () => {
+      const currentActivity = typeof activity === "function" ? activity() : activity;
+      const color = currentActivity === "done" ? "success" : "accent";
+      return theme.fg(color, "● ");
+    },
+    continuation: "  ",
+    content: () => {
+      const currentActivity = typeof activity === "function" ? activity() : activity;
+      const label = currentActivity === "done" ? "Done" : "Running";
+      const color = label === "Done" ? "success" : "accent";
+      return theme.fg(color, theme.bold(label)) +
+        theme.fg("dim", "(") +
+        theme.fg("text", summaryText(count, failed, currentActivity)) + theme.fg("dim", ")");
+    },
+  });
+
+  /**
+   * Clean mode keeps Running/Done rows in the existing tool components. This
+   * avoids waiting for agent_end (which can be followed by retry/compaction),
+   * leaves a visible count between calls, and keeps each row in transcript order.
+   */
+  const cleanToolCall = (theme: any, name: string, toolCallId: string): Component => {
+    knownToolCallIds.add(toolCallId);
+    return {
+      render(width: number): string[] {
+        if (renderMode !== "clean") return [];
+
+        const settledSummary = settledSummaries.get(toolCallId);
+        if (settledSummary) {
+          return block([summaryRow(theme, settledSummary.count, settledSummary.failed, settledSummary.activity)]).render(width);
+        }
+        if (cleanRun.settled) return [];
+
+        if (cleanRun.activeToolCallId === toolCallId) {
+          return block([summaryRow(
+            theme,
+            cleanRun.count + 1,
+            cleanRun.failed,
+            () => cleanRun.activeToolName ?? name,
+          )]).render(width);
+        }
+
+        // The active tool owns the live Running row. Keep the latest completed
+        // portion hidden while that tool's minimum display time is running.
+        if (
+          cleanRun.lastCompletedToolCallId === toolCallId &&
+          cleanRun.count > 0 &&
+          !cleanRun.activeToolCallId
+        ) {
+          return block([summaryRow(theme, cleanRun.count, cleanRun.failed, currentCleanActivity)]).render(width);
+        }
+
+        // Do not fall back to the per-component pending state here: Pi may
+        // create several tool-call components before execution starts, and
+        // showing that fallback would briefly expose all of them. The active
+        // component is selected to render the current Running row at execution start.
+        return [];
+      },
+      invalidate() {},
+    };
+  };
+
+  const hiddenToolResult = (context: any, options: any, output: string): Component => {
+    if (options.isPartial) setStatus(context, "running");
+    else completeStatus(context, output);
+    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.
+  const hideCleanTool = (
+    _toolCallId: string,
+    expanded: boolean,
+    _executionStarted = false,
+  ): boolean => renderMode === "clean" && !expanded;
+
+  pi.registerEntryRenderer<ToolSummaryData>("pretty-tui-tool-summary", (entry, { expanded }, theme) => ({
+    render(width: number): string[] {
+      if (renderMode !== "clean" || expanded) return [];
+      const data = entry.data;
+      const groups = data?.groups?.length
+        ? data.groups
+        : data?.lastToolCallId
+          ? [{
+              count: data.count ?? 0,
+              failed: data.failed ?? 0,
+              lastToolCallId: data.lastToolCallId,
+            }]
+          : (() => {
+              const summaryCallId = legacySummaryLastToolCallIds.get(entry.id);
+              return summaryCallId
+                ? [{
+                    count: data?.count ?? 0,
+                    failed: data?.failed ?? 0,
+                    lastToolCallId: summaryCallId,
+                  }]
+                : [];
+            })();
+      // The live tool components own the visual positions. Keep this durable
+      // entry as a fallback only for groups whose tool components are absent
+      // from the current branch (for example, after compaction).
+      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.
+      return block(missingGroups.map((group) =>
+        summaryRow(theme, group.count, group.failed, "done")
+      )).render(width);
+    },
+    invalidate() {},
+  }));
+
+  pi.on("session_start", (_event, ctx) => {
+    cleanToolsExpanded = ctx.ui.getToolsExpanded();
+    settledSummaries.clear();
+    legacySummaryLastToolCallIds.clear();
+    clearToolActivityHolds();
+    cleanRun.requestRender = undefined;
+    cleanRun.count = 0;
+    cleanRun.failed = 0;
+    cleanRun.groups = [];
+    cleanRun.activeToolCallId = undefined;
+    cleanRun.activeToolName = undefined;
+    cleanRun.lastCompletedToolCallId = undefined;
+    cleanRun.activity = undefined;
+    cleanRun.active = false;
+    cleanRun.settled = false;
+
+    let count = 0;
+    let failed = 0;
+    let lastToolCallId: string | undefined;
+    let lastFinishedGroup: ToolSummaryGroup | undefined;
+    const toolCalls = new Set<string>();
+    const explicitSummaryIds = new Set<string>();
+
+    const rememberGroup = (group: ToolSummaryGroup, entryId?: string) => {
+      settledSummaries.set(group.lastToolCallId, {
+        count: group.count,
+        failed: group.failed,
+        activity: "done",
+      });
+      if (entryId) legacySummaryLastToolCallIds.set(entryId, group.lastToolCallId);
+      explicitSummaryIds.add(group.lastToolCallId);
+    };
+
+    const finishGroup = () => {
+      if (lastToolCallId && count > 0) {
+        lastFinishedGroup = { count, failed, lastToolCallId };
+        if (!explicitSummaryIds.has(lastToolCallId)) {
+          settledSummaries.set(lastToolCallId, { count, failed, activity: "done" });
+        }
+      }
+      count = 0;
+      failed = 0;
+      lastToolCallId = undefined;
+      toolCalls.clear();
+    };
+
+    // Use the same compaction-aware branch that Pi renders in the transcript;
+    // getEntries() can also contain entries from other branches.
+    for (const entry of ctx.sessionManager.buildContextEntries()) {
+      if (entry.type === "custom" && entry.customType === "pretty-tui-tool-summary") {
+        const data = entry.data as ToolSummaryData | undefined;
+        if (data?.groups?.length) {
+          for (const group of data.groups) {
+            if (group?.lastToolCallId && group.count > 0) rememberGroup(group);
+          }
+        } else if (data?.lastToolCallId) {
+          rememberGroup({
+            count: data.count ?? 0,
+            failed: data.failed ?? 0,
+            lastToolCallId: data.lastToolCallId,
+          });
+        } else if (lastFinishedGroup) {
+          // Migrate summaries written by the earlier clean-mode versions,
+          // which did not persist the final tool call id. The text message
+          // preceding this entry has already closed the group.
+          rememberGroup({
+            count: data?.count ?? lastFinishedGroup.count,
+            failed: data?.failed ?? lastFinishedGroup.failed,
+            lastToolCallId: lastFinishedGroup.lastToolCallId,
+          }, entry.id);
+        } else if (lastToolCallId && count > 0) {
+          // Also handle a legacy entry inserted before the boundary text.
+          rememberGroup({
+            count: data?.count ?? count,
+            failed: data?.failed ?? failed,
+            lastToolCallId,
+          }, entry.id);
+        }
+        continue;
+      }
+
+      if (entry.type !== "message") continue;
+      const message = entry.message as any;
+
+      if (message.role === "user") {
+        finishGroup();
+        lastFinishedGroup = undefined;
+        continue;
+      }
+
+      if (message.role === "assistant") {
+        const hasVisibleText = (message.content ?? []).some(
+          (item: any) => item.type === "text" && typeof item.text === "string" && item.text.trim().length > 0,
+        );
+        if (hasVisibleText) finishGroup();
+        for (const item of message.content ?? []) {
+          if (item.type !== "toolCall" || !supportedTools.has(item.name)) continue;
+          count++;
+          lastToolCallId = item.id;
+          toolCalls.add(item.id);
+        }
+        continue;
+      }
+
+      if (message.role === "toolResult" && toolCalls.has(message.toolCallId) && message.isError) {
+        failed++;
+      }
+    }
+
+    finishGroup();
+  });
+
+  const hasVisibleAssistantText = (message: any): boolean =>
+    message?.role === "assistant" && (message.content ?? []).some(
+      (item: any) => item.type === "text" && typeof item.text === "string" && item.text.trim().length > 0,
+    );
+
+  const latestPendingToolCall = (message: any): any =>
+    [...(message?.content ?? [])].reverse().find(
+      (item: any) => item.type === "toolCall" && supportedTools.has(item.name) && item.id,
+    );
+
+  const trackPendingToolActivity = (message: any): boolean => {
+    const toolCall = latestPendingToolCall(message);
+    if (!toolCall || cleanRun.lastCompletedToolCallId === toolCall.id) return false;
+    cleanRun.active = true;
+    cleanRun.activeToolCallId = toolCall.id;
+    beginToolActivity(toolCall.id, toolDisplayName(toolCall.name));
+    return true;
+  };
+
+  const clearPendingToolActivities = () => {
+    for (const [toolCallId, hold] of toolActivityHolds) {
+      if (hold.started) continue;
+      if (hold.timer) clearTimeout(hold.timer);
+      toolActivityHolds.delete(toolCallId);
+      if (cleanRun.activeToolCallId === toolCallId) {
+        cleanRun.activeToolCallId = undefined;
+        cleanRun.activeToolName = undefined;
+      }
+    }
+  };
+
+  // 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.
+  pi.on("message_update", (event) => {
+    if (hasVisibleAssistantText(event.message)) {
+      cleanRun.activity = "responding...";
+      finishCleanGroup("responding...");
+      return;
+    }
+    trackPendingToolActivity(event.message);
+  });
+  pi.on("message_end", (event) => {
+    if (hasVisibleAssistantText(event.message)) {
+      cleanRun.activity = "done";
+      finishCleanGroup("done");
+      settleLastCleanGroup();
+      return;
+    }
+    trackPendingToolActivity(event.message);
+  });
+
+  pi.on("agent_start", () => {
+    // A retry can start another low-level agent loop. Keep the accumulated
+    // count until the whole run reaches agent_settled.
+    if (!cleanRun.active) {
+      clearToolActivityHolds();
+      cleanRun.count = 0;
+      cleanRun.failed = 0;
+      cleanRun.groups = [];
+      cleanRun.lastCompletedToolCallId = undefined;
+      cleanRun.settled = false;
+    }
+    cleanRun.active = true;
+    cleanRun.activeToolCallId = undefined;
+    cleanRun.activeToolName = undefined;
+    cleanRun.activity = "thinking...";
+  });
+  pi.on("tool_execution_start", (event) => {
+    if (!supportedTools.has(event.toolName)) return;
+    cleanRun.active = true;
+    cleanRun.activeToolCallId = event.toolCallId;
+    beginToolActivity(event.toolCallId, toolDisplayName(event.toolName), 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);
+    // 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);
+    cleanRun.count++;
+    if (event.isError) cleanRun.failed++;
+    cleanRun.lastCompletedToolCallId = event.toolCallId;
+    if (cleanRun.activeToolCallId === event.toolCallId) {
+      cleanRun.activeToolCallId = undefined;
+      cleanRun.activeToolName = undefined;
+      cleanRun.activity = "thinking...";
+    }
+  });
+  pi.on("agent_end", () => {
+    // No summary is appended here: this event may be followed by an automatic
+    // retry or compaction. The live row remains available until settled.
+    clearPendingToolActivities();
+    cleanRun.activeToolCallId = undefined;
+    cleanRun.activeToolName = undefined;
+    cleanRun.activity = "thinking...";
+  });
+  pi.on("agent_settled", () => {
+    if (cleanRun.settled) return;
+
+    clearPendingToolActivities();
+    // Finalize the last group after retries/compaction have definitely ended.
+    finishCleanGroup("done");
+    for (const group of cleanRun.groups) {
+      group.activity = "done";
+      settledSummaries.set(group.lastToolCallId, {
+        count: group.count,
+        failed: group.failed,
+        activity: activityValueForHold(group.lastToolCallId, "done"),
+      });
+    }
+    cleanRun.active = false;
+    cleanRun.activeToolCallId = undefined;
+    cleanRun.activeToolName = undefined;
+    cleanRun.activity = "done";
+    cleanRun.settled = true;
+
+    const groups = cleanRun.groups.slice();
+    if (renderMode !== "clean" || groups.length === 0) return;
+
+    const count = groups.reduce((total, group) => total + group.count, 0);
+    const failed = groups.reduce((total, group) => total + group.failed, 0);
+    const lastToolCallId = groups[groups.length - 1]?.lastToolCallId;
+    pi.appendEntry<ToolSummaryData>("pretty-tui-tool-summary", {
+      count,
+      failed,
+      lastToolCallId,
+      groups: groups.map(({ count, failed, lastToolCallId }) => ({ count, failed, lastToolCallId })),
+    });
+  });
+
   const read = createReadTool(cwd);
   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);
       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);
     },
     renderResult(toolResult: any, options: any, theme: any, context: any) {
-      if (options.isPartial) return partialResult(context, theme, "Reading…");
       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);
       if (image) return result(theme, "Read image", "", false, failed);
@@ -299,11 +1105,28 @@ export default function prettyTui(pi: ExtensionAPI) {
     ...bash,
     renderShell: "self",
     renderCall(args: any, theme: any, context: any) {
+      if (hideCleanTool(context.toolCallId, context.expanded, context.executionStarted)) return cleanToolCall(theme, "Bash", context.toolCallId);
       const command = typeof args.command === "string" ? args.command : "";
+      if (renderMode === "compact" && !context.expanded) {
+        const commandLines = command.split(/\r\n|\r|\n/);
+        const firstLine = commandLines[0] ?? "";
+        const omitted = commandLines.length - 1;
+        const detail = omitted > 0
+          ? `${firstLine} … (${omitted} more ${omitted === 1 ? "line" : "lines"})`
+          : firstLine;
+        return call(theme, "Bash", detail, context.state);
+      }
       return call(theme, "Bash", 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 (renderMode === "compact" && !options.expanded) {
+        if (options.isPartial) return partialResult(context, theme, "Running…");
+        const failed = completeStatus(context, output);
+        return result(theme, failed ? "Command failed" : "Done", "", false, failed);
+      }
+
       if (options.isPartial) {
         return bashResult(context, theme, "Running…", output, options.expanded, "running");
       }
@@ -332,12 +1155,14 @@ export default function prettyTui(pi: ExtensionAPI) {
     ...edit,
     renderShell: "self",
     renderCall(args: any, theme: any, context: any) {
+      if (hideCleanTool(context.toolCallId, context.expanded, context.executionStarted)) return cleanToolCall(theme, "Edit", context.toolCallId);
       const count = Array.isArray(args.edits) ? ` · ${args.edits.length} changes` : "";
       return call(theme, "Edit", `${args.path}${count}`, context.state);
     },
     renderResult(toolResult: any, options: any, theme: any, context: any) {
-      if (options.isPartial) return partialResult(context, theme, "Editing…");
       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 diff = toolResult.details?.diff ?? "";
       const additions = diff.split("\n").filter((line: string) => line.startsWith("+") && !line.startsWith("+++")).length;
@@ -371,12 +1196,21 @@ export default function prettyTui(pi: ExtensionAPI) {
     ...write,
     renderShell: "self",
     renderCall(args: any, theme: any, context: any) {
+      if (hideCleanTool(context.toolCallId, context.expanded, context.executionStarted)) return cleanToolCall(theme, "Write", context.toolCallId);
       const content = typeof args.content === "string" ? args.content : "";
-      return writeCall(theme, String(args.path ?? ""), content, context.expanded, context.state);
+      const path = String(args.path ?? "");
+      if (renderMode === "compact" && !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 writeCall(theme, path, content, context.expanded, context.state);
     },
     renderResult(toolResult: any, options: any, theme: any, context: any) {
-      if (options.isPartial) return partialResult(context, theme, "Writing…");
       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);
       return result(
         theme,
@@ -393,13 +1227,15 @@ export default function prettyTui(pi: ExtensionAPI) {
     ...grep,
     renderShell: "self",
     renderCall(args: any, theme: any, context: any) {
+      if (hideCleanTool(context.toolCallId, context.expanded, context.executionStarted)) return cleanToolCall(theme, "Grep", context.toolCallId);
       const where = args.path ? ` · ${args.path}` : "";
       const glob = args.glob ? ` · ${args.glob}` : "";
       return call(theme, "Grep", `${args.pattern}${where}${glob}`, context.state);
     },
     renderResult(toolResult: any, options: any, theme: any, context: any) {
-      if (options.isPartial) return partialResult(context, theme, "Searching…");
       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 matches = nonEmptyLines(output);
       return result(theme, failed ? output.split("\n")[0] : `Found ${matches} matches`, output, options.expanded, failed);
@@ -411,11 +1247,13 @@ export default function prettyTui(pi: ExtensionAPI) {
     ...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);
     },
     renderResult(toolResult: any, options: any, theme: any, context: any) {
-      if (options.isPartial) return partialResult(context, theme, "Searching…");
       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 matches = nonEmptyLines(output);
       return result(theme, failed ? output.split("\n")[0] : `Found ${matches} paths`, output, options.expanded, failed);
@@ -427,11 +1265,13 @@ export default function prettyTui(pi: ExtensionAPI) {
     ...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);
     },
     renderResult(toolResult: any, options: any, theme: any, context: any) {
-      if (options.isPartial) return partialResult(context, theme, "Listing…");
       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 entries = nonEmptyLines(output);
       return result(theme, failed ? output.split("\n")[0] : `Listed ${entries} entries`, output, options.expanded, failed);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-pretty-tui",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Polished tool calls and list rendering for the Pi coding agent TUI",
   "license": "MIT",
   "author": "Kainan Yang <ykn0309@whu.edu.cn>",
@@ -40,6 +40,6 @@
     "extensions": [
       "./extensions/index.ts"
     ],
-    "image": "https://unpkg.com/pi-pretty-tui@0.1.3/assets/screenshot.png"
+    "image": "https://unpkg.com/pi-pretty-tui@0.1.4/assets/screenshot.png"
   }
 }