@pi-kaush/pi-tool-call-markers 0.1.2 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## Unreleased
+
+- Compose capped in-progress rows before the Box paints its background, fixing elapsed tails leaking outside the tool background and restoring the block's bottom padding.
+
+- Render in-progress calls as a single header line (elapsed time inline for `bash`) that settles into the final summary at the same height, so the transcript flows downwards without jumping.
+- Show the real duration in successful bash summaries (`→ done · 2.3s`) instead of dropping the elapsed time on completion.
+- Keep a call's settled shape stable once rendered: batches that settle next to an active sibling stay as individual one-liners instead of regrouping afterwards, which removes the second jump when a parallel batch completes.
+- Only invalidate grouped-render caches on real state transitions, so bash's per-second ticks and resize invalidations stop busting them.
+
+- Keep failed calls collapsed by default while retaining their native error background and Ctrl+O expansion.
+- Add compact result tails for common successful tools in singleton and grouped summaries.
+- Keep grouped bullets to one line and preserve the useful result tail on narrow terminals.
+- Merge settled calls across assistant turns when no visible prose separates them, without reopening earlier groups while a later batch is active.
+- Move adjacent thinking-block merging to a separate extension entrypoint bundled in this package.
+
 ## 0.1.2
 
 - Keep grouping within one assistant tool batch, so a later pending batch does not reopen completed groups.

package/README.md

@@ -7,15 +7,21 @@ Collapse Pi's adjacent successful tool calls into one compact, gear-headed block
 When several tool calls of the same type succeed in a row, Pi normally renders each one as its own expanded block. This extension groups them:
 
 - **One gear header per contiguous tool type.** A run of `read` calls shares a single `⚙️ read` header; the following `write` run gets its own `⚙️ write` header.
-- **Bulleted call summaries.** Each call in a group becomes one bullet with a short summary (the tool name is stripped from the bullet since the header already names the tool).
+- **Bulleted call summaries.** Each call in a group becomes one bullet with a short summary and, for common tools, a compact outcome such as `→ done`, `→ 42 lines`, or `→ +2/-1`.
 - **Vertical spacing between tool types.** A blank line separates one tool group from the next.
-- **Hanging indent for wrapped bullets.** When a summary wraps, continuation lines align under the bullet text rather than under the gear.
-- **Tool batches settle before grouping.** A tool batch stays ungrouped while any sibling call is active. Completed batches remain stable when a later assistant turn starts, and successful calls group around failed-call boundaries after the batch settles.
+- **One-line, width-safe summaries.** Long targets truncate before their useful outcome tail instead of wrapping into taller blocks.
+- **Running calls stay one line.** While a call streams or executes, it renders as a single header line (with elapsed time inline for `bash`), so the transcript only grows downwards; the same line settles into the final `→ done · 2.3s`-style summary without changing height.
+- **Settled shapes never re-render.** A call's settled shape is decided the first time it renders settled and never changes afterwards. Batches that finish while a sibling is still active stay as individual one-liners instead of regrouping later; batches already settled on first render (e.g. restored history) still merge into groups across assistant turns that rendered no prose.
 - **Self-rendered tools keep their shell.** Tools that own their framing keep singleton previews intact. Grouped summaries use only their stable header instead of scraping preview or diff lines.
-- **Partial and image results stay visible.** Streaming progress and image-bearing results are not collapsed into text-only groups.
-- **Errors expand in place.** A failed call keeps its own block and shows its full detail.
-- **Ctrl+O restores full blocks.** Expanding tools (`setToolsExpanded(true)`) brings back Pi's individual full blocks, results and all.
-- **Adjacent thinking blocks combine.** Only directly adjacent `thinking` blocks merge into one; a non-thinking block between them keeps them separate. Malformed thinking content safely falls back to Pi's renderer exactly once, so the display never breaks.
+- **Image results stay visible.** Image-bearing results are not collapsed into text-only groups. Partial text output is held back while a call runs and surfaces through the final summary.
+- **Errors stay compact and visibly failed.** A failed call keeps its own error-colored block and native collapsed detail until expanded.
+- **Ctrl+O restores full blocks.** Expanding tools (`setToolsExpanded(true)`) brings back Pi's individual full blocks, including complete error details and successful results.
+
+## Bundled thinking-block extension
+
+The package ships a second extension entrypoint, `src/thinking-block-merger.ts`. Pi loads it independently from the tool presentation extension, so its `AssistantMessageComponent` patch and shutdown lifecycle stay isolated while install, update, and removal remain one package operation.
+
+It combines only directly adjacent `thinking` blocks for display. Tool calls, text, and other content remain boundaries; provider blocks and signatures are not modified.
 
 ## Install
 
