@quandev104/pi-style 0.1.7 → 0.2.1

package/extension-src/pi-style/features/tools/boxed/batch.ts

@@ -8,10 +8,10 @@
 // consume no vertical space.
 //
 // Design notes:
-// - No caching in the batch panel: it reads the module-level registry on every
-//   render, so member completions (which trigger ui.requestRender via Pi's
-//   tool_execution_end handler) are picked up without cross-component
-//   invalidation plumbing.
+// - Live batches render directly from the registry so member completions (which
+//   trigger ui.requestRender via Pi's tool_execution_end handler) are picked up
+//   without cross-component invalidation plumbing. Once a batch is finalized,
+//   width/config-stable renders reuse the cached line array.
 // - Batch boundaries: a new batch starts when the active batch is closed. The
 //   active batch closes when a non-batchable tool call is dispatched
 //   (boxed/index.ts), when a new message starts (pi/index.ts), and on session
@@ -31,7 +31,7 @@
 
 import type { Component } from "@earendil-works/pi-tui";
 import { stripAnsi } from "../../../shared/ansi.js";
-import { type BoxTheme, dimLine, formatToolTitlePrefix } from "../../../shared/box.js";
+import { type BoxTheme, dimLine, formatToolTitlePrefix, themeCacheKey } from "../../../shared/box.js";
 import { safeTruncateToWidth } from "../../../shared/render-budget.js";
 import {
 	fileIcon,
@@ -42,7 +42,7 @@ import {
 	TREE_CHILD_INDENT,
 	TREE_INDENT,
 } from "./output-tree.js";
-import { getToolsRenderConfig } from "./session-config.js";
+import { getToolsRenderCacheSignature, getToolsRenderConfig } from "./session-config.js";
 import type { BoxedToolContext } from "./shared.js";
 
 /** Quiet tools whose calls group into a single batch panel. */
@@ -78,6 +78,11 @@ export interface BatchMember {
 	outputEntries?: string[];
 }
 
+type BatchRenderCache = {
+	key: string;
+	lines: string[];
+};
+
 export interface BatchState {
 	readonly meta: BatchToolMeta;
 	readonly leaderId: string;
@@ -85,6 +90,8 @@ export interface BatchState {
 	completedAt?: number;
 	closed: boolean;
 	readonly members: BatchMember[];
+	revision: number;
+	renderCache?: BatchRenderCache;
 }
 
 /** Tree head limit: only the first few members are listed, the rest collapse. */
@@ -130,6 +137,7 @@ function createBatch(
 		leaderId,
 		startedAt: performance.now(),
 		closed: false,
+		revision: 0,
 		members: [
 			{
 				toolCallId: leaderId,
@@ -146,6 +154,11 @@ function createBatch(
 	return batch;
 }
 
+function bumpBatchRevision(batch: BatchState): void {
+	batch.revision++;
+	delete batch.renderCache;
+}
+
 /**
  * Register a call renderer invocation. Idempotent per toolCallId: re-fires
  * (updateDisplay on the same component) reuse the call's existing batch, even
@@ -161,9 +174,12 @@ export function registerBatchCall(
 	if (existing) {
 		const member = existing.members.find((entry) => entry.toolCallId === context.toolCallId);
 		if (member) {
+			const changed =
+				member.detail !== detail || member.pattern !== opts.pattern || member.pathLabel !== opts.pathLabel;
 			member.detail = detail;
 			if (opts.pattern !== undefined) member.pattern = opts.pattern;
 			if (opts.pathLabel !== undefined) member.pathLabel = opts.pathLabel;
+			if (changed) bumpBatchRevision(existing);
 		}
 		return { batch: existing, isLeader: existing.leaderId === context.toolCallId };
 	}
@@ -182,6 +198,7 @@ export function registerBatchCall(
 	};
 	current.members.push(member);
 	batchByCallId.set(context.toolCallId, current);
+	bumpBatchRevision(current);
 	return { batch: current, isLeader: false };
 }
 
@@ -208,14 +225,23 @@ export function registerBatchResult(
 	if (!batch || batch.meta.toolName !== meta.toolName) return { batch: undefined, isLeader: false };
 	const member = batch.members.find((entry) => entry.toolCallId === context.toolCallId);
 	if (member) {
-		member.status = data.isPartial ? "running" : "done";
-		member.isError = !data.isPartial && data.isError;
+		const nextStatus = data.isPartial ? "running" : "done";
+		const nextIsError = !data.isPartial && data.isError;
+		const changed =
+			member.status !== nextStatus ||
+			member.isError !== nextIsError ||
+			member.errorText !== (nextIsError ? data.errorText : undefined) ||
+			member.outputEntries !== data.entries;
+		member.status = nextStatus;
+		member.isError = nextIsError;
 		if (member.isError && data.errorText !== undefined) member.errorText = data.errorText;
 		else delete member.errorText;
 		if (data.entries !== undefined) member.outputEntries = data.entries;
+		if (changed) bumpBatchRevision(batch);
 	}
 	if (batch.completedAt === undefined && batch.members.every((entry) => entry.status === "done")) {
 		batch.completedAt = performance.now();
+		bumpBatchRevision(batch);
 	}
 	return { batch, isLeader: batch.leaderId === context.toolCallId };
 }
@@ -459,9 +485,17 @@ function renderBatchPanelLines(theme: BoxTheme, batch: BatchState, status: Batch
  */
 export function renderBatchAwareCall(theme: BoxTheme, batch: BatchState): Component {
 	return {
-		invalidate() {},
+		invalidate() {
+			delete batch.renderCache;
+		},
 		render(width: number): string[] {
-			return renderBatchPanelLines(theme, batch, batchStatus(batch), width);
+			const status = batchStatus(batch);
+			if (!status.allDone) return renderBatchPanelLines(theme, batch, status, width);
+			const cacheKey = [themeCacheKey(theme), getToolsRenderCacheSignature(), width, batch.revision].join("|");
+			if (batch.renderCache?.key === cacheKey) return batch.renderCache.lines;
+			const lines = renderBatchPanelLines(theme, batch, status, width);
+			batch.renderCache = { key: cacheKey, lines };
+			return lines;
 		},
 	};
 }

package/extension-src/pi-style/features/tools/boxed/edit.ts

@@ -24,6 +24,8 @@ import {
 	type BoxedToolContext,
 	type BoxedToolDefinition,
 	displayPath,
+	getRenderCacheKey,
+	memoizedStateComponent,
 	noteBoxedCallState,
 	noteBoxedResultPhase,
 	noteExecutionStart,
@@ -133,21 +135,34 @@ export const editTool: BoxedToolDefinition = {
 		const diffView = new AdaptiveDiffComponent(theme, rows, maxRows, shouldHighlight ? language : undefined);
 		const expandHint = !expanded && diffView.hasCollapsed() ? "Ctrl+O more" : undefined;
 
-		return renderBoxedToolResult(
-			theme,
-			{
-				render(width: number): string[] {
-					return diffView.render(width);
-				},
-				invalidate(): void {
-					diffView.invalidate();
-				},
-			},
-			{
-				dividerLabel: diffDividerLabel(theme, stats),
-				...(expandHint ? { dividerRightLabel: expandHint } : {}),
-				footerLines: [editDiffFooter(theme, result, context, stats)],
-			},
+		return memoizedStateComponent(
+			context.state,
+			"__piStyleEditDiffResult",
+			getRenderCacheKey(
+				"edit-diff-result",
+				theme,
+				Boolean(expanded),
+				diff,
+				sourcePath ?? "",
+				editDiffFooter(theme, result, context, stats),
+			),
+			() =>
+				renderBoxedToolResult(
+					theme,
+					{
+						render(width: number): string[] {
+							return diffView.render(width);
+						},
+						invalidate(): void {
+							diffView.invalidate();
+						},
+					},
+					{
+						dividerLabel: diffDividerLabel(theme, stats),
+						...(expandHint ? { dividerRightLabel: expandHint } : {}),
+						footerLines: [editDiffFooter(theme, result, context, stats)],
+					},
+				),
 		);
 	},
 };

package/extension-src/pi-style/features/tools/boxed/index.ts

@@ -20,6 +20,7 @@ import type { BoxedToolContext, BoxedToolDefinition } from "./shared.js";
 import {
 	emptyTurnResult,
 	getTurnEntry,
+	isMutatingTool,
 	noteTurnMemberElapsed,
 	noteTurnMemberRender,
 	renderTurnSummaryCall,
@@ -53,12 +54,16 @@ export function hasBoxedRenderer(toolName: unknown): boolean {
 /**
  * Turn-summary gate (ADR 0007): the member belongs to an ended turn, Pi's
  * global tool-output state is collapsed, the surface is enabled, and the block
- * itself is not an error (errors always stay visible).
+ * itself is not an error (errors always stay visible). Mutating tools
+ * (edit/write/…) are exempt unless `tools.collapseMutatingTools` is on — their
+ * blocks are the record of what was done and stay visible by default.
  */
 function collapsedTurnFor(toolCallId: string, expanded: boolean): TurnState | undefined {
-	if (expanded || !getToolsRenderConfig().collapseAfterTurn) return undefined;
+	const config = getToolsRenderConfig();
+	if (expanded || !config.collapseAfterTurn) return undefined;
 	const entry = getTurnEntry(toolCallId);
 	if (!entry?.turn.ended || entry.member.isError) return undefined;
+	if (isMutatingTool(entry.member.toolName) && !config.collapseMutatingTools) return undefined;
 	return entry.turn;
 }
 

package/extension-src/pi-style/features/tools/boxed/quick-edit.ts

@@ -16,6 +16,8 @@ import {
 	type BoxedToolContext,
 	type BoxedToolDefinition,
 	displayPath,
+	getRenderCacheKey,
+	memoizedStateComponent,
 	noteBoxedCallState,
 	noteBoxedResultPhase,
 	noteExecutionStart,
@@ -184,21 +186,35 @@ function renderQuickEditResult(
 	const diffView = new AdaptiveDiffComponent(theme, rows, maxRows, shouldHighlight ? language : undefined);
 	const expandHint = !expanded && diffView.hasCollapsed() ? "Ctrl+O more" : undefined;
 
-	return renderBoxedToolResult(
-		theme,
-		{
-			render(width: number): string[] {
-				return diffView.render(width);
-			},
-			invalidate(): void {
-				diffView.invalidate();
-			},
-		},
-		{
-			dividerLabel: quickEditDividerLabel(theme, stats),
-			...(expandHint ? { dividerRightLabel: expandHint } : {}),
-			footerLines: [quickEditDiffFooter(theme, result, context, stats)],
-		},
+	return memoizedStateComponent(
+		context.state,
+		"__piStyleQuickEditDiffResult",
+		getRenderCacheKey(
+			"quick-edit-diff-result",
+			theme,
+			config.toolLabel,
+			Boolean(expanded),
+			diff,
+			argPath,
+			quickEditDiffFooter(theme, result, context, stats),
+		),
+		() =>
+			renderBoxedToolResult(
+				theme,
+				{
+					render(width: number): string[] {
+						return diffView.render(width);
+					},
+					invalidate(): void {
+						diffView.invalidate();
+					},
+				},
+				{
+					dividerLabel: quickEditDividerLabel(theme, stats),
+					...(expandHint ? { dividerRightLabel: expandHint } : {}),
+					footerLines: [quickEditDiffFooter(theme, result, context, stats)],
+				},
+			),
 	);
 }
 

package/extension-src/pi-style/features/tools/boxed/session-config.ts

@@ -14,6 +14,8 @@ export interface ToolsRenderConfig {
 	nerdFonts: boolean;
 	/** Collapse a completed turn's tool blocks into one summary line (ADR 0007). */
 	collapseAfterTurn: boolean;
+	/** Also collapse mutating tools (edit/write/…) into the summary; off keeps them visible. */
+	collapseMutatingTools: boolean;
 }
 
 let sessionToolsConfig: ToolsRenderConfig = {
@@ -24,6 +26,7 @@ let sessionToolsConfig: ToolsRenderConfig = {
 	batchOpenGlyph: "●",
 	nerdFonts: false,
 	collapseAfterTurn: true,
+	collapseMutatingTools: false,
 };
 
 export function setToolsRenderConfig(config: Partial<ToolsRenderConfig>): void {
@@ -34,6 +37,19 @@ export function getToolsRenderConfig(): ToolsRenderConfig {
 	return sessionToolsConfig;
 }
 
+export function getToolsRenderCacheSignature(): string {
+	return [
+		sessionToolsConfig.maxCollapsedLines,
+		sessionToolsConfig.maxExpandedLines,
+		sessionToolsConfig.dimOutput ? 1 : 0,
+		sessionToolsConfig.showElapsed ? 1 : 0,
+		sessionToolsConfig.batchOpenGlyph,
+		sessionToolsConfig.nerdFonts ? 1 : 0,
+		sessionToolsConfig.collapseAfterTurn ? 1 : 0,
+		sessionToolsConfig.collapseMutatingTools ? 1 : 0,
+	].join("|");
+}
+
 // Wall-clock elapsed tracking through the renderer context state (no tool
 // re-registration, so result.details has no execution timing).
 //
@@ -80,8 +96,26 @@ export function markResultSeen(state: Record<string, unknown> | undefined): void
 
 type TickerHandle = ReturnType<typeof setInterval>;
 
-/** States that currently own a 1s elapsed-render interval, for session cleanup. */
-const tickerStates = new Set<Record<string, unknown>>();
+type ElapsedTickerEntry = {
+	invalidate: () => void;
+};
+
+/** States currently subscribed to the shared elapsed-render ticker. */
+const tickerEntries = new Map<Record<string, unknown>, ElapsedTickerEntry>();
+let sharedTickerHandle: TickerHandle | undefined;
+
+function ensureSharedTicker(): void {
+	if (sharedTickerHandle !== undefined || tickerEntries.size === 0) return;
+	sharedTickerHandle = setInterval(() => {
+		for (const { invalidate } of tickerEntries.values()) invalidate();
+	}, 1000) as unknown as TickerHandle;
+}
+
+function stopSharedTickerIfIdle(): void {
+	if (sharedTickerHandle === undefined || tickerEntries.size > 0) return;
+	clearInterval(sharedTickerHandle);
+	sharedTickerHandle = undefined;
+}
 
 /**
  * While a tool is running, re-render once per second so live elapsed labels
@@ -89,26 +123,26 @@ const tickerStates = new Set<Record<string, unknown>>();
  */
 export function startElapsedTicker(state: Record<string, unknown> | undefined, invalidate: () => void): void {
 	if (!state || typeof state !== "object") return;
-	if (state[TICKER_KEY] !== undefined) return;
-	state[TICKER_KEY] = setInterval(() => invalidate(), 1000) as unknown as TickerHandle;
-	tickerStates.add(state);
+	state[TICKER_KEY] = true;
+	tickerEntries.set(state, { invalidate });
+	ensureSharedTicker();
 }
 
 /** Stop a running tool's elapsed ticker (terminal result, error, session end). */
 export function stopElapsedTicker(state: Record<string, unknown> | undefined): void {
 	if (!state || typeof state !== "object") return;
-	const handle = state[TICKER_KEY] as TickerHandle | undefined;
-	if (handle !== undefined) clearInterval(handle);
 	delete state[TICKER_KEY];
-	tickerStates.delete(state);
+	tickerEntries.delete(state);
+	stopSharedTickerIfIdle();
 }
 
 /** Stop every elapsed ticker (session start/shutdown). */
 export function stopAllElapsedTickers(): void {
-	for (const state of tickerStates) {
-		const handle = state[TICKER_KEY] as TickerHandle | undefined;
-		if (handle !== undefined) clearInterval(handle);
-		delete state[TICKER_KEY];
-	}
-	tickerStates.clear();
+	for (const state of tickerEntries.keys()) delete state[TICKER_KEY];
+	tickerEntries.clear();
+	stopSharedTickerIfIdle();
+}
+
+export function __getElapsedTickerDebugState(): { trackedStates: number; hasSharedTicker: boolean } {
+	return { trackedStates: tickerEntries.size, hasSharedTicker: sharedTickerHandle !== undefined };
 }

package/extension-src/pi-style/features/tools/boxed/shared.ts

@@ -12,9 +12,11 @@ import {
 	renderCompactBoxedToolCall,
 	resolveRelativePath,
 	shortenPath,
+	themeCacheKey,
 } from "../../../shared/box.js";
 import {
 	getStateElapsedMs,
+	getToolsRenderCacheSignature,
 	isResultSeen,
 	markResultSeen,
 	recordExecutionEnded,
@@ -174,6 +176,29 @@ export function resultFooterLines(
 	return [formatBoxedFooter(theme, result, extraParts, stateElapsedMs(context))];
 }
 
+type StateComponentCacheEntry = {
+	key: string;
+	component: Component;
+};
+
+export function getRenderCacheKey(prefix: string, theme: BoxTheme, ...parts: Array<string | number | boolean>): string {
+	return [prefix, themeCacheKey(theme), getToolsRenderCacheSignature(), ...parts].join("|");
+}
+
+export function memoizedStateComponent(
+	state: Record<string, unknown> | undefined,
+	slot: string,
+	key: string,
+	build: () => Component,
+): Component {
+	if (!state || typeof state !== "object") return build();
+	const cached = state[slot] as StateComponentCacheEntry | undefined;
+	if (cached && cached.key === key) return cached.component;
+	const component = build();
+	state[slot] = { key, component } satisfies StateComponentCacheEntry;
+	return component;
+}
+
 export function clearFooterState(context: BoxedToolContext): void {
 	clearCompactBoxedFooter(context.state);
 }

package/extension-src/pi-style/features/tools/boxed/turn-summary.ts

@@ -2,10 +2,18 @@
 //
 // When a turn completes, its finalized tool blocks collapse into a single
 // summary line (`➔ Read 2 files, ran 4 shell commands · 3.1s`) rendered by the
-// turn's leader (its first non-error tool call); every other non-error tool
-// item of the turn renders zero lines. Error results stay visible, interrupted
-// turns never collapse, and Pi's global tool-output toggle (Ctrl+O) expands
-// everything again (`options.expanded` is read, never written).
+// turn's leader (its first non-error tool call that collapses under the render
+// config); every other collapsible tool item of the turn renders zero lines.
+// Error results stay visible, interrupted turns never collapse, and Pi's
+// global tool-output toggle (Ctrl+O) expands everything again
+// (`options.expanded` is read, never written).
+//
+// Mutating tools (edit/write/quick_edit/substitute_edit/target_edit) are
+// exempt from the summary by default (`tools.collapseMutatingTools: off`):
+// their blocks are the record of what was done to the user's files, so they
+// always stay visible (compact preview) even in an ended turn — the summary
+// covers only read-only tools (read/ls/find/grep/bash). Turning the leaf on
+// restores the full collapse.
 //
 // Design notes:
 // - The registry is populated from **session content**, never from runtime
@@ -27,6 +35,7 @@ import type { Component } from "@earendil-works/pi-tui";
 import type { BoxTheme } from "../../../shared/box.js";
 import { safeTruncateToWidth } from "../../../shared/render-budget.js";
 import { pluralForm } from "./output-tree.js";
+import { getToolsRenderConfig } from "./session-config.js";
 
 export interface TurnMemberInfo {
 	readonly toolCallId: string;
@@ -39,12 +48,37 @@ export interface TurnMemberInfo {
 }
 
 export interface TurnState {
-	/** First non-error member; renders the summary line. Empty when every member errored. */
+	/**
+	 * First non-error member that collapses under the current render config
+	 * (mutating members are skipped unless `tools.collapseMutatingTools` is
+	 * on); renders the summary line. Empty when every member errored or when
+	 * the turn's members are all mutating with the exemption active (such a
+	 * turn collapses nothing).
+	 */
 	leaderId: string;
 	ended: boolean;
 	members: readonly TurnMemberInfo[];
 }
 
+/**
+ * Tools that change the user's files. Their blocks are the record of what was
+ * done — they stay visible after the turn and are excluded from the summary
+ * unless `tools.collapseMutatingTools` is on. bash is deliberately NOT here:
+ * read-only and mutating commands are indistinguishable without parsing the
+ * command text.
+ */
+const MUTATING_TOOLS: ReadonlySet<string> = new Set(["edit", "write", "quick_edit", "substitute_edit", "target_edit"]);
+
+/** Whether the tool changes the user's files (exempt from turn collapse). */
+export function isMutatingTool(toolName: string): boolean {
+	return MUTATING_TOOLS.has(toolName);
+}
+
+/** Whether the summary should also cover mutating tools (render config). */
+function mutatingCollapses(): boolean {
+	return getToolsRenderConfig().collapseMutatingTools;
+}
+
 interface TurnEntry {
 	readonly turn: TurnState;
 	readonly member: TurnMemberInfo;
@@ -96,7 +130,7 @@ function registerTurn(
 			isError: isErrorById.get(toolCallId) === true,
 		};
 	});
-	const leader = members.find((member) => !member.isError);
+	const leader = members.find((member) => !member.isError && (!isMutatingTool(member.toolName) || mutatingCollapses()));
 	const turn: TurnState = {
 		leaderId: leader?.toolCallId ?? "",
 		ended: ended && complete,
@@ -145,7 +179,9 @@ export function registerTurnFromMessage(message: unknown, toolResults: readonly
 			isError: isErrorById.get(toolCallId) === true,
 		};
 	});
-	const leader = newMembers.find((member) => !member.isError);
+	const leader = newMembers.find(
+		(member) => !member.isError && (!isMutatingTool(member.toolName) || mutatingCollapses()),
+	);
 	if (!currentRun) {
 		currentRun = {
 			leaderId: leader?.toolCallId ?? "",
@@ -303,17 +339,24 @@ export interface TurnSummaryParts {
 	readonly elapsedMs: number | undefined;
 }
 
-/** Aggregate a turn's non-error members into summary parts (pure). */
+/**
+ * Aggregate a turn's collapsed members into summary parts (pure). Mutating
+ * members are excluded unless `tools.collapseMutatingTools` is on — by default
+ * their visible blocks are the record; the summary describes only what it
+ * hides.
+ */
 export function turnSummaryParts(turn: TurnState): TurnSummaryParts {
 	const counts = new Map<string, number>();
 	const order: string[] = [];
 	let failedCount = 0;
 	let elapsedMs: number | undefined;
+	const collapseMutating = mutatingCollapses();
 	for (const member of turn.members) {
 		if (member.isError) {
 			failedCount++;
 			continue;
 		}
+		if (!collapseMutating && isMutatingTool(member.toolName)) continue;
 		if (member.elapsedMs !== undefined) elapsedMs = (elapsedMs ?? 0) + member.elapsedMs;
 		const existing = counts.get(member.toolName);
 		if (existing === undefined) {
@@ -323,8 +366,10 @@ export function turnSummaryParts(turn: TurnState): TurnSummaryParts {
 	}
 	const parts = order.map((toolName) => {
 		const count = counts.get(toolName) ?? 0;
-		const style = TURN_SUMMARY_STYLE[toolName] ?? { verb: "ran", unit: `${toolName} call` };
-		return `${style.verb} ${count} ${pluralForm(style.unit, count)}`;
+		const style = TURN_SUMMARY_STYLE[toolName];
+		// Unknown tools (extension tools like TaskCreate/ask_user_question) use a
+		// neutral phrasing with the invariant tool name: `used 5 TaskCreate`.
+		return style ? `${style.verb} ${count} ${pluralForm(style.unit, count)}` : `used ${count} ${toolName}`;
 	});
 	return { parts, failedCount, elapsedMs };
 }
@@ -337,7 +382,7 @@ function formatTurnSummaryLine(theme: BoxTheme, turn: TurnState): string {
 	const parts = summary.parts.join(", ");
 	let line = `${theme.fg("dim", `➔ ${parts}`)}`;
 	if (summary.failedCount > 0)
-		line += theme.fg("error", ` · ${summary.failedCount} ${pluralForm("failed", summary.failedCount)}`);
+		line += theme.fg("error", ` · ${summary.failedCount} ${pluralForm("failure", summary.failedCount)}`);
 	if (summary.elapsedMs !== undefined) line += theme.fg("dim", ` · ${(summary.elapsedMs / 1000).toFixed(2)}s`);
 	return line;
 }

package/extension-src/pi-style/features/tools/index.ts

@@ -423,16 +423,31 @@ export function createToolDecorationOwner(snapshot: Partial<ToolDecorationSnapsh
 				if (typeof renderer !== "function") {
 					neutralizeToolContainerBackground(instance);
 					if (subtype === "tool-call-renderer")
-						return (callArgs: unknown, theme: unknown, context: unknown) =>
-							renderBoxedToolCall(toolName, callArgs as Record<string, unknown>, theme as never, context as never);
-					return (result: unknown, options: unknown, theme: unknown, context: unknown) =>
-						renderBoxedToolResult(
+						return (callArgs: unknown, theme: unknown, context: unknown) => {
+							const component = renderBoxedToolCall(
+								toolName,
+								callArgs as Record<string, unknown>,
+								theme as never,
+								context as never,
+							);
+							// Same batch-member contract as the native-renderer path: a
+							// collapsed turn member (or quiet batch member) returns the
+							// singleton and must be hidden, or Pi leaves a stray native
+							// placeholder row per block after the collapse.
+							if (component === EMPTY_BATCH_COMPONENT) hideBatchMember(instance);
+							return component;
+						};
+					return (result: unknown, options: unknown, theme: unknown, context: unknown) => {
+						const component = renderBoxedToolResult(
 							toolName,
 							result as { content?: readonly unknown[]; details?: unknown },
 							options as { expanded: boolean; isPartial: boolean },
 							theme as never,
 							context as never,
 						);
+						if (component === EMPTY_BATCH_COMPONENT) hideBatchMember(instance);
+						return component;
+					};
 				}
 				return function (this: unknown, ...rendererArgs: unknown[]) {
 					const valid = subtype === "tool-call-renderer" ? validCallArgs(rendererArgs) : validResultArgs(rendererArgs);

package/extension-src/pi-style/pi/compatibility-probe.ts

@@ -145,7 +145,7 @@ export const KNOWN_NATIVE_IDENTITIES: Readonly<Record<string, readonly KnownNati
 /** Primary (first-recorded) fingerprint per surface, for diagnostics and back-compat. */
 export const TRUSTED_NATIVE_FINGERPRINTS: Readonly<Record<string, string>> = Object.freeze(
 	Object.fromEntries(
-		Object.entries(KNOWN_NATIVE_IDENTITIES).map(([key, identities]) => [key, identities[0]!.fingerprint]),
+		Object.entries(KNOWN_NATIVE_IDENTITIES).map(([key, identities]) => [key, identities[0]?.fingerprint ?? ""]),
 	),
 );