pi-cc-extensions 0.8.13 → 0.8.14

package/extensions/compact-style.ts

@@ -192,7 +192,8 @@ function shortenPath(path: unknown): string {
 }
 
 function oneLine(value: unknown): string {
-	return sanitizeToolResultText(String(value ?? ""))
+	// Preview paths only need a short prefix; skip scanning multi-MB tool outputs.
+	return sanitizeToolResultText(String(value ?? ""), 4_096)
 		.replace(/\s+/g, " ")
 		.trim();
 }
@@ -298,7 +299,8 @@ export function resultPreview(result: any, isPartial = false): string {
 		? result.content.find((c: any) => c?.type === "text" && typeof c.text === "string")?.text
 		: undefined;
 	if (!text) return isPartial ? "running" : "";
-	const lines = sanitizeToolResultText(text)
+	// Only the first non-empty line / line count is used; bound the scan window.
+	const lines = sanitizeToolResultText(text, 8_192)
 		.trim()
 		.split("\n")
 		.filter((line) => line.trim().length > 0);

package/extensions/context.ts

@@ -213,19 +213,53 @@ export function formatTokens(tokens: number): string {
 	return `${Math.round(tokens / 1_000)}k`;
 }
 
-function collectParts(ctx: ExtensionCommandContext): ContextPart[] {
-	const options = ctx.getSystemPromptOptions();
+type SystemPromptOptions = {
+	contextFiles?: Array<{ path: string; content: string }>;
+	skills?: Array<{
+		name: string;
+		description?: string;
+		filePath?: string;
+		disableModelInvocation?: boolean;
+	}>;
+	selectedTools?: string[];
+	toolSnippets?: Record<string, string>;
+	promptGuidelines?: string[];
+};
+
+type ContextBreakdown = {
+	parts: ContextPart[];
+	options: SystemPromptOptions;
+	systemPrompt: string;
+};
+
+/**
+ * Single pass over prompt options + session entries. Returns options/systemPrompt
+ * so the /context UI does not re-fetch or re-stringify the same sources.
+ */
+function collectContextBreakdown(ctx: ExtensionCommandContext): ContextBreakdown {
+	const options = (ctx.getSystemPromptOptions?.() ?? {}) as SystemPromptOptions;
+	const systemPrompt = typeof ctx.getSystemPrompt === "function" ? ctx.getSystemPrompt() : "";
+
 	const contextFileTokens = (options.contextFiles ?? []).reduce(
 		(sum, file) => sum + tokenEstimate(file.content),
 		0,
 	);
-	const skillTokens = (options.skills ?? []).reduce((sum, skill) => sum + tokenEstimate(skill), 0);
+	// Prefer field-level estimates over JSON.stringify(whole skill).
+	const skillTokens = (options.skills ?? []).reduce((sum, skill) => {
+		if (!skill || typeof skill !== "object") return sum + tokenEstimate(skill);
+		return (
+			sum +
+			tokenEstimate(skill.name) +
+			tokenEstimate(skill.description) +
+			tokenEstimate(skill.filePath)
+		);
+	}, 0);
 	const tools = options.selectedTools ?? [];
-	const toolTokens =
-		tools.reduce(
-			(sum, name) => sum + tokenEstimate(name) + tokenEstimate(options.toolSnippets?.[name]),
-			0,
-		) + tokenEstimate(options.promptGuidelines);
+	const snippets = options.toolSnippets;
+	let toolTokens = tokenEstimate(options.promptGuidelines);
+	for (const name of tools) {
+		toolTokens += tokenEstimate(name) + tokenEstimate(snippets?.[name]);
+	}
 
 	let user = 0;
 	let assistant = 0;
@@ -242,7 +276,7 @@ function collectParts(ctx: ExtensionCommandContext): ContextPart[] {
 		}
 	}
 
-	const systemTotal = tokenEstimate(ctx.getSystemPrompt());
+	const systemTotal = tokenEstimate(systemPrompt);
 	const baseSystem = Math.max(0, systemTotal - contextFileTokens - skillTokens - toolTokens);
 	const parts: ContextPart[] = [
 		{ label: "System prompt", tokens: baseSystem, color: "accent" },
@@ -254,7 +288,11 @@ function collectParts(ctx: ExtensionCommandContext): ContextPart[] {
 		{ label: "Tool results", tokens: toolResults, color: "dim" },
 		{ label: "Compaction summaries", tokens: summaries, color: "success" },
 	];
-	return parts.filter((part) => part.tokens > 0);
+	return {
+		parts: parts.filter((part) => part.tokens > 0),
+		options,
+		systemPrompt,
+	};
 }
 
 export default function contextUsageExtension(pi: ExtensionAPI) {
@@ -263,8 +301,9 @@ export default function contextUsageExtension(pi: ExtensionAPI) {
 		handler: async (_args, ctx) => {
 			const usage = ctx.getContextUsage();
 			const contextWindow = usage?.contextWindow ?? ctx.model?.contextWindow ?? 0;
-			const used = usage?.tokens ?? collectParts(ctx).reduce((sum, part) => sum + part.tokens, 0);
-			const parts = scaleParts(collectParts(ctx), used);
+			const breakdown = collectContextBreakdown(ctx);
+			const used = usage?.tokens ?? breakdown.parts.reduce((sum, part) => sum + part.tokens, 0);
+			const parts = scaleParts(breakdown.parts, used);
 			const free = Math.max(0, contextWindow - used);
 			const allParts = [...parts, { label: "Free space", tokens: free, color: "dim" as const }];
 
@@ -274,7 +313,7 @@ export default function contextUsageExtension(pi: ExtensionAPI) {
 				return;
 			}
 
-			const options = ctx.getSystemPromptOptions();
+			const options = breakdown.options;
 			const toolByName = new Map<string, ToolPreviewInfo>(
 				(pi.getAllTools() as ToolPreviewInfo[]).map((tool) => [tool.name, tool] as const),
 			);
@@ -313,7 +352,7 @@ export default function contextUsageExtension(pi: ExtensionAPI) {
 					key: "systemPrompt",
 					label: "System prompt",
 					title: "System Prompt",
-					content: ctx.getSystemPrompt(),
+					content: breakdown.systemPrompt,
 				},
 				{
 					key: "tools",

package/extensions/session-reference.ts

@@ -66,6 +66,20 @@ type SubagentManager = {
 
 // Local subagent record tracking (pi-subagents does not expose a global manager).
 const liveSubagentRecords = new Map<string, SubagentLiveRecord>();
+/** Cap retained completed/live records so long-lived pi processes cannot grow unbounded. */
+const MAX_LIVE_SUBAGENT_RECORDS = 200;
+
+function pruneLiveSubagentRecords(): void {
+	while (liveSubagentRecords.size > MAX_LIVE_SUBAGENT_RECORDS) {
+		const oldest = liveSubagentRecords.keys().next().value;
+		if (oldest === undefined) break;
+		liveSubagentRecords.delete(oldest);
+	}
+}
+
+function clearLiveSubagentRecords(): void {
+	liveSubagentRecords.clear();
+}
 
 function trackSubagentFromEvent(data: unknown): void {
 	if (!data || typeof data !== "object") return;
@@ -87,6 +101,9 @@ function trackSubagentFromEvent(data: unknown): void {
 				typeof event.endedAt === "number" ? event.endedAt : event.lastUpdate
 			) as number;
 		}
+		// Refresh insertion order so completed-but-still-referenced runs stay recent.
+		liveSubagentRecords.delete(runId);
+		liveSubagentRecords.set(runId, existing);
 		return;
 	}
 	// Started event — create new record
@@ -100,6 +117,7 @@ function trackSubagentFromEvent(data: unknown): void {
 		cwd,
 		startedAt,
 	});
+	pruneLiveSubagentRecords();
 }
 
 function getSubagentManager(): SubagentManager | undefined {
@@ -134,8 +152,14 @@ function formatDate(date: Date): string {
 	}).format(date);
 }
 
+/** Stable across keystrokes while getReferences returns the same reference objects. */
+const sessionSearchTextCache = new WeakMap<SessionReference, string>();
+const sessionItemCache = new WeakMap<SessionReference, { cwd: string; item: AutocompleteItem }>();
+
 function sessionSearchText(reference: SessionReference): string {
-	return [
+	const cached = sessionSearchTextCache.get(reference);
+	if (cached !== undefined) return cached;
+	const text = [
 		reference.info.name,
 		reference.info.firstMessage,
 		reference.info.cwd,
@@ -144,34 +168,65 @@ function sessionSearchText(reference: SessionReference): string {
 	]
 		.filter(Boolean)
 		.join(" ");
+	sessionSearchTextCache.set(reference, text);
+	return text;
 }
 
 function sessionItem(reference: SessionReference, currentCwd: string): AutocompleteItem {
+	const cached = sessionItemCache.get(reference);
+	if (cached && cached.cwd === currentCwd) return cached.item;
+
 	const session = reference.info;
 	const workspace = samePath(session.cwd, currentCwd)
 		? "current workspace"
 		: session.cwd || "unknown workspace";
 	const label = reference.kind === "subagent" ? "[SubAgent]" : "[Session]";
-	return {
+	const item: AutocompleteItem = {
 		value: `${SESSION_REFERENCE_PREFIX}${reference.referenceIds[0]}`,
 		label: `${label} ${sessionTitle(session)}`,
 		description: `${workspace} · ${session.messageCount} messages · ${formatDate(session.modified)}`,
 	};
+	sessionItemCache.set(reference, { cwd: currentCwd, item });
+	return item;
 }
 
-function filterSessions(
+/** Sort cache: same array + cwd reuses order (getReferences returns a stable ordered array). */
+const orderedReferencesCache = new WeakMap<
+	SessionReference[],
+	{ cwd: string; ordered: SessionReference[] }
+>();
+
+function orderSessionReferences(
 	references: SessionReference[],
-	query: string,
 	currentCwd: string,
-): AutocompleteItem[] {
-	if (query.startsWith("session:")) return [];
+): SessionReference[] {
+	const cached = orderedReferencesCache.get(references);
+	if (cached && cached.cwd === currentCwd) return cached.ordered;
 
 	const ordered = [...references].sort((left, right) => {
 		const leftLocal = samePath(left.info.cwd, currentCwd) ? 1 : 0;
 		const rightLocal = samePath(right.info.cwd, currentCwd) ? 1 : 0;
 		return rightLocal - leftLocal || right.info.modified.getTime() - left.info.modified.getTime();
 	});
-	const matches = query.trim() ? fuzzyFilter(ordered, query, sessionSearchText) : ordered;
+	orderedReferencesCache.set(references, { cwd: currentCwd, ordered });
+	// Point the ordered array at itself so subsequent keystrokes skip re-sorting.
+	orderedReferencesCache.set(ordered, { cwd: currentCwd, ordered });
+	return ordered;
+}
+
+function filterSessions(
+	references: SessionReference[],
+	query: string,
+	currentCwd: string,
+): AutocompleteItem[] {
+	if (query.startsWith("session:")) return [];
+
+	const ordered = orderSessionReferences(references, currentCwd);
+	const trimmed = query.trim();
+	// Empty query: top-N already sorted — no fuzzy scan over the full list.
+	const matches = trimmed
+		? fuzzyFilter(ordered, trimmed, sessionSearchText)
+		: ordered.slice(0, MAX_SESSION_SUGGESTIONS);
 	return matches
 		.slice(0, MAX_SESSION_SUGGESTIONS)
 		.map((reference) => sessionItem(reference, currentCwd));
@@ -341,6 +396,7 @@ export default function sessionReferenceExtension(pi: ExtensionAPI): void {
 	pi.on("session_start", (_event, ctx) => {
 		const generation = ++sessionGeneration;
 		subagentIds.clear();
+		clearLiveSubagentRecords();
 		let loadErrorShown = false;
 		const currentSessionId = ctx.sessionManager.getSessionId();
 		const currentSessionFile = ctx.sessionManager.getSessionFile();
@@ -365,8 +421,27 @@ export default function sessionReferenceExtension(pi: ExtensionAPI): void {
 			return sessionsPromise;
 		};
 
-		const getReferences = async (): Promise<SessionReference[]> =>
-			mergeReferences(await getSessions(), liveSubagentReferences(subagentIds, currentSessionId));
+		// Pre-sort once per (sessions list, subagent id set) so @ keystrokes only fuzzy-filter.
+		let referencesCache:
+			| { sessions: SessionInfo[]; subagentKey: string; ordered: SessionReference[] }
+			| undefined;
+		const getReferences = async (): Promise<SessionReference[]> => {
+			const sessions = await getSessions();
+			const subagentKey = [...subagentIds].join("\0");
+			if (
+				referencesCache &&
+				referencesCache.sessions === sessions &&
+				referencesCache.subagentKey === subagentKey
+			) {
+				return referencesCache.ordered;
+			}
+			const ordered = orderSessionReferences(
+				mergeReferences(sessions, liveSubagentReferences(subagentIds, currentSessionId)),
+				ctx.cwd,
+			);
+			referencesCache = { sessions, subagentKey, ordered };
+			return ordered;
+		};
 
 		getAvailableReferences = getReferences;
 		if (ctx.mode === "tui") {
@@ -463,6 +538,7 @@ export default function sessionReferenceExtension(pi: ExtensionAPI): void {
 
 	pi.on("session_before_switch", () => {
 		subagentIds.clear();
+		clearLiveSubagentRecords();
 		getAvailableReferences = undefined;
 	});
 
@@ -470,6 +546,7 @@ export default function sessionReferenceExtension(pi: ExtensionAPI): void {
 		sessionGeneration++;
 		for (const unsubscribe of unsubscribeSubagentEvents) unsubscribe();
 		subagentIds.clear();
+		clearLiveSubagentRecords();
 		getAvailableReferences = undefined;
 	});
 }

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));
 		}
 	};
 }
@@ -2148,28 +2159,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)
@@ -2371,51 +2450,38 @@ export function renderEditDiffResult(
 			}
 
 			const headerRows = renderHeaderRows(parsed.stats, mode, safeWidth, theme);
-			const inlineHighlights = buildInlineHighlightMap(splitRows);
+			const displayLimit = resolveDiffDisplayLimit(
+				options.expanded,
+				config.diffCollapsedLines,
+				config.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,
@@ -2424,6 +2490,7 @@ export function renderEditDiffResult(
 				config.expandedPreviewMaxLines,
 				parsed.stats.hunks,
 				theme,
+				unprocessedLogicalRows,
 			);
 			const frame = renderDiffFrameLine(safeWidth, theme);
 			const renderedLines =
@@ -2593,6 +2660,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 +2700,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 +2713,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;
 }
@@ -2704,9 +2777,6 @@ 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;
@@ -2753,6 +2823,10 @@ 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,
@@ -2787,10 +2861,22 @@ export function renderWriteDiffResult(
 			}
 
 			const data = getDetailedData();
+			const displayLimit = resolveDiffDisplayLimit(
+				options.expanded,
+				config.diffCollapsedLines,
+				config.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,13 +2885,17 @@ 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,
@@ -2815,6 +2905,7 @@ export function renderWriteDiffResult(
 				config.expandedPreviewMaxLines,
 				data.hunkCount,
 				theme,
+				unprocessedLogicalRows,
 			);
 			const frame = renderDiffFrameLine(safeWidth, theme);
 			const renderedLines =