@quandev104/pi-style 0.2.1 → 0.2.2

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

@@ -188,6 +188,38 @@ function countNewlines(text: string, from: number, to: number): number {
 	return count;
 }
 
+/** Index just past the `need`-th newline counted backwards from `end` (0 when
+ *  the window holds fewer), so only `text.slice(index, end)` needs further
+ *  processing. Plain char scan, no allocation. */
+function findBackwardLineStart(text: string, need: number, end: number = text.length): number {
+	let found = 0;
+	for (let i = end - 1; i >= 0; i--) {
+		if (text.charCodeAt(i) === 10 && ++found >= need) return i + 1;
+	}
+	return 0;
+}
+
+/** Whitespace per `String.prototype.trim` (superset of ASCII blank/line
+ *  terminators); anything else counts as visible output. */
+function isOutputWhitespaceCode(code: number): boolean {
+	if (code === 0x20 || (code >= 0x09 && code <= 0x0d)) return true;
+	if (code === 0x85 || code === 0xa0 || code === 0x1680) return true;
+	if (code >= 0x2000 && code <= 0x200a) return true;
+	return code === 0x2028 || code === 0x2029 || code === 0x202f || code === 0x205f || code === 0x3000 || code === 0xfeff;
+}
+
+/** End index (exclusive) of the last non-whitespace character in `text` — the
+ *  streaming equivalent of `stripAnsi(text).trimEnd()`: trailing blank lines and
+ *  padding never push the visible tail out of the processing window. ANSI
+ *  escape bytes count as non-whitespace; a slice ending inside one still
+ *  strips correctly downstream. */
+function lastVisibleEnd(text: string): number {
+	for (let i = text.length - 1; i >= 0; i--) {
+		if (!isOutputWhitespaceCode(text.charCodeAt(i))) return i + 1;
+	}
+	return 0;
+}
+
 function stripBashToolNoticeLines(text: string): string {
 	const filteredLines = text
 		.replace(/\r/g, "")
@@ -388,8 +420,19 @@ function renderBashStreamingResult(
 	options: { expanded: boolean },
 	context: BoxedToolContext,
 ): Component {
-	const body = stripBashToolNoticeLines(stripAnsi(raw));
-	const hasOutput = body.trim().length > 0;
+	// Tail-only processing: the preview collapses to maxCollapsedLines lines
+	// anyway, so only the last maxCollapsedLines + 10 raw lines (the same headroom
+	// the final collapsed scan uses, covering notice lines stripped from the
+	// tail) get ANSI stripping/truncation work, and trailing blank lines never
+	// push real content out of the window (the raw-string equivalent of the old
+	// whole-buffer stripAnsi + trimEnd). Streaming passes stay O(tail) as the
+	// output grows instead of re-stripping the whole buffer each pass.
+	const contentEnd = lastVisibleEnd(raw);
+	const hasOutput = contentEnd > 0;
+	const tailStart = hasOutput
+		? findBackwardLineStart(raw, getToolsRenderConfig().maxCollapsedLines + 10, contentEnd)
+		: 0;
+	const body = stripBashToolNoticeLines(stripAnsi(raw.slice(tailStart, contentEnd)));
 	const elapsed = getStateElapsedMs(context.state);
 	const emptyLines: string[] = [theme.fg("dim", "No output received yet")];
 	if (!hasOutput && isInteractiveCommand(context?.args?.command) && (elapsed ?? 0) >= 1000) {
@@ -429,17 +472,7 @@ function renderBashFinalResult(
 	if (!options.expanded) {
 		// Collapsed: only process the tail of the output (notices stripped per line).
 		const scanLines = getToolsRenderConfig().maxCollapsedLines + 10;
-		let nlCount = 0;
-		let tailStart = 0;
-		for (let i = statusStripped.length - 1; i >= 0; i--) {
-			if (statusStripped.charCodeAt(i) === 10) {
-				nlCount++;
-				if (nlCount >= scanLines) {
-					tailStart = i + 1;
-					break;
-				}
-			}
-		}
+		const tailStart = findBackwardLineStart(statusStripped, scanLines);
 		const tail = stripBashToolNoticeLines(stripAnsi(statusStripped.slice(tailStart)));
 		const totalLinesBefore = tailStart > 0 ? countNewlines(statusStripped, 0, tailStart) : 0;
 		const preview = createBashResultPreview(theme, tail, options, outputColor);
@@ -508,17 +541,7 @@ function createBashResultPreview(
 			if (!expanded) {
 				// Collapsed: only process the tail of the output
 				const needed = cfg.maxCollapsedLines;
-				let totalNewlines = 0;
-				let scanFrom = 0; // default: take full text if fewer than needed newlines
-				for (let i = text.length - 1; i >= 0; i--) {
-					if (text.charCodeAt(i) === 10) {
-						totalNewlines++;
-						if (totalNewlines === needed) {
-							scanFrom = i + 1;
-							break;
-						}
-					}
-				}
+				const scanFrom = findBackwardLineStart(text, needed); // full text when fewer newlines
 
 				if (text.length === 0) {
 					cacheKey = cacheId;
@@ -548,10 +571,14 @@ function createBashResultPreview(
 				return cacheLines;
 			}
 
-			// Expanded: process all lines
+			// Expanded: only the tail lines the expanded budget can show receive
+			// clamp/truncate/color work; earlier lines collapse into one `… N earlier
+			// lines` head row, so per-line cost scales with maxExpandedLines instead
+			// of the full output.
 			const normalized = replaceTabs(text);
-			const logicalLines = normalized.split("\n").map((l) => clampLineLength(l));
-			const hasOutput = !(logicalLines.length === 1 && logicalLines[0] === "");
+			const rawLines = normalized.split("\n");
+			const totalLines = rawLines.length;
+			const hasOutput = !(totalLines === 1 && rawLines[0] === "");
 
 			if (!hasOutput) {
 				cacheKey = cacheId;
@@ -559,17 +586,17 @@ function createBashResultPreview(
 				return cacheLines;
 			}
 
-			const truncatedLines = logicalLines.map((line) => safeTruncateToWidth(line, bodyWidth, "…"));
-			const expandedLines = truncatedLines.length === 1 && truncatedLines[0] === "" ? [] : truncatedLines;
 			const applyColor = (l: string) =>
 				color === "error"
 					? formatToolOutputLine(theme, l, "error")
 					: cfg.dimOutput
 						? formatToolOutputLine(theme, l)
 						: formatToolOutputLine(theme, l, "text");
-			if (cfg.maxExpandedLines > 0 && expandedLines.length > cfg.maxExpandedLines) {
-				const truncated = expandedLines.slice(-cfg.maxExpandedLines).map(applyColor);
-				const remaining = expandedLines.length - cfg.maxExpandedLines;
+			const renderRawLine = (line: string) => safeTruncateToWidth(clampLineLength(line), bodyWidth, "…");
+
+			if (cfg.maxExpandedLines > 0 && totalLines > cfg.maxExpandedLines) {
+				const truncated = rawLines.slice(-cfg.maxExpandedLines).map((line) => applyColor(renderRawLine(line)));
+				const remaining = totalLines - cfg.maxExpandedLines;
 				truncated.unshift(theme.fg("dim", `… ${remaining} earlier lines`));
 				cacheKey = cacheId;
 				cacheLines = truncated;
@@ -577,7 +604,7 @@ function createBashResultPreview(
 			}
 
 			cacheKey = cacheId;
-			cacheLines = expandedLines.map(applyColor);
+			cacheLines = rawLines.map((line) => applyColor(renderRawLine(line)));
 			return cacheLines;
 		},
 	};
@@ -778,6 +805,10 @@ interface BashTreeState {
 	finished: boolean;
 	revision: number;
 	renderCache?: FinalSemanticRenderCache;
+	/** Raw output length at the last streaming parse attempt: partial passes
+	 *  with smaller growth than PARTIAL_REPARSE_THRESHOLD skip the re-parse (the
+	 *  final pass always parses the settled output in full). */
+	lastParsedLength?: number;
 }
 
 /** Classified semantic command: a bash tree (ls/find/grep), a git card, or a
@@ -834,6 +865,11 @@ function isGitActionClass(cls: BashSemanticClass): boolean {
 	return !isBashTreeClass(cls) && (cls as GitSemanticClass).kind === "action";
 }
 
+/** Minimum raw-output growth (chars) before a streaming partial pass re-parses
+ *  a live tree command's output; smaller deltas keep the current tree until the
+ *  final pass re-parses everything. */
+const PARTIAL_REPARSE_THRESHOLD = 4096;
+
 function parseSemanticOutput(cls: BashSemanticClass, output: string): ParsedSemantic | null {
 	if (isBashTreeClass(cls)) return parseBashTreeOutput(cls, output);
 	if (isGhClass(cls)) return parseGhOutput(cls, output);
@@ -945,6 +981,7 @@ export const bashTool: BoxedToolDefinition = {
 					existing.finished = false;
 					existing.revision++;
 					delete existing.renderCache;
+					delete existing.lastParsedLength;
 				}
 				existing.command = command;
 				existing.cls = cls;
@@ -980,14 +1017,26 @@ export const bashTool: BoxedToolDefinition = {
 			}
 			if (!options.isPartial || isBashTreeClass(cls)) {
 				const output = stripBashToolNoticeLines(stripAnsi(getTextOutput(result)));
-				const parsed = parseSemanticOutput(cls, output);
 				const state = semanticStates.get(context.toolCallId);
+				// Live tree classes re-parse on streaming passes, but only once the raw
+				// output grew ≥ PARTIAL_REPARSE_THRESHOLD chars since the last parse
+				// attempt: re-parsing the full buffer on every partial pass made
+				// streaming O(n²). Small deltas keep the current tree; the final pass
+				// always re-parses, so the settled registry state matches the ungated
+				// path byte for byte.
+				const shouldParse =
+					!options.isPartial ||
+					state === undefined ||
+					state.lastParsedLength === undefined ||
+					output.length - state.lastParsedLength >= PARTIAL_REPARSE_THRESHOLD;
+				const parsed = shouldParse ? parseSemanticOutput(cls, output) : undefined;
 				if (parsed) {
 					if (state) {
 						state.parsed = parsed;
 						state.finished = !options.isPartial;
 						state.revision++;
 						delete state.renderCache;
+						if (options.isPartial) state.lastParsedLength = output.length;
 					} else
 						semanticStates.set(context.toolCallId, {
 							cls,
@@ -995,6 +1044,7 @@ export const bashTool: BoxedToolDefinition = {
 							parsed,
 							finished: !options.isPartial,
 							revision: 0,
+							...(options.isPartial ? { lastParsedLength: output.length } : {}),
 						});
 					// `git diff` / `git show` render a boxed adaptive-diff result (one frame
 					// per file); `gh run view --job=<id>` renders a boxed log result. Every
@@ -1008,14 +1058,25 @@ export const bashTool: BoxedToolDefinition = {
 					}
 					return EMPTY_BASH_TREE_RESULT;
 				}
+				if (!shouldParse) {
+					// Skipped re-parse (sub-threshold growth): keep the current panel. A
+					// live parsed tree still owns the display (the call panel renders it, the
+					// result adds nothing); a fallback keeps streaming raw output into the
+					// open box below.
+					if (state?.parsed !== undefined) return EMPTY_BASH_TREE_RESULT;
+				}
 				// Unparseable output (ls -l, raw rg summary, non-git output): the boxed
 				// shell owns the result; flag the call panel to render nothing so the
-				// two don't duplicate.
-				if (state) {
-					state.fallback = true;
-					state.finished = !options.isPartial;
-					state.revision++;
-					delete state.renderCache;
+				// two don't duplicate. Skipped passes (sub-threshold growth) leave the
+				// current panel untouched.
+				if (shouldParse) {
+					if (state) {
+						state.fallback = true;
+						state.finished = !options.isPartial;
+						state.revision++;
+						delete state.renderCache;
+						if (options.isPartial) state.lastParsedLength = output.length;
+					}
 				}
 			}
 		} else if (options.isPartial) {

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

@@ -215,6 +215,12 @@ export interface BatchResultData {
  * and records batch completion once every member has settled. The member's
  * display detail stays as registered by the call renderer (the result context's
  * args may be normalized differently).
+ *
+ * `data.entries === undefined` means "keep the registered entries": callers
+ * that already registered final output (see hasFinalBatchOutput) omit the
+ * field on warm re-render passes, and that must never count as a change —
+ * comparing against the stored array would otherwise bump the revision on
+ * every pass.
  */
 export function registerBatchResult(
 	meta: BatchToolMeta,
@@ -231,7 +237,7 @@ export function registerBatchResult(
 			member.status !== nextStatus ||
 			member.isError !== nextIsError ||
 			member.errorText !== (nextIsError ? data.errorText : undefined) ||
-			member.outputEntries !== data.entries;
+			(data.entries !== undefined && member.outputEntries !== data.entries);
 		member.status = nextStatus;
 		member.isError = nextIsError;
 		if (member.isError && data.errorText !== undefined) member.errorText = data.errorText;
@@ -246,6 +252,16 @@ export function registerBatchResult(
 	return { batch, isLeader: batch.leaderId === context.toolCallId };
 }
 
+/** True when the member for `toolCallId` has settled with final parsed output
+ *  (done, non-error, entries registered). Result renderers use this to skip
+ *  re-parsing an unchanged final output on warm re-render passes. */
+export function hasFinalBatchOutput(toolCallId: string): boolean {
+	const batch = batchByCallId.get(toolCallId);
+	if (!batch) return false;
+	const member = batch.members.find((entry) => entry.toolCallId === toolCallId);
+	return member !== undefined && member.outputEntries !== undefined && member.status === "done" && !member.isError;
+}
+
 interface BatchStatus {
 	readonly total: number;
 	readonly done: number;

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

@@ -117,24 +117,15 @@ export const editTool: BoxedToolDefinition = {
 			});
 		}
 
-		// Resolve language for syntax highlighting
+		// Resolve the edited path (cache-key input + language hint source).
 		const message = firstText(result.content as Array<{ type: string; text?: string }>);
 		const argPath = String(context?.args?.path ?? context?.args?.file_path ?? "");
 		const sourcePath = details?.path ?? (argPath || extractEditedPath(message));
-		const language = sourcePath ? getLanguageFromPath(sourcePath) : undefined;
-
-		// Build diff rows + adaptive layout
-		const rows = buildSplitRows(diff);
 		const expanded = options.expanded;
-		const shouldHighlight =
-			Boolean(language) && diff.length <= MAX_HIGHLIGHT_DIFF_CHARS && rows.length <= MAX_HIGHLIGHT_DIFF_ROWS;
+		// Stats feed the footer, which is part of the cache key (cheap line scan —
+		// unlike the row/component construction below, which must not run on hits).
 		const stats = countDiffStats(diff);
 
-		// Render adaptive diff (unified/split per width) with syntax colors for small outputs.
-		const maxRows = expanded ? 160 : 36;
-		const diffView = new AdaptiveDiffComponent(theme, rows, maxRows, shouldHighlight ? language : undefined);
-		const expandHint = !expanded && diffView.hasCollapsed() ? "Ctrl+O more" : undefined;
-
 		return memoizedStateComponent(
 			context.state,
 			"__piStyleEditDiffResult",
@@ -146,8 +137,21 @@ export const editTool: BoxedToolDefinition = {
 				sourcePath ?? "",
 				editDiffFooter(theme, result, context, stats),
 			),
-			() =>
-				renderBoxedToolResult(
+			() => {
+				// Expensive construction (buildSplitRows + AdaptiveDiffComponent,
+				// ~0.4ms for a 160-row diff) runs only on cache misses, never per
+				// render pass. Everything below is a pure function of the key inputs.
+				const language = sourcePath ? getLanguageFromPath(sourcePath) : undefined;
+				const rows = buildSplitRows(diff);
+				const shouldHighlight =
+					Boolean(language) && diff.length <= MAX_HIGHLIGHT_DIFF_CHARS && rows.length <= MAX_HIGHLIGHT_DIFF_ROWS;
+
+				// Render adaptive diff (unified/split per width) with syntax colors for small outputs.
+				const maxRows = expanded ? 160 : 36;
+				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[] {
@@ -162,7 +166,8 @@ export const editTool: BoxedToolDefinition = {
 						...(expandHint ? { dividerRightLabel: expandHint } : {}),
 						footerLines: [editDiffFooter(theme, result, context, stats)],
 					},
-				),
+				);
+			},
 		);
 	},
 };

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

@@ -11,6 +11,7 @@ import {
 	type BatchToolMeta,
 	EMPTY_BATCH_COMPONENT,
 	emptyBatchResult,
+	hasFinalBatchOutput,
 	registerBatchCall,
 	registerBatchResult,
 	renderBatchAwareCall,
@@ -48,14 +49,18 @@ export const findTool: BoxedToolDefinition = {
 		return renderBatchAwareCall(theme, batch);
 	},
 	result(result, options, _theme, context) {
-		const output = stripAnsi(getTextOutput(result)).trimEnd();
-		const entries = context.isError ? undefined : parseFindOutput(output);
+		const isError = Boolean(context.isError);
+		// Result renderers re-fire on every repaint/scroll; once the final output
+		// is parsed and registered, skip stripping/parsing the same text again.
+		const settled = !options.isPartial && !isError && hasFinalBatchOutput(context.toolCallId);
+		const output = settled ? "" : stripAnsi(getTextOutput(result)).trimEnd();
+		const entries = settled || isError ? undefined : parseFindOutput(output);
 		registerBatchResult(
 			FIND_META,
 			{
 				isPartial: Boolean(options.isPartial),
-				isError: Boolean(context.isError),
-				errorText: context.isError ? output || undefined : undefined,
+				isError,
+				errorText: isError ? output || undefined : undefined,
 				...(entries !== undefined ? { entries } : {}),
 			},
 			context,

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

@@ -26,7 +26,7 @@ import { AdaptiveDiffComponent, buildSplitRows, countDiffStats } from "../../../
 import { parseSimpleBashCommand } from "./command-shape.js";
 import { pluralForm, TREE_INDENT } from "./output-tree.js";
 import { getStateElapsedMs, getToolsRenderConfig } from "./session-config.js";
-import type { BoxedToolContext } from "./shared.js";
+import { type BoxedToolContext, getRenderCacheKey, memoizedStateComponent } from "./shared.js";
 
 // ── Classification ──────────────────────────────────────────────────────────
 
@@ -1871,7 +1871,10 @@ interface DiffFileBox {
 
 /** Build a complete boxed-diff result component for a parsed `git diff`/`show`.
  *  The call panel renders the boxless Git header; this component renders one
- *  `╭…╰` frame per file (or a single `No changes` frame for an empty diff). */
+ *  `╭…╰` frame per file (or a single `No changes` frame for an empty diff).
+ *  Construction is memoized on the call state: repeated result passes reuse
+ *  the cached component (identity-stable, invalidate propagates inward) so
+ *  the per-file `AdaptiveDiffComponent` build never re-runs per render pass. */
 export function renderGitDiffResult(
 	theme: BoxTheme,
 	parsed: GitDiffParsed,
@@ -1879,6 +1882,47 @@ export function renderGitDiffResult(
 	context: BoxedToolContext,
 ): Component {
 	const expanded = Boolean(options.expanded);
+
+	// Cheap cache key capturing everything that affects output — theme, show vs
+	// diff, expansion, file count/totals, and per-file identity (path, body
+	// length, counts, binary/status) — computed WITHOUT building rows or
+	// components; the expensive build runs only on cache misses.
+	let totalAdditions = 0;
+	let totalRemovals = 0;
+	const sigParts: string[] = [];
+	for (const file of parsed.files) {
+		totalAdditions += file.additions;
+		totalRemovals += file.removals;
+		sigParts.push(
+			`${file.path}:${file.body.length}:${file.additions}:${file.removals}:${file.binary ? 1 : 0}:${file.status ?? ""}`,
+		);
+	}
+	const sig = sigParts.join(";").slice(0, 2048);
+
+	return memoizedStateComponent(
+		context.state,
+		"__piStyleGitDiffResult",
+		getRenderCacheKey(
+			"git-diff-result",
+			theme,
+			String(parsed.show),
+			String(expanded),
+			parsed.files.length,
+			totalAdditions,
+			totalRemovals,
+			sig,
+		),
+		() => buildGitDiffResultComponent(theme, parsed, expanded, context),
+	);
+}
+
+/** Uncached boxed git-diff construction: one `╭…╰` frame per file. */
+function buildGitDiffResultComponent(
+	theme: BoxTheme,
+	parsed: GitDiffParsed,
+	expanded: boolean,
+	context: BoxedToolContext,
+): Component {
 	const elapsedMs = getStateElapsedMs(context.state);
 	const fileCount = parsed.files.length;
 

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

@@ -166,14 +166,21 @@ export const grepTool: BoxedToolDefinition = {
 		return renderGrepPanel(theme, context.toolCallId);
 	},
 	result(result, options, _theme, context) {
-		const output = stripAnsi(getTextOutput(result)).trimEnd();
 		const isError = Boolean(context.isError);
+		const isPartial = Boolean(options.isPartial);
+		// Result renderers re-fire on every repaint/scroll; once final matches
+		// are registered the registry is already final — skip stripping/parsing.
+		const state = grepPanels.get(context.toolCallId);
+		if (!isPartial && !isError && state !== undefined && state.matches !== undefined && !state.isPartial) {
+			return EMPTY_GREP_RESULT;
+		}
+		const output = stripAnsi(getTextOutput(result)).trimEnd();
 		const matches = isError ? [] : parseGrepOutput(output);
 		registerGrepResult(context.toolCallId, {
 			matches,
 			isError,
 			errorText: isError ? output || undefined : undefined,
-			isPartial: Boolean(options.isPartial),
+			isPartial,
 		});
 		return EMPTY_GREP_RESULT;
 	},

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

@@ -11,6 +11,7 @@ import {
 	type BatchToolMeta,
 	EMPTY_BATCH_COMPONENT,
 	emptyBatchResult,
+	hasFinalBatchOutput,
 	registerBatchCall,
 	registerBatchResult,
 	renderBatchAwareCall,
@@ -40,14 +41,18 @@ export const lsTool: BoxedToolDefinition = {
 		return renderBatchAwareCall(theme, batch);
 	},
 	result(result, options, _theme, context) {
-		const output = stripAnsi(getTextOutput(result)).trimEnd();
-		const entries = context.isError ? undefined : parseLsOutput(output);
+		const isError = Boolean(context.isError);
+		// Result renderers re-fire on every repaint/scroll; once the final output
+		// is parsed and registered, skip stripping/parsing the same text again.
+		const settled = !options.isPartial && !isError && hasFinalBatchOutput(context.toolCallId);
+		const output = settled ? "" : stripAnsi(getTextOutput(result)).trimEnd();
+		const entries = settled || isError ? undefined : parseLsOutput(output);
 		registerBatchResult(
 			LIST_META,
 			{
 				isPartial: Boolean(options.isPartial),
-				isError: Boolean(context.isError),
-				errorText: context.isError ? output || undefined : undefined,
+				isError,
+				errorText: isError ? output || undefined : undefined,
 				...(entries !== undefined ? { entries } : {}),
 			},
 			context,

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

@@ -174,18 +174,12 @@ function renderQuickEditResult(
 		});
 	}
 
-	const rows = buildSplitRows(diff);
 	const expanded = options.expanded;
 	const argPath = String(context?.args?.path ?? "");
-	const language = argPath ? getLanguageFromPath(argPath) : undefined;
-	const shouldHighlight =
-		Boolean(language) && diff.length <= MAX_HIGHLIGHT_DIFF_CHARS && rows.length <= MAX_HIGHLIGHT_DIFF_ROWS;
+	// Stats feed the footer, which is part of the cache key (cheap line scan —
+	// unlike the row/component construction below, which must not run on hits).
 	const stats = countDiffStats(diff);
 
-	const maxRows = expanded ? 160 : 36;
-	const diffView = new AdaptiveDiffComponent(theme, rows, maxRows, shouldHighlight ? language : undefined);
-	const expandHint = !expanded && diffView.hasCollapsed() ? "Ctrl+O more" : undefined;
-
 	return memoizedStateComponent(
 		context.state,
 		"__piStyleQuickEditDiffResult",
@@ -198,8 +192,20 @@ function renderQuickEditResult(
 			argPath,
 			quickEditDiffFooter(theme, result, context, stats),
 		),
-		() =>
-			renderBoxedToolResult(
+		() => {
+			// Expensive construction (buildSplitRows + AdaptiveDiffComponent) runs
+			// only on cache misses, never per render pass. Everything below is a
+			// pure function of the key inputs.
+			const rows = buildSplitRows(diff);
+			const language = argPath ? getLanguageFromPath(argPath) : undefined;
+			const shouldHighlight =
+				Boolean(language) && diff.length <= MAX_HIGHLIGHT_DIFF_CHARS && rows.length <= MAX_HIGHLIGHT_DIFF_ROWS;
+
+			const maxRows = expanded ? 160 : 36;
+			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[] {
@@ -214,7 +220,8 @@ function renderQuickEditResult(
 					...(expandHint ? { dividerRightLabel: expandHint } : {}),
 					footerLines: [quickEditDiffFooter(theme, result, context, stats)],
 				},
-			),
+			);
+		},
 	);
 }
 

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

@@ -32,13 +32,15 @@ export const readTool: BoxedToolDefinition = {
 		return renderBatchAwareCall(theme, batch);
 	},
 	result(result, options, _theme, context) {
-		const output = stripAnsi(getTextOutput(result)).trimEnd();
+		// The strip is only needed for error text — keep it off the success path
+		// (result renderers re-fire on every repaint/scroll).
+		const errorText = context.isError ? stripAnsi(getTextOutput(result)).trimEnd() || undefined : undefined;
 		registerBatchResult(
 			READ_META,
 			{
 				isPartial: Boolean(options.isPartial),
 				isError: Boolean(context.isError),
-				errorText: context.isError ? output || undefined : undefined,
+				errorText,
 			},
 			context,
 		);

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

@@ -181,8 +181,34 @@ type StateComponentCacheEntry = {
 	component: Component;
 };
 
+/** Cache-key string parts at or below this length join verbatim; longer ones
+ *  collapse to `length:hash` so the joined key length stays bounded regardless
+ *  of raw output size. */
+const CACHE_KEY_LONG_PART_THRESHOLD = 64;
+
+/** 32-bit FNV-1a hash of a string as 8 lowercase hex digits. Local mirror of the
+ *  compatibility probe's fingerprint hashing (the pi/ layer stays unreachable
+ *  from features): deterministic, collision-safe for cache identity. */
+function fnv1aHex(text: string): string {
+	let hash = 2166136261;
+	for (let i = 0; i < text.length; i++) {
+		hash ^= text.charCodeAt(i);
+		hash = Math.imul(hash, 16777619) >>> 0;
+	}
+	return hash.toString(16).padStart(8, "0");
+}
+
+/** Fold one join part: strings longer than CACHE_KEY_LONG_PART_THRESHOLD
+ *  collapse to `length:hash`; numbers/booleans pass through unchanged. */
+function boundedCacheKeyPart(part: string | number | boolean): string | number | boolean {
+	if (typeof part !== "string" || part.length <= CACHE_KEY_LONG_PART_THRESHOLD) return part;
+	return `${part.length}:${fnv1aHex(part)}`;
+}
+
 export function getRenderCacheKey(prefix: string, theme: BoxTheme, ...parts: Array<string | number | boolean>): string {
-	return [prefix, themeCacheKey(theme), getToolsRenderCacheSignature(), ...parts].join("|");
+	const pieces: Array<string | number | boolean> = [prefix, themeCacheKey(theme), getToolsRenderCacheSignature()];
+	for (const part of parts) pieces.push(boundedCacheKeyPart(part));
+	return pieces.join("|");
 }
 
 export function memoizedStateComponent(

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

@@ -306,6 +306,18 @@ export function invalidateTurnMembers(turn: TurnState): void {
 	}
 }
 
+/**
+ * Drop the turn's captured invalidate callbacks (`agent_end`, after the
+ * collapse re-render). The closures pin component state for the rest of the
+ * session otherwise; `memberByCallId` entries stay so scrollback keeps
+ * resolving the turn. Later expand toggles re-render via Pi's updateDisplay
+ * selectors and re-capture fresh callbacks; a missing callback is already
+ * skipped gracefully by invalidateTurnMembers.
+ */
+export function releaseTurnInvalidators(turn: TurnState): void {
+	for (const member of turn.members) invalidateByCallId.delete(member.toolCallId);
+}
+
 /**
  * Freeze a member's wall-clock elapsed into the registry (idempotent; the
  * value is frozen by the renderer state once the terminal result rendered).

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

@@ -7,6 +7,7 @@ import {
 	invalidateTurnMembers,
 	rebuildTurnRegistryFromEntries,
 	registerTurnFromMessage,
+	releaseTurnInvalidators,
 } from "../features/tools/boxed/turn-summary.js";
 import { requestToolPresentationRender } from "../features/tools/index.js";
 import { registerPiStyleCommand } from "./commands.js";
@@ -142,6 +143,7 @@ export default function piStyleExtension(pi: ExtensionAPI): void {
 		const run = finishAgentRun();
 		if (run) {
 			invalidateTurnMembers(run);
+			releaseTurnInvalidators(run);
 			requestToolPresentationRender();
 		}
 	});