pi-cc-extensions 0.8.13 → 0.8.15

package/extensions/tool-diff/diff-renderer.ts

@@ -277,29 +277,40 @@ function resolveLanguageFromPath(rawPath: string | undefined): string | undefine
 	}
 }
 
+const MAX_CODE_HIGHLIGHT_CACHE_ENTRIES = 2048;
+
 function createCodeLineHighlighter(language: string | undefined): CodeLineHighlighter {
 	if (!language) {
 		return (line) => sanitizeAnsiForThemedOutput(line);
 	}
 
+	// Insertion-order Map used as a small LRU so large diffs cannot retain every unique line.
 	const cache = new Map<string, string>();
+	const remember = (line: string, value: string): string => {
+		if (cache.has(line)) cache.delete(line);
+		cache.set(line, value);
+		if (cache.size > MAX_CODE_HIGHLIGHT_CACHE_ENTRIES) {
+			const oldest = cache.keys().next().value;
+			if (oldest !== undefined) cache.delete(oldest);
+		}
+		return value;
+	};
 	return (line) => {
 		if (!line) {
 			return line;
 		}
 		const cached = cache.get(line);
 		if (cached !== undefined) {
+			// Refresh recency for LRU.
+			cache.delete(line);
+			cache.set(line, cached);
 			return cached;
 		}
 		try {
 			const highlighted = highlightCode(line, language)[0] ?? line;
-			const sanitized = sanitizeAnsiForThemedOutput(highlighted);
-			cache.set(line, sanitized);
-			return sanitized;
+			return remember(line, sanitizeAnsiForThemedOutput(highlighted));
 		} catch {
-			const sanitizedFallback = sanitizeAnsiForThemedOutput(line);
-			cache.set(line, sanitizedFallback);
-			return sanitizedFallback;
+			return remember(line, sanitizeAnsiForThemedOutput(line));
 		}
 	};
 }
@@ -1301,6 +1312,25 @@ function resolveDiffIndicatorMode(
 	return config.diffIndicatorMode ?? DEFAULT_TOOL_DISPLAY_CONFIG.diffIndicatorMode;
 }
 