@@ -28,20 +34,23 @@ pi install npm:@pi-kaush/pi-tool-call-markers@0.1.0
 For local development:
 
 ```bash
-pi -e ./extensions/pi-tool-call-markers/src/index.ts
+pi \
+  -e ./extensions/pi-tool-call-markers/src/index.ts \
+  -e ./extensions/pi-tool-call-markers/src/thinking-block-merger.ts
 ```
 
 ## Compatibility and risk
 
-This extension currently relies on **guarded, reversible prototype patches** against a small number of Pi component classes:
+The tool presentation entrypoint currently relies on **guarded, reversible prototype patches** against two Pi component classes:
 
 - `ToolExecutionComponent` (render + display presentation),
-- `Container` (transcript grouping), and
-- `AssistantMessageComponent` (adjacent thinking merge).
+- `Container` (transcript grouping).
+
+The bundled thinking-block entrypoint separately patches `AssistantMessageComponent.updateContent`. Its patch and lifecycle do not share state with tool presentation.
 
-Pi exposes no public transcript or tool-grouping hook today, so the extension patches those prototypes on `session_start` and restores the originals on `session_shutdown`. Every patch is wrapped in `try`/`catch` with an idempotency guard (`Symbol.for(...)` markers), so if Pi's internals change the extension silently no-ops and Pi's default rendering is preserved.
+Pi exposes no public transcript or tool-grouping hook today, so the extension patches those prototypes and restores the originals on `session_shutdown`. Every patch is wrapped in `try`/`catch` with an idempotency guard (`Symbol.for(...)` markers), so if Pi's internals change the extension silently no-ops and Pi's default rendering is preserved.
 
-**Compatible Pi version:** `@earendil-works/pi-coding-agent` and `@earendil-works/pi-tui` `>=0.80.6`. Because the patches touch internal prototype methods, a future Pi release that renames or restructures those methods can silently disable the grouping until this extension is updated. The extension never broadens the private-API footprint beyond the three classes above, and all original methods are restored on shutdown.
+**Compatible Pi version:** `@earendil-works/pi-coding-agent` and `@earendil-works/pi-tui` `>=0.80.6`. Because the patches touch internal prototype methods, a future Pi release that renames or restructures those methods can silently disable the affected presentation until this package is updated. All original methods are restored on shutdown.
 
 > TODO: migrate to a public Pi tool/transcript rendering API when one becomes available, and remove the prototype patches.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pi-kaush/pi-tool-call-markers",
-  "version": "0.1.2",
-  "description": "Collapse adjacent successful tool calls into one compact, gear-headed block per tool type in Pi's transcript.",
+  "version": "0.2.0",
+  "description": "Compact and group Pi tool calls, with a bundled extension for adjacent thinking blocks.",
   "license": "MIT",
   "author": "Kaushik Gopal",
   "type": "module",
