@pi-kaush/pi-tool-call-markers 0.1.1 → 0.1.3

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## Unreleased
+
+- 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.
+- Wait for every tool in a batch to settle, including tools beyond failed or expanded siblings.
+- Preserve partial and image-bearing results instead of collapsing them.
+- Treat self-rendered tools as owning their full shell and use only their stable header line in grouped summaries.
+
 ## 0.1.1
 
 - Wait for every call in a contiguous parallel run to settle before grouping successful calls, which prevents completed prefixes and suffixes from repeatedly collapsing around active calls.

package/README.md

@@ -7,13 +7,20 @@ 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.
-- **Parallel runs settle before grouping.** A contiguous run stays ungrouped while any call is active. After every call settles, successful calls group around visible thinking or text and failed-call boundaries.
-- **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.
+- **One-line, width-safe summaries.** Long targets truncate before their useful outcome tail instead of wrapping into taller blocks.
+- **Tool batches settle before grouping.** A tool batch stays ungrouped while any sibling call is active. Earlier groups remain stable while a later batch runs, then visually adjacent settled calls merge 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 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
 
@@ -26,20 +33,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.1",
-  "description": "Collapse adjacent successful tool calls into one compact, gear-headed block per tool type in Pi's transcript.",
+  "version": "0.1.3",
+  "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;
 
@@ -47,7 +45,11 @@ type ToolExecutionRow = {
   args?: unknown;
   expanded?: boolean;
   isPartial?: boolean;
-  result?: { isError?: boolean };
+  result?: {
+    isError?: boolean;
+    content?: Array<{ type?: unknown; text?: unknown }>;
+    details?: Record<string, unknown>;
+  };
   contentBox?: ComponentContainer;
   contentText?: TextComponent;
   selfRenderContainer?: ComponentContainer;
@@ -84,25 +86,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, "");
 }
@@ -203,17 +186,27 @@ function hideResultImages(row: ToolExecutionRow): void {
   row.imageSpacers = [];
 }
 
-function collapseSuccessfulResult(row: ToolExecutionRow): void {
-  if (row.expanded !== false || !row.result || row.result.isError) return;
+function collapseSuccessfulResult(
+  row: ToolExecutionRow,
+  theme?: ThemeLike,
+): void {
+  if (
+    row.expanded !== false ||
+    row.isPartial !== false ||
+    !row.result ||
+    row.result.isError ||
+    hasImageResult(row) ||
+    row.getRenderShell?.() === "self"
+  )
+    return;
 
   const collapsed = row.hasRendererDefinition?.()
-    ? removeResultComponent(
-        row.getRenderShell?.() === "self"
-          ? row.selfRenderContainer
-          : row.contentBox,
-      )
+    ? removeResultComponent(row.contentBox)
     : collapseGenericResult(row);
-  if (collapsed) hideResultImages(row);
+  if (collapsed) {
+    hideResultImages(row);
+    decorateSuccessfulCall(row, theme);
+  }
 }
 
 function isToolExecutionRow(
@@ -222,12 +215,25 @@ function isToolExecutionRow(
   return component instanceof ToolExecutionComponent;
 }
 
+function isAssistantMessageRow(component: unknown): boolean {
+  return component instanceof AssistantMessageComponent;
+}
+
+function hasImageResult(row: ToolExecutionRow): boolean {
+  return (
+    row.result?.content?.some((content) => content.type === "image") === true ||
+    (row.imageComponents?.length ?? 0) > 0 ||
+    (row.imageSpacers?.length ?? 0) > 0
+  );
+}
+
 function isCollapsibleSuccess(row: ToolExecutionRow): boolean {
   return (
     row.expanded === false &&
     row.isPartial === false &&
     !!row.result &&
-    !row.result.isError
+    !row.result.isError &&
+    !hasImageResult(row)
   );
 }
 
@@ -235,7 +241,7 @@ function isSettledToolRow(row: ToolExecutionRow): boolean {
   return row.isPartial === false && !!row.result;
 }
 
-function hasUnsettledToolInGroupRun(
+function hasUnsettledToolInBatch(
   children: unknown[],
   index: number,
   renderAt: (index: number) => string[],
@@ -247,9 +253,9 @@ function hasUnsettledToolInGroupRun(
       candidateIndex += direction
     ) {
       const candidate = children[candidateIndex];
+      if (isAssistantMessageRow(candidate)) break;
       if (isToolExecutionRow(candidate)) {
         if (!isSettledToolRow(candidate)) return true;
-        if (!isCollapsibleSuccess(candidate)) break;
         continue;
       }
       if (renderAt(candidateIndex).some(hasVisibleContent)) break;
@@ -264,39 +270,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 {
@@ -307,6 +280,169 @@ 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":
+      return "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);
@@ -340,11 +476,12 @@ function renderedCallSummary(
     component = row.contentBox.children[0] as ComponentLike | undefined;
   }
 
+  const selfRendered = row.getRenderShell?.() === "self";
   if (component && typeof component.render === "function") {
     const visibleLines = component
       .render(Math.max(1, width))
       .filter(hasVisibleContent);
-    const rendered = visibleLines.slice(0, 3);
+    const rendered = visibleLines.slice(0, selfRendered ? 1 : 3);
     const line = rendered[0];
     if (line) {
       const first = trimRenderedLine(line);
@@ -380,26 +517,30 @@ function renderedCallSummary(
     }
   }
 
+  if (selfRendered) return theme.fg("muted", "(details omitted)");
+
   const fallback = compactArgs(row.args);
   return fallback
     ? theme.fg("accent", fallback)
     : 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(
@@ -422,8 +563,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;
     },
@@ -577,7 +719,7 @@ function renderContainerWithToolGroups(
       lines.push(...renderAt(index));
       continue;
     }
-    if (hasUnsettledToolInGroupRun(children, index, renderAt)) {
+    if (hasUnsettledToolInBatch(children, index, renderAt)) {
       lines.push(...renderAt(index));
       continue;
     }
@@ -590,6 +732,10 @@ function renderContainerWithToolGroups(
       candidateIndex++
     ) {
       const candidate = children[candidateIndex];
+      if (isAssistantMessageRow(candidate)) {
+        if (renderAt(candidateIndex).some(hasVisibleContent)) break;
+        continue;
+      }
       if (isToolExecutionRow(candidate)) {
         if (!isCollapsibleSuccess(candidate)) break;
         group.push(candidate);
@@ -612,69 +758,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 {
@@ -776,11 +859,7 @@ function installPresentationPatch(): PresentationPatchState | undefined {
       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);
+        collapseSuccessfulResult(this, state.theme);
       } catch {
         // Presentation is cosmetic; preserve Pi's renderer if its internals change.
       }
@@ -843,7 +922,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;
@@ -851,7 +929,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));
+}