+/** Snapshot or live getter — panel changes must apply on the next paint. */
+export type DisplayConfigInput = ToolDisplayConfig | (() => ToolDisplayConfig);
+
+function resolveLiveDisplayConfig(input: DisplayConfigInput): ToolDisplayConfig {
+	return typeof input === "function" ? input() : input;
+}
+
+/** Cache key fragment so indicator/wrap/limits invalidate without host recreate. */
+function displayConfigCacheKey(config: ToolDisplayConfig): string {
+	return [
+		config.diffViewMode,
+		config.diffIndicatorMode,
+		String(config.diffSplitMinWidth),
+		String(config.diffCollapsedLines),
+		config.diffWordWrap ? "1" : "0",
+		String(config.expandedPreviewMaxLines),
+	].join(":");
+}
+
 function resolveIndicatorGlyph(
 	kind: DiffLineKind,
 	indicatorMode: DiffIndicatorMode,
@@ -2148,28 +2178,96 @@ function renderDiffSpacerLine(width: number): string {
 	return safeWidth > 0 ? " ".repeat(safeWidth) : "";
 }
 
-function applyLineLimit(
-	rows: RenderedRow[],
-	width: number,
+function resolveDiffDisplayLimit(
 	expanded: boolean,
 	maxCollapsedLines: number,
 	maxExpandedLines: number,
-	totalHunks: number,
-	theme: DiffTheme,
-): string[] {
+): number {
 	const expandedLimit = Number.isFinite(maxExpandedLines)
 		? maxExpandedLines
 		: DEFAULT_TOOL_DISPLAY_CONFIG.expandedPreviewMaxLines;
 	const collapsedLimit = Number.isFinite(maxCollapsedLines)
 		? maxCollapsedLines
 		: DEFAULT_TOOL_DISPLAY_CONFIG.diffCollapsedLines;
-	const limit = expanded ? Math.max(0, expandedLimit) : Math.max(1, collapsedLimit);
-	if (limit === 0 || rows.length <= limit) {
+	return expanded ? Math.max(0, expandedLimit) : Math.max(1, collapsedLimit);
+}
+
+/**
+ * How many source rows/entries to fully highlight+render before applyLineLimit.
+ * Extra headroom covers word-wrap expansion so the display limit can still fill.
+ */
+function resolveDiffProcessBudget(displayLimit: number, wordWrap: boolean): number {
+	if (!Number.isFinite(displayLimit) || displayLimit <= 0) {
+		return Number.POSITIVE_INFINITY;
+	}
+	return wordWrap ? displayLimit * 2 + 8 : displayLimit + 4;
+}
+
+function countDiffLineEntries(entries: readonly ParsedDiffEntry[]): number {
+	let count = 0;
+	for (const entry of entries) {
+		if (entry.kind === "line") count++;
+	}
+	return count;
+}
+
+function takeEntriesForLineBudget(
+	entries: ParsedDiffEntry[],
+	maxLineEntries: number,
+): { entries: ParsedDiffEntry[]; totalLineEntries: number; processedLineEntries: number } {
+	const totalLineEntries = countDiffLineEntries(entries);
+	if (!Number.isFinite(maxLineEntries) || maxLineEntries >= totalLineEntries) {
+		return { entries, totalLineEntries, processedLineEntries: totalLineEntries };
+	}
+	const limited: ParsedDiffEntry[] = [];
+	let processedLineEntries = 0;
+	for (const entry of entries) {
+		if (entry.kind === "line") {
+			if (processedLineEntries >= maxLineEntries) break;
+			processedLineEntries++;
+		}
+		limited.push(entry);
+	}
+	return { entries: limited, totalLineEntries, processedLineEntries };
+}
+
+function takeSplitRowsForBudget(
+	rows: SplitDiffRow[],
+	maxRows: number,
+): { rows: SplitDiffRow[]; totalRows: number; processedRows: number } {
+	const totalRows = rows.length;
+	if (!Number.isFinite(maxRows) || maxRows >= totalRows) {
+		return { rows, totalRows, processedRows: totalRows };
+	}
+	const limited = rows.slice(0, maxRows);
+	return { rows: limited, totalRows, processedRows: limited.length };
+}
+
+function applyLineLimit(
+	rows: RenderedRow[],
+	width: number,
+	expanded: boolean,
+	maxCollapsedLines: number,
+	maxExpandedLines: number,
+	totalHunks: number,
+	theme: DiffTheme,
+	/**
+	 * When the caller only rendered a prefix of the full diff, pass the unprocessed
+	 * remainder so the collapse hint still reflects total hidden content.
+	 */
+	unprocessedLogicalRows = 0,
+): string[] {
+	const limit = resolveDiffDisplayLimit(expanded, maxCollapsedLines, maxExpandedLines);
+	const safeUnprocessed = Math.max(0, unprocessedLogicalRows);
+	if (limit === 0 || (rows.length <= limit && safeUnprocessed === 0)) {
 		return rows.map((row) => clampDiffLineToWidth(row.text, width));
 	}
 
-	const shown = rows.slice(0, limit);
-	const remaining = rows.length - shown.length;
+	const shown = rows.length <= limit ? rows : rows.slice(0, limit);
+	const remaining = Math.max(0, rows.length - shown.length) + safeUnprocessed;
+	if (remaining === 0) {
+		return shown.map((row) => clampDiffLineToWidth(row.text, width));
+	}
 	const visibleHunks = new Set(
 		shown
 			.map((row) => row.hunkIndex)
@@ -2271,24 +2369,38 @@ function createDiffRenderCache() {
 	let cachedWidth: number | undefined;
 	let cachedExpanded: boolean | undefined;
 	let cachedMode: DiffPresentationMode | undefined;
+	let cachedConfigKey: string | undefined;
 	let cachedLines: string[] | undefined;
 
 	return {
-		get(width: number, expanded: boolean, mode: DiffPresentationMode): string[] | undefined {
+		get(
+			width: number,
+			expanded: boolean,
+			mode: DiffPresentationMode,
+			configKey: string,
+		): string[] | undefined {
 			if (
 				cachedLines &&
 				cachedWidth === width &&
 				cachedExpanded === expanded &&
-				cachedMode === mode
+				cachedMode === mode &&
+				cachedConfigKey === configKey
 			) {
 				return cachedLines;
 			}
 			return undefined;
 		},
-		set(width: number, expanded: boolean, mode: DiffPresentationMode, lines: string[]): string[] {
+		set(
+			width: number,
+			expanded: boolean,
+			mode: DiffPresentationMode,
+			configKey: string,
+			lines: string[],
+		): string[] {
 			cachedWidth = width;
 			cachedExpanded = expanded;
 			cachedMode = mode;
+			cachedConfigKey = configKey;
 			cachedLines = lines;
 			return lines;
 		},
@@ -2296,6 +2408,7 @@ function createDiffRenderCache() {
 			cachedWidth = undefined;
 			cachedExpanded = undefined;
 			cachedMode = undefined;
+			cachedConfigKey = undefined;
 			cachedLines = undefined;
 		},
 	};
@@ -2304,7 +2417,7 @@ function createDiffRenderCache() {
 export function renderEditDiffResult(
 	details: unknown,
 	options: DiffRenderOptions,
-	config: ToolDisplayConfig,
+	config: DisplayConfigInput,
 	theme: DiffTheme,
 	fallbackText: string,
 ): Component {
@@ -2339,16 +2452,19 @@ export function renderEditDiffResult(
 	const containerBgAnsi = undefined;
 	const language = resolveLanguageFromPath(options.filePath);
 	const highlightLine = createCodeLineHighlighter(language);
-	const wordWrap = config.diffWordWrap;
-	const indicatorMode = resolveDiffIndicatorMode(config);
 
 	const cache = createDiffRenderCache();
 
 	return {
 		render(width: number): string[] {
+			// Live config: panel can change indicator/wrap/limits after this component is created.
+			const live = resolveLiveDisplayConfig(config);
+			const wordWrap = live.diffWordWrap;
+			const indicatorMode = resolveDiffIndicatorMode(live);
+			const configKey = displayConfigCacheKey(live);
 			const safeWidth = normalizeDiffRenderWidth(width);
-			const mode = resolveDiffPresentationMode(config, safeWidth, canRenderSplitLayout(safeWidth));
-			const cached = cache.get(safeWidth, options.expanded, mode);
+			const mode = resolveDiffPresentationMode(live, safeWidth, canRenderSplitLayout(safeWidth));
+			const cached = cache.get(safeWidth, options.expanded, mode, configKey);
 			if (cached) {
 				return cached;
 			}
@@ -2358,6 +2474,7 @@ export function renderEditDiffResult(
 					safeWidth,
 					options.expanded,
 					mode,
+					configKey,
 					clampDiffLinesToWidth(
 						renderSingleDiffRow(
 							buildDiffSummaryText(parsed.stats, safeWidth),
@@ -2371,59 +2488,47 @@ export function renderEditDiffResult(
 			}
 
 			const headerRows = renderHeaderRows(parsed.stats, mode, safeWidth, theme);
-			const inlineHighlights = buildInlineHighlightMap(splitRows);
+			const displayLimit = resolveDiffDisplayLimit(
+				options.expanded,
+				live.diffCollapsedLines,
+				live.expandedPreviewMaxLines,
+			);
+			const processBudget = resolveDiffProcessBudget(displayLimit, wordWrap);
+			// Only highlight/render a prefix that can fill the display limit; full-diff
+			// LCS + syntax highlight on thousands of hidden lines is pure waste when collapsed.
+			const entryBudget = takeEntriesForLineBudget(parsed.entries, processBudget);
+			const splitBudget = takeSplitRowsForBudget(splitRows, processBudget);
+			const inlineHighlights = buildInlineHighlightMap(splitBudget.rows);
+			const renderCtx: DiffRenderContext = {
+				width: safeWidth,
+				theme,
+				inlineHighlights,
+				palette,
+				highlightLine,
+				containerBgAnsi,
+				wordWrap,
+				indicatorMode,
+				showHashlineAnchors,
+			};
 			const bodyRows =
 				mode === "split"
-					? renderSplit(
-							splitRows,
-							{
-								width: safeWidth,
-								theme,
-								inlineHighlights,
-								palette,
-								highlightLine,
-								containerBgAnsi,
-								wordWrap,
-								indicatorMode,
-								showHashlineAnchors,
-							},
-							lineNumberWidth,
-						)
+					? renderSplit(splitBudget.rows, renderCtx, lineNumberWidth)
 					: mode === "compact"
-						? renderCompact(parsed.entries, {
-								width: safeWidth,
-								theme,
-								inlineHighlights,
-								palette,
-								highlightLine,
-								containerBgAnsi,
-								wordWrap,
-								indicatorMode,
-								showHashlineAnchors,
-							})
-						: renderUnified(
-								parsed.entries,
-								{
-									width: safeWidth,
-									theme,
-									inlineHighlights,
-									palette,
-									highlightLine,
-									containerBgAnsi,
-									wordWrap,
-									indicatorMode,
-									showHashlineAnchors,
-								},
-								lineNumberWidth,
-							);
+						? renderCompact(entryBudget.entries, renderCtx)
+						: renderUnified(entryBudget.entries, renderCtx, lineNumberWidth);
+			const unprocessedLogicalRows =
+				mode === "split"
+					? Math.max(0, splitBudget.totalRows - splitBudget.processedRows)
+					: Math.max(0, entryBudget.totalLineEntries - entryBudget.processedLineEntries);
 			const bodyWithLimit = applyLineLimit(
 				bodyRows,
 				safeWidth,
 				options.expanded,
-				config.diffCollapsedLines,
-				config.expandedPreviewMaxLines,
+				live.diffCollapsedLines,
+				live.expandedPreviewMaxLines,
 				parsed.stats.hunks,
 				theme,
+				unprocessedLogicalRows,
 			);
 			const frame = renderDiffFrameLine(safeWidth, theme);
 			const renderedLines =
@@ -2432,7 +2537,7 @@ export function renderEditDiffResult(
 					: [...headerRows.map((row) => row.text), ...bodyWithLimit];
 
 			const clampedLines = clampDiffLinesToWidth(renderedLines, safeWidth);
-			return cache.set(safeWidth, options.expanded, mode, clampedLines);
+			return cache.set(safeWidth, options.expanded, mode, configKey, clampedLines);
 		},
 		invalidate: cache.invalidate,
 	};
@@ -2593,6 +2698,8 @@ interface WriteOverwriteGuard {
 
 const MAX_WRITE_OVERWRITE_DIFF_LINES = 4000;
 const MAX_WRITE_OVERWRITE_DIFF_MATRIX_CELLS = 1_000_000;
+/** Collapsed overwrite previews refuse larger LCS matrices to avoid TUI freezes. */
+const MAX_COLLAPSED_WRITE_OVERWRITE_DIFF_MATRIX_CELLS = 200_000;
 
 function buildApproximateWriteStats(
 	lineCount: number,
@@ -2631,6 +2738,7 @@ function buildWriteDiffData(entries: ParsedDiffEntry[]): WriteDiffData {
 function resolveWriteOverwriteGuard(
 	previousLines: string[],
 	nextLines: string[],
+	expanded = true,
 ): WriteOverwriteGuard | undefined {
 	const previousLineCount = previousLines.length;
 	const nextLineCount = nextLines.length;
@@ -2643,7 +2751,10 @@ function resolveWriteOverwriteGuard(
 	if (previousLineCount === 0 || nextLineCount === 0) {
 		return undefined;
 	}
-	return previousLineCount * nextLineCount > MAX_WRITE_OVERWRITE_DIFF_MATRIX_CELLS
+	const cellLimit = expanded
+		? MAX_WRITE_OVERWRITE_DIFF_MATRIX_CELLS
+		: MAX_COLLAPSED_WRITE_OVERWRITE_DIFF_MATRIX_CELLS;
+	return previousLineCount * nextLineCount > cellLimit
 		? { previousLineCount, nextLineCount }
 		: undefined;
 }
@@ -2680,7 +2791,7 @@ function renderWriteOverwriteGuardRows(
 export function renderWriteDiffResult(
 	content: string | undefined,
 	options: DiffRenderOptions,
-	config: ToolDisplayConfig,
+	config: DisplayConfigInput,
 	theme: DiffTheme,
 	fallbackText: string,
 ): Component {
@@ -2704,16 +2815,11 @@ export function renderWriteDiffResult(
 		previousLines.length,
 		hasComparablePrevious,
 	);
-	const overwriteGuard = hasComparablePrevious
-		? resolveWriteOverwriteGuard(previousLines, lines)
-		: undefined;
 	const palette = resolveDiffPalette(theme);
 	// Keep the panel transparent; changed rows and inline spans retain their own highlights.
 	const containerBgAnsi = undefined;
 	const language = resolveLanguageFromPath(filePath);
 	const highlightLine = createCodeLineHighlighter(language);
-	const wordWrap = config.diffWordWrap;
-	const indicatorMode = resolveDiffIndicatorMode(config);
 
 	let detailedData: WriteDiffData | undefined;
 	const cache = createDiffRenderCache();
@@ -2731,9 +2837,14 @@ export function renderWriteDiffResult(
 
 	return {
 		render(width: number): string[] {
+			// Live config: panel can change indicator/wrap/limits after this component is created.
+			const live = resolveLiveDisplayConfig(config);
+			const wordWrap = live.diffWordWrap;
+			const indicatorMode = resolveDiffIndicatorMode(live);
+			const configKey = displayConfigCacheKey(live);
 			const safeWidth = normalizeDiffRenderWidth(width);
 			const resolvedMode = resolveDiffPresentationMode(
-				config,
+				live,
 				safeWidth,
 				canRenderSplitLayout(safeWidth),
 			);
@@ -2742,7 +2853,7 @@ export function renderWriteDiffResult(
 				: resolvedMode === "split"
 					? "unified"
 					: resolvedMode;
-			const cached = cache.get(safeWidth, options.expanded, mode);
+			const cached = cache.get(safeWidth, options.expanded, mode, configKey);
 			if (cached) {
 				return cached;
 			}
@@ -2753,11 +2864,16 @@ export function renderWriteDiffResult(
 				theme,
 				options.headerLabel,
 			);
+			// Guard depends on expanded: collapsed previews use a stricter LCS cell budget.
+			const overwriteGuard = hasComparablePrevious
+				? resolveWriteOverwriteGuard(previousLines, lines, options.expanded)
+				: undefined;
 			if (overwriteGuard) {
 				return cache.set(
 					safeWidth,
 					options.expanded,
 					mode,
+					configKey,
 					clampDiffLinesToWidth(
 						[header, ...renderWriteOverwriteGuardRows(overwriteGuard, safeWidth, theme)],
 						safeWidth,
@@ -2782,15 +2898,28 @@ export function renderWriteDiffResult(
 					safeWidth,
 					options.expanded,
 					mode,
+					configKey,
 					clampDiffLinesToWidth(summaryRows, safeWidth),
 				);
 			}
 
 			const data = getDetailedData();
+			const displayLimit = resolveDiffDisplayLimit(
+				options.expanded,
+				live.diffCollapsedLines,
+				live.expandedPreviewMaxLines,
+			);
+			const processBudget = resolveDiffProcessBudget(displayLimit, wordWrap);
+			const entryBudget = takeEntriesForLineBudget(data.entries, processBudget);
+			const splitBudget = takeSplitRowsForBudget(data.splitRows, processBudget);
+			const inlineHighlights =
+				splitBudget.processedRows < splitBudget.totalRows
+					? buildInlineHighlightMap(splitBudget.rows)
+					: data.inlineHighlights;
 			const renderCtx: DiffRenderContext = {
 				width: safeWidth,
 				theme,
-				inlineHighlights: data.inlineHighlights,
+				inlineHighlights,
 				palette,
 				highlightLine,
 				containerBgAnsi,
@@ -2799,28 +2928,33 @@ export function renderWriteDiffResult(
 				showHashlineAnchors: false,
 			};
 			const bodyRows: RenderedRow[] =
-				data.entries.length === 0
+				entryBudget.entries.length === 0
 					? [{ text: theme.fg("muted", "(empty file)"), hunkIndex: null }]
 					: mode === "split"
-						? renderSplit(data.splitRows, renderCtx, data.lineNumberWidth)
+						? renderSplit(splitBudget.rows, renderCtx, data.lineNumberWidth)
 						: mode === "compact"
-							? renderCompact(data.entries, renderCtx)
-							: renderUnified(data.entries, renderCtx, data.lineNumberWidth);
+							? renderCompact(entryBudget.entries, renderCtx)
+							: renderUnified(entryBudget.entries, renderCtx, data.lineNumberWidth);
+			const unprocessedLogicalRows =
+				mode === "split"
+					? Math.max(0, splitBudget.totalRows - splitBudget.processedRows)
+					: Math.max(0, entryBudget.totalLineEntries - entryBudget.processedLineEntries);
 
 			const bodyWithLimit = applyLineLimit(
 				bodyRows,
 				safeWidth,
 				options.expanded,
-				config.diffCollapsedLines,
-				config.expandedPreviewMaxLines,
+				live.diffCollapsedLines,
+				live.expandedPreviewMaxLines,
 				data.hunkCount,
 				theme,
+				unprocessedLogicalRows,
 			);
 			const frame = renderDiffFrameLine(safeWidth, theme);
 			const renderedLines =
 				mode === "unified" ? [header, frame, ...bodyWithLimit, frame] : [header, ...bodyWithLimit];
 			const finalLines = clampDiffLinesToWidth(renderedLines, safeWidth);
-			return cache.set(safeWidth, options.expanded, mode, finalLines);
+			return cache.set(safeWidth, options.expanded, mode, configKey, finalLines);
 		},
 		invalidate: cache.invalidate,
 	};

package/extensions/tool-diff/index.ts

@@ -1,6 +1,10 @@
 import { createWriteToolDefinition, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth } from "@earendil-works/pi-tui";
-import { renderEditDiffResult, renderWriteDiffResult } from "./diff-renderer.ts";
+import {
+	renderEditDiffResult,
+	renderWriteDiffResult,
+	type DisplayConfigInput,
+} from "./diff-renderer.ts";
 import { DEFAULT_TOOL_DISPLAY_CONFIG } from "./types.ts";
 import { executeWriteWithMetadata, WriteExecutionMetadataStore } from "./write-execution.ts";
 
@@ -34,6 +38,8 @@ export function renderRichToolResult(
 	theme: any,
 	context: any,
 	writeMetadata: WriteExecutionMetadataStore,
+	/** Plain snapshot or live getter — getter lets /ccstyle panel changes repaint existing diffs. */
+	displayConfig: DisplayConfigInput = DEFAULT_TOOL_DISPLAY_CONFIG,
 ): any | undefined {
 	if (options?.isPartial || options?.isError || context?.isError) return undefined;
 	const expanded = options?.expanded === true || context?.expanded === true;
@@ -42,7 +48,7 @@ export function renderRichToolResult(
 		return renderEditDiffResult(
 			result?.details,
 			{ expanded, filePath },
-			DEFAULT_TOOL_DISPLAY_CONFIG,
+			displayConfig,
 			theme,
 			resultText(result),
 		);
@@ -64,7 +70,7 @@ export function renderRichToolResult(
 			previousContent: metadata.previousContent,
 			fileExistedBeforeWrite: metadata.fileExistedBeforeWrite,
 		},
-		DEFAULT_TOOL_DISPLAY_CONFIG,
+		displayConfig,
 		theme,
 		resultText(result),
 	);
@@ -103,4 +109,11 @@ export function installWriteOverride(
 	return store;
 }
 
-export { DEFAULT_TOOL_DISPLAY_CONFIG, WriteExecutionMetadataStore };
+export {
+	DEFAULT_TOOL_DISPLAY_CONFIG,
+	type ToolDisplayConfig,
+	type DiffViewMode,
+	type DiffIndicatorMode,
+} from "./types.ts";
+export type { DisplayConfigInput } from "./diff-renderer.ts";
+export { WriteExecutionMetadataStore } from "./write-execution.ts";

package/extensions/tool-diff/types.ts

@@ -14,7 +14,13 @@ export const DEFAULT_TOOL_DISPLAY_CONFIG: ToolDisplayConfig = {
 	diffViewMode: "auto",
 	diffIndicatorMode: "bars",
 	diffSplitMinWidth: 120,
+	/** Collapsed tool/diff body: ~half a typical terminal after chrome. */
 	diffCollapsedLines: 24,
 	diffWordWrap: true,
-	expandedPreviewMaxLines: 4000,
+	/**
+	 * Expanded tool/diff body cap. 40 ≈ one screen of content after title,
+	 * Input section, editor, and status — keeps the TUI compact.
+	 * Raise via /ccstyle → Diff → Expanded max lines when reviewing large dumps.
+	 */
+	expandedPreviewMaxLines: 40,
 };

package/extensions/tool-result-sanitize.ts

@@ -6,9 +6,16 @@ const UNSAFE_TERMINAL_ESCAPE = new RegExp(
 	"g",
 );
 
-/** Prevent captured terminal control responses from being replayed by tool renderers. */
-export function sanitizeToolResultText(value: string): string {
-	return value
+/**
+ * Prevent captured terminal control responses from being replayed by tool renderers.
+ * Optional `maxChars` trims the input first so preview/one-line paths never scan multi-MB outputs.
+ */
+export function sanitizeToolResultText(value: string, maxChars?: number): string {
+	const source =
+		typeof maxChars === "number" && maxChars >= 0 && value.length > maxChars
+			? value.slice(0, maxChars)
+			: value;
+	return source
 		.replace(UNSAFE_TERMINAL_ESCAPE, "")
 		.replace(/\x1B/g, "")
 		.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F]/g, "")

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-cc-extensions",
-	"version": "0.8.13",
+	"version": "0.8.15",
 	"description": "A Pi productivity suite with Claude Code-style UI, structured questionnaires, context inspection, and agent/session references",
 	"type": "module",
 	"keywords": [