@@ -31,7 +31,8 @@
   ],
   "pi": {
     "extensions": [
-      "./src/index.ts"
+      "./src/index.ts",
+      "./src/thinking-block-merger.ts"
     ]
   },
   "peerDependencies": {

package/src/index.ts

@@ -9,7 +9,6 @@ import {
   sliceByColumn,
   truncateToWidth,
   visibleWidth,
-  wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
 
 const BADGE = " ⚙️";
@@ -17,7 +16,6 @@ const BADGE_WIDTH = visibleWidth(BADGE);
 const PRESENTATION_PATCHED = Symbol.for("kg.pi.toolPresentation.v3");
 const LEGACY_PRESENTATION_PATCHED = Symbol.for("kg.pi.toolPresentation.v2");
 const GROUPING_PATCHED = Symbol.for("kg.pi.toolGrouping.v1");
-const THINKING_GROUPING_PATCHED = Symbol.for("kg.pi.thinkingGrouping.v1");
 const ANSI_RE = /\u001b\[[0-9;]*m/g;
 const BOLD_ON_RE = /\u001b\[1m/g;
 
@@ -49,8 +47,10 @@ type ToolExecutionRow = {
   isPartial?: boolean;
   result?: {
     isError?: boolean;
-    content?: Array<{ type?: unknown }>;
+    content?: Array<{ type?: unknown; text?: unknown }>;
+    details?: Record<string, unknown>;
   };
+  rendererState?: { startedAt?: unknown; endedAt?: unknown };
   contentBox?: ComponentContainer;
   contentText?: TextComponent;
   selfRenderContainer?: ComponentContainer;
@@ -67,6 +67,10 @@ type PresentationPatchState = {
   theme?: ThemeLike;
   groupCache: WeakMap<ToolExecutionRow, GroupRenderCache>;
   rowVersions: WeakMap<ToolExecutionRow, number>;
+  // A row's settled shape is decided the first time it renders settled and
+  // never changes afterwards, so live output only ever grows downwards.
+  rowModes: WeakMap<ToolExecutionRow, "individual" | ToolExecutionRow[]>;
+  rowSignatures: WeakMap<ToolExecutionRow, string>;
   originalRender: (width: number) => string[];
   originalUpdateDisplay: () => void;
   patchedRender?: (width: number) => string[];
@@ -87,25 +91,6 @@ type GroupRenderCache = {
   width: number;
 };
 
-type AssistantMessageLike = {
-  content?: unknown[];
-};
-
-type AssistantMessageRow = {
-  updateContent(message: AssistantMessageLike): void;
-};
-
-type ThinkingGroupingPatchState = {
-  originalUpdateContent: (message: AssistantMessageLike) => void;
-  patchedUpdateContent?: (message: AssistantMessageLike) => void;
-};
-
-type ThinkingContentLike = {
-  type: "thinking";
-  thinking: string;
-  [key: string]: unknown;
-};
-
 function stripAnsi(text: string): string {
   return text.replace(ANSI_RE, "");
 }
@@ -206,7 +191,10 @@ function hideResultImages(row: ToolExecutionRow): void {
   row.imageSpacers = [];
 }
 
-function collapseSuccessfulResult(row: ToolExecutionRow): void {
+function collapseSuccessfulResult(
+  row: ToolExecutionRow,
+  theme?: ThemeLike,
+): void {
   if (
     row.expanded !== false ||
     row.isPartial !== false ||
@@ -220,7 +208,10 @@ function collapseSuccessfulResult(row: ToolExecutionRow): void {
   const collapsed = row.hasRendererDefinition?.()
     ? removeResultComponent(row.contentBox)
     : collapseGenericResult(row);
-  if (collapsed) hideResultImages(row);
+  if (collapsed) {
+    hideResultImages(row);
+    decorateSuccessfulCall(row, theme);
+  }
 }
 
 function isToolExecutionRow(
@@ -241,6 +232,113 @@ function hasImageResult(row: ToolExecutionRow): boolean {
   );
 }
 
+function formatDuration(ms: number): string {
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+
+function bashDurationText(row: ToolExecutionRow): string | undefined {
+  const startedAt = row.rendererState?.startedAt;
+  const endedAt = row.rendererState?.endedAt;
+  if (
+    typeof startedAt !== "number" ||
+    typeof endedAt !== "number" ||
+    !Number.isFinite(startedAt) ||
+    !Number.isFinite(endedAt)
+  )
+    return undefined;
+  return formatDuration(Math.max(0, endedAt - startedAt));
+}
+
+function liveElapsedText(row: ToolExecutionRow): string | undefined {
+  if (row.toolName !== "bash") return undefined;
+  const startedAt = row.rendererState?.startedAt;
+  if (typeof startedAt !== "number" || !Number.isFinite(startedAt))
+    return undefined;
+  return formatDuration(Math.max(0, Date.now() - startedAt));
+}
+
+function isLiveRow(row: ToolExecutionRow): boolean {
+  return (
+    row.expanded === false &&
+    (row.isPartial !== false || !row.result) &&
+    row.getRenderShell?.() !== "self" &&
+    !hasImageResult(row)
+  );
+}
+
+function liveTailText(
+  row: ToolExecutionRow,
+  droppedVisible: boolean,
+  theme?: ThemeLike,
+): string | undefined {
+  if (!theme) return undefined;
+  const elapsed = liveElapsedText(row);
+  if (!droppedVisible && !elapsed) return undefined;
+  const parts: string[] = [];
+  if (droppedVisible) parts.push("…");
+  if (elapsed) parts.push("·", elapsed);
+  return theme.fg("muted", parts.join(" "));
+}
+
+function fitLiveHeader(
+  header: string,
+  tail: string,
+  width: number,
+  droppedVisible: boolean,
+): string {
+  const max = Math.max(1, width);
+  const head = header.trimEnd();
+  if (visibleWidth(head) + visibleWidth(tail) + 1 <= max)
+    return `${head} ${tail}`;
+  const headWidth = Math.max(1, max - visibleWidth(tail) - 1);
+  const headSuffix = droppedVisible ? "" : "…";
+  return `${truncateToWidth(head, headWidth, headSuffix, false)} ${tail}`;
+}
+
+// While a call streams or runs, pin it to a single header line with the
+// elapsed time inline, so the block never grows and never collapses on
+// completion; the header text simply settles into the outcome summary. The
+// cap is composed before the Box applies background and padding, so the live
+// line keeps the tool background edge to edge and the block's bottom padding.
+function capLiveRowDisplay(row: ToolExecutionRow, theme?: ThemeLike): void {
+  if (row.hasRendererDefinition?.()) {
+    const container = row.contentBox;
+    if (!container || !Array.isArray(container.children)) return;
+    const hadExtraChildren = container.children.length > 1;
+    removeResultComponent(container);
+    const original = container.children[0] as ComponentLike | undefined;
+    if (!original || typeof original.render !== "function") return;
+    container.children[0] = {
+      render(width: number): string[] {
+        const lines = original.render(width);
+        const headerIndex = lines.findIndex(hasVisibleContent);
+        if (headerIndex === -1) return lines;
+        const header = lines[headerIndex] ?? "";
+        const droppedVisible =
+          hadExtraChildren ||
+          lines.slice(headerIndex + 1).some(hasVisibleContent);
+        const tail = liveTailText(row, droppedVisible, theme);
+        return [
+          tail ? fitLiveHeader(header, tail, width, droppedVisible) : header,
+        ];
+      },
+      invalidate() {
+        original.invalidate();
+      },
+    };
+    return;
+  }
+
+  const text = row.contentText;
+  if (typeof text?.text !== "string" || typeof text.setText !== "function")
+    return;
+  const lines = text.text.split("\n");
+  const title = lines[0] ?? "";
+  const droppedVisible = lines.slice(1).some((line) => line.trim().length > 0);
+  const tail = liveTailText(row, droppedVisible, theme);
+  text.setText(tail ? `${title} ${tail}` : title);
+}
+
 function isCollapsibleSuccess(row: ToolExecutionRow): boolean {
   return (
     row.expanded === false &&
@@ -284,39 +382,6 @@ function renderComponent(component: unknown, width: number): string[] {
   return (component as ComponentLike).render(width);
 }
 
-function isThinkingContent(content: unknown): content is ThinkingContentLike {
-  return (
-    !!content &&
-    typeof content === "object" &&
-    (content as { type?: unknown }).type === "thinking" &&
-    typeof (content as { thinking?: unknown }).thinking === "string"
-  );
-}
-
-function combineAdjacentThinking(
-  message: AssistantMessageLike,
-): AssistantMessageLike {
-  if (!Array.isArray(message.content)) return message;
-
-  // Merge a display-only copy; the original provider blocks and their signatures stay untouched.
-  let changed = false;
-  const content: unknown[] = [];
-  for (const block of message.content) {
-    const previous = content.at(-1);
-    if (isThinkingContent(previous) && isThinkingContent(block)) {
-      content[content.length - 1] = {
-        ...previous,
-        thinking: `${previous.thinking.trim()}\n\n${block.thinking.trim()}`,
-      };
-      changed = true;
-      continue;
-    }
-    content.push(block);
-  }
-
-  return changed ? { ...message, content } : message;
-}
-
 function compactArgs(args: unknown): string {
   if (args === undefined || args === null) return "";
   try {
@@ -327,6 +392,171 @@ function compactArgs(args: unknown): string {
   }
 }
 
+function resultText(row: ToolExecutionRow): string {
+  const contentText = row.result?.content?.find(
+    (content) => content.type === "text" && typeof content.text === "string",
+  )?.text;
+  if (typeof contentText === "string") return contentText;
+  return row.getTextOutput?.() ?? "";
+}
+
+function textLineCount(text: string): number {
+  if (!text) return 0;
+  const lines = text.split("\n");
+  return text.endsWith("\n") ? lines.length - 1 : lines.length;
+}
+
+function resultCount(row: ToolExecutionRow, text: string): number {
+  const totalMatched = row.result?.details?.totalMatched;
+  if (typeof totalMatched === "number" && Number.isFinite(totalMatched))
+    return Math.max(0, totalMatched);
+
+  const trimmed = text.trim();
+  if (
+    !trimmed ||
+    /^(?:No matches found|No files found|\(empty directory\))/i.test(trimmed)
+  )
+    return 0;
+
+  if (row.toolName === "grep" || row.toolName === "ffgrep") {
+    const lines = trimmed.split("\n");
+    const matches = lines.filter(
+      (line) => /^.+:\d+:/.test(line) || /^\s+\d+:/.test(line),
+    ).length;
+    if (matches > 0) return matches;
+  }
+
+  return trimmed
+    .split("\n")
+    .filter((line) => line.trim() && !/^\s*\[.*\]\s*$/.test(line)).length;
+}
+
+function readLineCount(row: ToolExecutionRow, text: string): number {
+  const outputLines = (
+    row.result?.details?.truncation as { outputLines?: unknown } | undefined
+  )?.outputLines;
+  if (typeof outputLines === "number" && Number.isFinite(outputLines))
+    return Math.max(0, outputLines);
+
+  const content = text.replace(
+    /\n\n\[[^\n]*(?:more lines|showing lines)[^\n]*\]\s*$/i,
+    "",
+  );
+  return textLineCount(content);
+}
+
+function diffCounts(diff: string): { added: number; removed: number } {
+  let added = 0;
+  let removed = 0;
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("+") && !line.startsWith("+++")) added++;
+    if (line.startsWith("-") && !line.startsWith("---")) removed++;
+  }
+  return { added, removed };
+}
+
+function outcomeSummary(row: ToolExecutionRow): string | undefined {
+  if (!isCollapsibleSuccess(row)) return undefined;
+
+  const text = resultText(row);
+  switch (row.toolName) {
+    case "bash": {
+      const duration = bashDurationText(row);
+      return duration ? `done · ${duration}` : "done";
+    }
+    case "read": {
+      const lines = readLineCount(row, text);
+      return `${lines} ${lines === 1 ? "line" : "lines"}`;
+    }
+    case "write": {
+      const content = (row.args as { content?: unknown } | undefined)?.content;
+      if (typeof content !== "string") return "written";
+      const lines = textLineCount(content);
+      return `${lines} ${lines === 1 ? "line" : "lines"}`;
+    }
+    case "edit": {
+      const diff = row.result?.details?.diff;
+      if (typeof diff !== "string") return "applied";
+      const { added, removed } = diffCounts(diff);
+      return `+${added}/-${removed}`;
+    }
+    case "grep":
+    case "ffgrep":
+    case "find":
+    case "fffind":
+    case "ls": {
+      const results = resultCount(row, text);
+      return `${results} ${results === 1 ? "result" : "results"}`;
+    }
+    default:
+      return undefined;
+  }
+}
+
+function renderedOutcome(
+  row: ToolExecutionRow,
+  theme: ThemeLike,
+): string | undefined {
+  const summary = outcomeSummary(row);
+  if (!summary) return undefined;
+  return `${theme.fg("muted", "→")} ${theme.fg("success", summary)}`;
+}
+
+function truncatePlain(text: string, width: number, suffix = "…"): string {
+  const max = Math.max(0, width);
+  const plain = stripAnsi(text);
+  if (visibleWidth(plain) <= max) return plain;
+
+  const suffixWidth = visibleWidth(suffix);
+  if (suffixWidth >= max) return sliceByColumn(suffix, 0, max, true);
+  return `${sliceByColumn(plain, 0, max - suffixWidth, true)}${suffix}`;
+}
+
+function fitSummary(summary: string, width: number): string {
+  const max = Math.max(1, width);
+  return visibleWidth(summary) <= max ? summary : truncatePlain(summary, max);
+}
+
+function fitSummaryTail(head: string, tail: string, width: number): string {
+  const max = Math.max(1, width);
+  const summary = `${head.trimEnd()} ${tail}`;
+  if (visibleWidth(summary) <= max) return summary;
+
+  const tailWidth = visibleWidth(tail);
+  if (tailWidth >= max) return truncatePlain(tail, max);
+  return `${truncatePlain(head, max - tailWidth - 1)} ${tail}`;
+}
+
+function decorateSuccessfulCall(
+  row: ToolExecutionRow,
+  theme?: ThemeLike,
+): void {
+  if (!theme || !Array.isArray(row.contentBox?.children)) return;
+  const original = row.contentBox.children[0] as ComponentLike | undefined;
+  const outcome = renderedOutcome(row, theme);
+  if (!original || typeof original.render !== "function" || !outcome) return;
+
+  row.contentBox.children[0] = {
+    render(width: number): string[] {
+      const lines = original.render(width);
+      const lineIndex = lines.findIndex(hasVisibleContent);
+      if (lineIndex === -1) return lines;
+      const line = lines[lineIndex];
+      if (line === undefined) return lines;
+      const next = [...lines];
+      next[lineIndex] = fitSummaryTail(
+        trimRenderedLine(line),
+        outcome,
+        Math.max(1, width - BADGE_WIDTH),
+      );
+      return next;
+    },
+    invalidate() {
+      original.invalidate();
+    },
+  };
+}
+
 function removeTrailingExpandHint(text: string): string {
   const plain = stripAnsi(text).trimEnd();
   const hint = plain.match(/\s+\([^)]*to expand\)$/i);
@@ -409,20 +639,22 @@ function renderedCallSummary(
     : theme.fg("muted", "(no arguments)");
 }
 
-function wrappedBulletLines(
+function compactBulletLine(
   summary: string,
+  outcome: string | undefined,
   width: number,
   theme: ThemeLike,
-): string[] {
+): string {
   const prefix = `  ${theme.fg("muted", "•")} `;
   const indent = visibleWidth(prefix);
-  if (width <= indent) return [truncateToWidth(prefix, width, "", false)];
-
-  const wrapped = wrapTextWithAnsi(summary, width - indent);
-  return wrapped.map((line, index) => {
-    const linePrefix = index === 0 ? prefix : " ".repeat(indent);
-    return truncateToWidth(linePrefix + line, width, "", false);
-  });
+  if (width <= indent) return truncateToWidth(prefix, width, "", false);
+  const available = width - indent;
+  return (
+    prefix +
+    (outcome
+      ? fitSummaryTail(summary, outcome, available)
+      : fitSummary(summary, available))
+  );
 }
 
 function groupedCallComponent(
@@ -445,8 +677,9 @@ function groupedCallComponent(
           lines.push(truncateToWidth(heading, width, "", false));
           previousToolName = row.toolName;
         }
-        const summary = renderedCallSummary(row, Math.max(1, width - 4), theme);
-        lines.push(...wrappedBulletLines(summary, width, theme));
+        const call = renderedCallSummary(row, Math.max(1, width - 4), theme);
+        const outcome = renderedOutcome(row, theme);
+        lines.push(compactBulletLine(call, outcome, width, theme));
       }
       return lines;
     },
@@ -600,7 +833,41 @@ function renderContainerWithToolGroups(
       lines.push(...renderAt(index));
       continue;
     }
+    const decided = presentation.rowModes.get(child);
+    if (decided === "individual") {
+      lines.push(...renderAt(index));
+      continue;
+    }
+    if (Array.isArray(decided)) {
+      // A decided group is sticky, but transient states like Ctrl+O expansion
+      // still render members in full until they become collapsible again.
+      if (!decided.every(isCollapsibleSuccess)) {
+        lines.push(...renderAt(index));
+        continue;
+      }
+      const lastMember = decided[decided.length - 1];
+      let lastMemberIndex = index;
+      for (
+        let candidateIndex = index + 1;
+        candidateIndex < children.length;
+        candidateIndex++
+      ) {
+        if (children[candidateIndex] === lastMember) {
+          lastMemberIndex = candidateIndex;
+          break;
+        }
+      }
+      lines.push(...renderGroupedToolRows(child, decided, width, presentation));
+      index = lastMemberIndex;
+      continue;
+    }
+
+    // Undecided row: pick its settled shape once. A row that first settles
+    // next to an active sibling stays individual forever, so live batches
+    // never regroup after the fact; only batches that are fully settled on
+    // first render (e.g. restored history) become groups.
     if (hasUnsettledToolInBatch(children, index, renderAt)) {
+      presentation.rowModes.set(child, "individual");
       lines.push(...renderAt(index));
       continue;
     }
@@ -613,9 +880,13 @@ function renderContainerWithToolGroups(
       candidateIndex++
     ) {
       const candidate = children[candidateIndex];
-      if (isAssistantMessageRow(candidate)) break;
+      if (isAssistantMessageRow(candidate)) {
+        if (renderAt(candidateIndex).some(hasVisibleContent)) break;
+        continue;
+      }
       if (isToolExecutionRow(candidate)) {
         if (!isCollapsibleSuccess(candidate)) break;
+        if (presentation.rowModes.has(candidate)) break;
         group.push(candidate);
         lastMemberIndex = candidateIndex;
         continue;
@@ -624,10 +895,12 @@ function renderContainerWithToolGroups(
     }
 
     if (group.length === 1) {
+      presentation.rowModes.set(child, "individual");
       lines.push(...renderAt(index));
       continue;
     }
 
+    for (const member of group) presentation.rowModes.set(member, group);
     lines.push(...renderGroupedToolRows(child, group, width, presentation));
     index = lastMemberIndex;
   }
@@ -636,69 +909,6 @@ function renderContainerWithToolGroups(
 }
 
 // TODO: Replace prototype patching with a public Pi tool/transcript rendering API when available.
-function installThinkingGroupingPatch():
-  | ThinkingGroupingPatchState
-  | undefined {
-  try {
-    const proto =
-      AssistantMessageComponent?.prototype as unknown as AssistantMessageRow & {
-        [THINKING_GROUPING_PATCHED]?: ThinkingGroupingPatchState;
-        updateContent?: (message: AssistantMessageLike) => void;
-      };
-    if (!proto || typeof proto.updateContent !== "function") return undefined;
-
-    const existing = proto[THINKING_GROUPING_PATCHED];
-    if (existing) return existing;
-
-    const state: ThinkingGroupingPatchState = {
-      originalUpdateContent: proto.updateContent,
-    };
-    const patchedUpdateContent = function updateContentWithCombinedThinking(
-      this: AssistantMessageRow,
-      message: AssistantMessageLike,
-    ): void {
-      // Combine adjacent thinking blocks for display, but fall back to the original
-      // message if combining throws. Either way, invoke Pi's renderer exactly once.
-      let combined = message;
-      try {
-        combined = combineAdjacentThinking(message);
-      } catch {
-        // Thinking grouping is cosmetic; preserve the original message intact.
-      }
-      state.originalUpdateContent.call(this, combined);
-    };
-
-    state.patchedUpdateContent = patchedUpdateContent;
-    proto.updateContent = patchedUpdateContent;
-    Object.defineProperty(proto, THINKING_GROUPING_PATCHED, {
-      configurable: true,
-      value: state,
-    });
-    return state;
-  } catch {
-    // Thinking grouping is cosmetic; preserve Pi's renderer if its internals change.
-    return undefined;
-  }
-}
-
-function uninstallThinkingGroupingPatch(
-  state: ThinkingGroupingPatchState | undefined,
-): void {
-  if (!state) return;
-  const proto =
-    AssistantMessageComponent?.prototype as unknown as AssistantMessageRow & {
-      [THINKING_GROUPING_PATCHED]?: ThinkingGroupingPatchState;
-      updateContent?: (message: AssistantMessageLike) => void;
-    };
-  if (
-    proto[THINKING_GROUPING_PATCHED] !== state ||
-    proto.updateContent !== state.patchedUpdateContent
-  )
-    return;
-  proto.updateContent = state.originalUpdateContent;
-  delete proto[THINKING_GROUPING_PATCHED];
-}
-
 function installGroupingPatch(
   presentation: PresentationPatchState,
 ): GroupingPatchState | undefined {
@@ -790,21 +1000,30 @@ function installPresentationPatch(): PresentationPatchState | undefined {
     const state: PresentationPatchState = {
       groupCache: new WeakMap(),
       rowVersions: new WeakMap(),
+      rowModes: new WeakMap(),
+      rowSignatures: new WeakMap(),
       originalRender: proto.render,
       originalUpdateDisplay: proto.updateDisplay,
     };
     const patchedUpdateDisplay = function updateDisplayWithCollapsedResult(
       this: ToolExecutionRow,
     ): void {
-      state.rowVersions.set(this, (state.rowVersions.get(this) ?? 0) + 1);
-      state.groupCache.delete(this);
+      // Group members always bump so their leader's cache refreshes; other
+      // rows only bump on state transitions, so bash's per-second invalidate
+      // ticks and resize invalidations stop busting caches.
+      const signature = `${this.isPartial}|${this.expanded}|${this.result ? 1 : 0}|${this.result?.isError ? 1 : 0}`;
+      if (
+        Array.isArray(state.rowModes.get(this)) ||
+        state.rowSignatures.get(this) !== signature
+      ) {
+        state.rowSignatures.set(this, signature);
+        state.rowVersions.set(this, (state.rowVersions.get(this) ?? 0) + 1);
+        state.groupCache.delete(this);
+      }
       state.originalUpdateDisplay.call(this);
       try {
-        if (this.result?.isError && this.expanded === false) {
-          this.expanded = true;
-          state.originalUpdateDisplay.call(this);
-        }
-        collapseSuccessfulResult(this);
+        if (isLiveRow(this)) capLiveRowDisplay(this, state.theme);
+        else collapseSuccessfulResult(this, state.theme);
       } catch {
         // Presentation is cosmetic; preserve Pi's renderer if its internals change.
       }
@@ -867,7 +1086,6 @@ function uninstallPresentationPatch(
 export default function (pi: ExtensionAPI) {
   const patch = installPresentationPatch();
   const grouping = patch ? installGroupingPatch(patch) : undefined;
-  const thinkingGrouping = installThinkingGroupingPatch();
 
   pi.on("session_start", (_event, ctx) => {
     if (patch) patch.theme = ctx.ui.theme;
@@ -875,7 +1093,6 @@ export default function (pi: ExtensionAPI) {
   });
 
   pi.on("session_shutdown", () => {
-    uninstallThinkingGroupingPatch(thinkingGrouping);
     uninstallGroupingPatch(grouping);
     uninstallPresentationPatch(patch);
   });

package/src/thinking-block-merger.ts

@@ -0,0 +1,123 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { AssistantMessageComponent } from "@earendil-works/pi-coding-agent";
+
+const THINKING_GROUPING_PATCHED = Symbol.for("kg.pi.thinkingGrouping.v1");
+
+type AssistantMessageLike = {
+  content?: unknown[];
+};
+
+type AssistantMessageRow = {
+  updateContent(message: AssistantMessageLike): void;
+};
+
+type ThinkingGroupingPatchState = {
+  originalUpdateContent: (message: AssistantMessageLike) => void;
+  patchedUpdateContent?: (message: AssistantMessageLike) => void;
+};
+
+type ThinkingContentLike = {
+  type: "thinking";
+  thinking: string;
+  [key: string]: unknown;
+};
+
+function isThinkingContent(content: unknown): content is ThinkingContentLike {
+  return (
+    !!content &&
+    typeof content === "object" &&
+    (content as { type?: unknown }).type === "thinking" &&
+    typeof (content as { thinking?: unknown }).thinking === "string"
+  );
+}
+
+function combineAdjacentThinking(
+  message: AssistantMessageLike,
+): AssistantMessageLike {
+  if (!Array.isArray(message.content)) return message;
+
+  // Merge a display-only copy; provider blocks and signatures stay untouched.
+  let changed = false;
+  const content: unknown[] = [];
+  for (const block of message.content) {
+    const previous = content.at(-1);
+    if (isThinkingContent(previous) && isThinkingContent(block)) {
+      content[content.length - 1] = {
+        ...previous,
+        thinking: `${previous.thinking.trim()}\n\n${block.thinking.trim()}`,
+      };
+      changed = true;
+      continue;
+    }
+    content.push(block);
+  }
+
+  return changed ? { ...message, content } : message;
+}
+
+// TODO: Replace prototype patching with a public assistant-message rendering API.
+function installThinkingGroupingPatch():
+  | ThinkingGroupingPatchState
+  | undefined {
+  try {
+    const proto =
+      AssistantMessageComponent?.prototype as unknown as AssistantMessageRow & {
+        [THINKING_GROUPING_PATCHED]?: ThinkingGroupingPatchState;
+        updateContent?: (message: AssistantMessageLike) => void;
+      };
+    if (!proto || typeof proto.updateContent !== "function") return undefined;
+
+    const existing = proto[THINKING_GROUPING_PATCHED];
+    if (existing) return existing;
+
+    const state: ThinkingGroupingPatchState = {
+      originalUpdateContent: proto.updateContent,
+    };
+    const patchedUpdateContent = function updateContentWithCombinedThinking(
+      this: AssistantMessageRow,
+      message: AssistantMessageLike,
+    ): void {
+      // Thinking grouping is cosmetic. If it fails, render the original once.
+      let combined = message;
+      try {
+        combined = combineAdjacentThinking(message);
+      } catch {
+        // Preserve the original message intact.
+      }
+      state.originalUpdateContent.call(this, combined);
+    };
+
+    state.patchedUpdateContent = patchedUpdateContent;
+    proto.updateContent = patchedUpdateContent;
+    Object.defineProperty(proto, THINKING_GROUPING_PATCHED, {
+      configurable: true,
+      value: state,
+    });
+    return state;
+  } catch {
+    return undefined;
+  }
+}
+
+function uninstallThinkingGroupingPatch(
+  state: ThinkingGroupingPatchState | undefined,
+): void {
+  if (!state) return;
+  const proto =
+    AssistantMessageComponent?.prototype as unknown as AssistantMessageRow & {
+      [THINKING_GROUPING_PATCHED]?: ThinkingGroupingPatchState;
+      updateContent?: (message: AssistantMessageLike) => void;
+    };
+  if (
+    proto[THINKING_GROUPING_PATCHED] !== state ||
+    proto.updateContent !== state.patchedUpdateContent
+  )
+    return;
+  proto.updateContent = state.originalUpdateContent;
+  delete proto[THINKING_GROUPING_PATCHED];
+}
+
+export default function (pi: ExtensionAPI) {
+  const patch = installThinkingGroupingPatch();
+  pi.on("session_shutdown", () => uninstallThinkingGroupingPatch(patch));
+}