@quandev104/pi-style 0.2.0 → 0.2.1

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

@@ -1,9 +1,46 @@
-import { visibleWidth } from "@earendil-works/pi-tui";
+import { visibleWidth } from "../../shared/ansi.js";
 
 const OSC133_ZONE_START = "\x1b]133;A\x07";
 const OSC133_ZONE_END = "\x1b]133;B\x07";
 const OSC133_ZONE_FINAL = "\x1b]133;C\x07";
 type OscParts = { start: string; body: string; end: string };
+type LineAnalysis = {
+	visibleWidth: number;
+	hasContent: boolean;
+	oscEnvelope: OscParts | undefined;
+	hasOscStart: boolean;
+	leadingMarkers: { head: string; rest: string };
+	isBackgroundWrapped: boolean;
+	backgroundAnsi: string;
+	backgroundBody: string | undefined;
+	backgroundBodyWidth: number | undefined;
+};
+type DecoratedRenderCacheEntry = {
+	nativeRef: readonly string[];
+	nativeLines: readonly string[];
+	result: readonly string[];
+};
+type MessageDecorationTestState = {
+	decoratePasses: number;
+	cacheHits: number;
+	cacheMisses: number;
+	lineCacheHits: number;
+	lineCacheMisses: number;
+};
+
+const BG_RESET = "\x1b[49m";
+const MAX_RENDER_CACHE_KEYS_PER_INSTANCE = 8;
+const MAX_LINE_ANALYSIS_ENTRIES = 4096;
+
+let renderCacheByInstance = new WeakMap<object, Map<string, DecoratedRenderCacheEntry>>();
+let lineAnalysisCache = new Map<string, LineAnalysis>();
+const messageDecorationTestState: MessageDecorationTestState = {
+	decoratePasses: 0,
+	cacheHits: 0,
+	cacheMisses: 0,
+	lineCacheHits: 0,
+	lineCacheMisses: 0,
+};
 
 function extractOscEnvelope(line: string): OscParts | undefined {
 	if (!line.startsWith(OSC133_ZONE_START)) return undefined;
@@ -12,8 +49,6 @@ function extractOscEnvelope(line: string): OscParts | undefined {
 	return { start: OSC133_ZONE_START, body: line.slice(OSC133_ZONE_START.length, bodyEnd), end: line.slice(bodyEnd) };
 }
 
-const BG_RESET = "\x1b[49m";
-
 /** Leading zero-width OSC sequences (e.g. OSC133 markers) of a line. */
 function splitLeadingMarkers(line: string): { head: string; rest: string } {
 	let index = 0;
@@ -51,27 +86,81 @@ function isBackgroundSgr(sequence: string): boolean {
 	return false;
 }
 
-/**
- * Rebuild a native line so `lead` (prompt prefix / continuation indent) and the
- * full target width are covered by the line's background.
- *
- * Native Box lines (user messages) are `bgAnsi + body + \x1b[49m`; prepending the
- * prefix outside that wrap shifted the input row's background right by the
- * prefix width while keeping the full container width, producing a staircase
- * box (indented left, overflowing right). Rebuilding inside the wrap keeps the
- * background flush across every row; plain (unwrapped) lines are padded to the
- * target width instead so left/right edges stay aligned.
- */
-function rebuildAtWidth(line: string, width: number, lead: string): string {
-	const { head, rest } = splitLeadingMarkers(line);
-	const bgAnsi = leadingSgr(rest);
-	if (bgAnsi && isBackgroundSgr(bgAnsi) && rest.endsWith(BG_RESET)) {
-		const body = rest.slice(bgAnsi.length, rest.length - BG_RESET.length);
-		const pad = " ".repeat(Math.max(0, width - visibleWidth(lead) - visibleWidth(body)));
-		return `${head}${bgAnsi}${lead}${body}${pad}${BG_RESET}`;
+function contentText(line: string): string {
+	let output = "";
+	for (let index = 0; index < line.length; index++) {
+		if (line.charCodeAt(index) !== 27) {
+			output += line[index];
+			continue;
+		}
+		const next = line[index + 1];
+		if (next === "]") {
+			index += 2;
+			while (index < line.length && line.charCodeAt(index) !== 7) index++;
+			continue;
+		}
+		if (next === "[") {
+			index += 2;
+			while (index < line.length && (line.charCodeAt(index) < 64 || line.charCodeAt(index) > 126)) index++;
+		}
+	}
+	return output.replaceAll(OSC133_ZONE_START, "").replaceAll(OSC133_ZONE_END, "").replaceAll(OSC133_ZONE_FINAL, "");
+}
+
+function hasContent(line: string): boolean {
+	return [...contentText(line)].some((character) => !/\s/u.test(character));
+}
+
+function getLineAnalysis(line: string): LineAnalysis {
+	const cached = lineAnalysisCache.get(line);
+	if (cached) {
+		messageDecorationTestState.lineCacheHits++;
+		return cached;
+	}
+	messageDecorationTestState.lineCacheMisses++;
+	const leadingMarkers = splitLeadingMarkers(line);
+	const backgroundAnsi = leadingSgr(leadingMarkers.rest);
+	const isBackgroundWrapped =
+		backgroundAnsi !== "" && isBackgroundSgr(backgroundAnsi) && leadingMarkers.rest.endsWith(BG_RESET);
+	const backgroundBody = isBackgroundWrapped
+		? leadingMarkers.rest.slice(backgroundAnsi.length, leadingMarkers.rest.length - BG_RESET.length)
+		: undefined;
+	const analysis: LineAnalysis = {
+		visibleWidth: visibleWidth(line),
+		hasContent: hasContent(line),
+		oscEnvelope: extractOscEnvelope(line),
+		hasOscStart: line.startsWith(OSC133_ZONE_START),
+		leadingMarkers,
+		isBackgroundWrapped,
+		backgroundAnsi,
+		backgroundBody,
+		backgroundBodyWidth: backgroundBody === undefined ? undefined : visibleWidth(backgroundBody),
+	};
+	lineAnalysisCache.set(line, analysis);
+	if (lineAnalysisCache.size > MAX_LINE_ANALYSIS_ENTRIES) {
+		const oldestKey = lineAnalysisCache.keys().next().value;
+		if (oldestKey !== undefined) lineAnalysisCache.delete(oldestKey);
+	}
+	return analysis;
+}
+
+function rebuildAtWidth(
+	line: string,
+	width: number,
+	lead: string,
+	leadWidth: number,
+	analysis = getLineAnalysis(line),
+): string {
+	if (
+		analysis.isBackgroundWrapped &&
+		analysis.backgroundBody !== undefined &&
+		analysis.backgroundBodyWidth !== undefined
+	) {
+		const pad = " ".repeat(Math.max(0, width - leadWidth - analysis.backgroundBodyWidth));
+		return `${analysis.leadingMarkers.head}${analysis.backgroundAnsi}${lead}${analysis.backgroundBody}${pad}${BG_RESET}`;
 	}
-	const padded = `${lead}${line}`;
-	return `${padded}${" ".repeat(Math.max(0, width - visibleWidth(padded)))}`;
+	const pad = " ".repeat(Math.max(0, width - leadWidth - analysis.visibleWidth));
+	return `${lead}${line}${pad}`;
 }
 
 function decorateMessageLine(
@@ -85,20 +174,23 @@ function decorateMessageLine(
 		firstHasStart: boolean;
 		multilineEnvelope: boolean;
 		prefix: string;
+		prefixWidth: number;
 	},
+	analysis = getLineAnalysis(line),
 ): string {
-	const { firstEnvelope, firstHasStart, multilineEnvelope, prefix } = options;
-	const prefixWidth = visibleWidth(prefix);
+	const { firstEnvelope, firstHasStart, multilineEnvelope, prefix, prefixWidth } = options;
 	const lead = index === contentIndex ? prefix : index > contentIndex ? " ".repeat(prefixWidth) : "";
+	const leadWidth = index < contentIndex ? 0 : prefixWidth;
 	if (index === contentIndex && firstEnvelope)
-		return `${firstEnvelope.start}${rebuildAtWidth(firstEnvelope.body, width, prefix)}${firstEnvelope.end}`;
+		return `${firstEnvelope.start}${rebuildAtWidth(firstEnvelope.body, width, prefix, prefixWidth)}${firstEnvelope.end}`;
 	if (index === contentIndex && firstHasStart)
-		return `${OSC133_ZONE_START}${rebuildAtWidth(line.slice(OSC133_ZONE_START.length), width, prefix)}`;
+		return `${OSC133_ZONE_START}${rebuildAtWidth(line.slice(OSC133_ZONE_START.length), width, prefix, prefixWidth)}`;
 	if (index === lastIndex && multilineEnvelope && index !== contentIndex)
 		return `${OSC133_ZONE_END}${OSC133_ZONE_FINAL}${rebuildAtWidth(
 			line.slice((OSC133_ZONE_END + OSC133_ZONE_FINAL).length),
 			width,
 			lead,
+			leadWidth,
 		)}`;
 	if (
 		index === contentIndex &&
@@ -110,43 +202,61 @@ function decorateMessageLine(
 			line.slice((OSC133_ZONE_END + OSC133_ZONE_FINAL).length),
 			width,
 			prefix,
+			prefixWidth,
 		)}`;
-	return rebuildAtWidth(line, width, lead);
+	return rebuildAtWidth(line, width, lead, leadWidth, analysis);
 }
 
-function contentText(line: string): string {
-	let output = "";
-	for (let index = 0; index < line.length; index++) {
-		if (line.charCodeAt(index) !== 27) {
-			output += line[index];
-			continue;
-		}
-		const next = line[index + 1];
-		if (next === "]") {
-			index += 2;
-			while (index < line.length && line.charCodeAt(index) !== 7) index++;
-			continue;
-		}
-		if (next === "[") {
-			index += 2;
-			while (index < line.length && (line.charCodeAt(index) < 64 || line.charCodeAt(index) > 126)) index++;
-		}
+function sameLines(left: readonly string[], right: readonly string[]): boolean {
+	if (left === right) return true;
+	if (left.length !== right.length) return false;
+	for (let index = 0; index < left.length; index++) {
+		if (left[index] !== right[index]) return false;
 	}
-	return output.replaceAll(OSC133_ZONE_START, "").replaceAll(OSC133_ZONE_END, "").replaceAll(OSC133_ZONE_FINAL, "");
+	return true;
 }
 
-function hasContent(line: string): boolean {
-	return [...contentText(line)].some((character) => !/\s/u.test(character));
+function cacheKey(width: number, prefix: string): string {
+	return `${width}\u0000${prefix}`;
+}
+
+function getRenderCache(instance: object): Map<string, DecoratedRenderCacheEntry> {
+	let cache = renderCacheByInstance.get(instance);
+	if (!cache) {
+		cache = new Map();
+		renderCacheByInstance.set(instance, cache);
+	}
+	return cache;
+}
+
+function storeRenderCache(
+	instance: object,
+	width: number,
+	prefix: string,
+	native: readonly string[],
+	result: readonly string[],
+): void {
+	const cache = getRenderCache(instance);
+	const key = cacheKey(width, prefix);
+	if (cache.has(key)) cache.delete(key);
+	cache.set(key, { nativeRef: native, nativeLines: [...native], result: [...result] });
+	while (cache.size > MAX_RENDER_CACHE_KEYS_PER_INSTANCE) {
+		const oldestKey = cache.keys().next().value;
+		if (oldestKey === undefined) break;
+		cache.delete(oldestKey);
+	}
 }
 
 function prefixNative(lines: unknown, width: number, prefix: string): string[] | undefined {
 	if (!Array.isArray(lines) || lines.length === 0 || !lines.every((line) => typeof line === "string")) return undefined;
+	messageDecorationTestState.decoratePasses++;
 	const nativeLines = lines as string[];
 	const prefixWidth = visibleWidth(prefix);
 	if (width <= prefixWidth) return undefined;
 	const bodyWidth = width - prefixWidth;
 	const first = nativeLines[0] ?? "";
 	const last = nativeLines.at(-1) ?? "";
+	const lastAnalysis = getLineAnalysis(last);
 	const multilineEnvelope = nativeLines.length > 1 && last.startsWith(OSC133_ZONE_END + OSC133_ZONE_FINAL);
 	// The last line is a content-start candidate only when the envelope is
 	// single-line, or when no earlier line carries content. Assistant messages
@@ -154,22 +264,26 @@ function prefixNative(lines: unknown, width: number, prefix: string): string[] |
 	// sits on the final line ([OSC133_A, OSC133_END+FINAL+body]); excluding it
 	// would drop the prefix for every short assistant reply.
 	const firstContentIndex = nativeLines.findIndex((line, index) => {
-		if (index !== nativeLines.length - 1 || !multilineEnvelope) return hasContent(line);
-		return !nativeLines.slice(0, index).some((earlier) => hasContent(earlier)) && hasContent(line);
+		if (index !== nativeLines.length - 1 || !multilineEnvelope) return getLineAnalysis(line).hasContent;
+		return (
+			!nativeLines.slice(0, index).some((earlier) => getLineAnalysis(earlier).hasContent) && lastAnalysis.hasContent
+		);
 	});
 	if (firstContentIndex < 0) return nativeLines;
-	const firstEnvelope = firstContentIndex === 0 ? extractOscEnvelope(first) : undefined;
-	const firstHasStart = firstContentIndex === 0 && first.startsWith(OSC133_ZONE_START);
+	const firstAnalysis = getLineAnalysis(first);
+	const firstEnvelope = firstContentIndex === 0 ? firstAnalysis.oscEnvelope : undefined;
+	const firstHasStart = firstContentIndex === 0 && firstAnalysis.hasOscStart;
 	const decorated = nativeLines.map((line, index) =>
 		decorateMessageLine(line, index, nativeLines.length - 1, firstContentIndex, width, {
 			firstEnvelope,
 			firstHasStart,
 			multilineEnvelope,
 			prefix,
+			prefixWidth,
 		}),
 	);
 	if (!decorated.every((line) => visibleWidth(line) <= width)) return undefined;
-	if (!nativeLines.every((line) => visibleWidth(line) <= bodyWidth)) return undefined;
+	if (!nativeLines.every((line) => getLineAnalysis(line).visibleWidth <= bodyWidth)) return undefined;
 	return decorated;
 }
 
@@ -182,6 +296,20 @@ export type MessageDecorationSnapshot = Readonly<{
 	hideInterimText: boolean;
 }>;
 
+export function __getMessageDecorationTestState(): Readonly<MessageDecorationTestState> {
+	return { ...messageDecorationTestState };
+}
+
+export function __resetMessageDecorationTestState(): void {
+	messageDecorationTestState.decoratePasses = 0;
+	messageDecorationTestState.cacheHits = 0;
+	messageDecorationTestState.cacheMisses = 0;
+	messageDecorationTestState.lineCacheHits = 0;
+	messageDecorationTestState.lineCacheMisses = 0;
+	renderCacheByInstance = new WeakMap<object, Map<string, DecoratedRenderCacheEntry>>();
+	lineAnalysisCache = new Map<string, LineAnalysis>();
+}
+
 export function decorateMessageRender(
 	original: unknown,
 	instance: object,
@@ -197,12 +325,22 @@ export function decorateMessageRender(
 	const width = typeof args[0] === "number" ? args[0] : 0;
 	const prefix = snapshot.assistantPrefix;
 	if (!snapshot.assistantEnabled) return Reflect.apply(original, instance, args);
-	if (width <= visibleWidth(prefix)) return Reflect.apply(original, instance, args);
+	const prefixWidth = visibleWidth(prefix);
+	if (width <= prefixWidth) return Reflect.apply(original, instance, args);
 	// Exactly one native invocation. If the reduced render cannot be certified, the
 	// already-obtained result is the only safe fallback; retrying can mutate state.
-	const reducedWidth = width - visibleWidth(prefix);
+	const reducedWidth = width - prefixWidth;
 	const native = Reflect.apply(original, instance, [reducedWidth, ...args.slice(1)]);
-	return prefixNative(native, width, prefix) ?? native;
+	if (!Array.isArray(native) || !native.every((line) => typeof line === "string")) return native;
+	const cached = getRenderCache(instance).get(cacheKey(width, prefix));
+	if (cached && (cached.nativeRef === native || sameLines(cached.nativeLines, native))) {
+		messageDecorationTestState.cacheHits++;
+		return [...cached.result];
+	}
+	messageDecorationTestState.cacheMisses++;
+	const decorated = prefixNative(native, width, prefix) ?? native;
+	storeRenderCache(instance, width, prefix, native, decorated);
+	return decorated;
 }
 
 /** Spacer-like: renders empty lines and exposes only setLines among these surfaces. */

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

@@ -19,6 +19,7 @@ import {
 	boxLine,
 	boxWidth,
 	formatBoxedRunningStatus,
+	themeCacheKey,
 } from "../../shared/box.js";
 import { getThemeExtra } from "../../shared/theme-extras.js";
 
@@ -30,6 +31,11 @@ export function setBashExecutionTheme(theme: BoxTheme | undefined): void {
 }
 
 /** Structural view of the native BashExecutionComponent as used by the patch. */
+interface BashExecutionRenderCache {
+	key: string;
+	lines: string[];
+}
+
 interface BashExecutionInstance {
 	command: string;
 	status: "running" | "cancelled" | "error" | "complete";
@@ -37,6 +43,7 @@ interface BashExecutionInstance {
 	contentContainer: { render(width: number): string[] };
 	/** Wall-clock start captured on the first boxed render for the live `◌ Running · Ns` footer. */
 	piStyleStart?: number;
+	piStyleRenderCache?: BashExecutionRenderCache;
 }
 
 const TOP_LEFT = "╭";
@@ -92,13 +99,15 @@ export function renderBashExecutionBox(instance: unknown, args: unknown[]): stri
 	try {
 		if (host.piStyleStart === undefined) host.piStyleStart = Date.now();
 		const renderedWidth = boxWidth(width);
+		const cacheKey = `${themeCacheKey(theme)}|${width}|${host.status}|${host.exitCode ?? ""}|${host.command}`;
+		if (host.status !== "running" && host.piStyleRenderCache?.key === cacheKey) return host.piStyleRenderCache.lines;
 		const inner = boxInnerWidth(renderedWidth);
 		// The native Text children render one leading padding space per line;
 		// drop it so boxLine's own side padding produces symmetric borders.
 		const wrapped = content
 			.render(inner)
 			.map((line) => boxLine(theme, line.startsWith(" ") ? line.slice(1) : line, renderedWidth));
-		return [
+		const lines = [
 			"",
 			boxLabeledBorder(theme, TOP_LEFT, TOP_RIGHT, bashBoxTitle(theme, host), undefined, renderedWidth),
 			boxBlankLine(theme, renderedWidth),
@@ -106,6 +115,8 @@ export function renderBashExecutionBox(instance: unknown, args: unknown[]): stri
 			boxBlankLine(theme, renderedWidth),
 			boxLabeledBorder(theme, BOTTOM_LEFT, BOTTOM_RIGHT, bashBoxFooter(theme, host), undefined, renderedWidth),
 		];
+		if (host.status !== "running") host.piStyleRenderCache = { key: cacheKey, lines };
+		return lines;
 	} catch {
 		return undefined;
 	}

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

@@ -15,6 +15,7 @@ import {
 	renderBoxedToolResult,
 	replaceTabs,
 	shortenPath,
+	themeCacheKey,
 } from "../../../shared/box.js";
 import { safeTruncateToWidth, truncateAtCodePointBoundary } from "../../../shared/render-budget.js";
 import { parseSimpleBashCommand } from "./command-shape.js";
@@ -52,6 +53,7 @@ import {
 } from "./output-tree.js";
 import {
 	getStateElapsedMs,
+	getToolsRenderCacheSignature,
 	getToolsRenderConfig,
 	isResultSeen,
 	markResultSeen,
@@ -59,7 +61,14 @@ import {
 	startElapsedTicker,
 	stopElapsedTicker,
 } from "./session-config.js";
-import { type BoxedToolContext, type BoxedToolDefinition, noteBoxedCallState, noteExecutionStart } from "./shared.js";
+import {
+	type BoxedToolContext,
+	type BoxedToolDefinition,
+	getRenderCacheKey,
+	memoizedStateComponent,
+	noteBoxedCallState,
+	noteExecutionStart,
+} from "./shared.js";
 
 const MAX_LINE_CHARS = 2000;
 const ESC = "\x1b";
@@ -754,13 +763,21 @@ function parseBashTreeOutput(cls: BashTreeClass, output: string): ParsedBashTree
 	return { matches };
 }
 
+type FinalSemanticRenderCache = {
+	key: string;
+	lines: string[];
+};
+
 interface BashTreeState {
-	readonly cls: BashSemanticClass;
+	cls: BashSemanticClass;
 	/** Raw command, so the call panel can render the boxed bash call on fallback. */
-	readonly command: string;
+	command: string;
 	/** `parsed` once the result arrives; `fallback` when the boxed shell takes over. */
 	parsed?: ParsedSemantic;
 	fallback?: boolean;
+	finished: boolean;
+	revision: number;
+	renderCache?: FinalSemanticRenderCache;
 }
 
 /** Classified semantic command: a bash tree (ls/find/grep), a git card, or a
@@ -879,29 +896,37 @@ function renderSemanticPanel(theme: BoxTheme, toolCallId: string, context: Boxed
 		invalidate() {},
 		render(width: number): string[] {
 			if (!state) return [];
-			if (state.fallback) {
-				return renderBoxedBashCall(
-					theme,
-					state.command.split("\n"),
-					context,
-					bashWidthKey(state.command, context?.args?.timeout),
-				).render(width);
-			}
-			if (isBashTreeClass(state.cls)) {
-				const treeState: { cls: BashTreeClass; parsed?: ParsedBashTree } = { cls: state.cls };
-				if (state.parsed !== undefined) treeState.parsed = state.parsed as ParsedBashTree;
-				return renderBashTreeLines(theme, treeState, width);
-			}
-			// Git classes only ever carry git parsed values (parseSemanticOutput
-			// dispatches on the class), so the narrowed cast is exact.
-			if (isGhClass(state.cls)) {
-				const ghState: { cls: GhSemanticClass; parsed?: GhParsedSemantic } = { cls: state.cls };
-				if (state.parsed !== undefined) ghState.parsed = state.parsed as GhParsedSemantic;
-				return renderGhCardLines(theme, ghState, width);
-			}
-			const gitState: { cls: GitSemanticClass; parsed?: GitParsedSemantic } = { cls: state.cls };
-			if (state.parsed !== undefined) gitState.parsed = state.parsed as GitParsedSemantic;
-			return renderGitCardLines(theme, gitState, width);
+			const renderFresh = () => {
+				if (state.fallback) {
+					return renderBoxedBashCall(
+						theme,
+						state.command.split("\n"),
+						context,
+						bashWidthKey(state.command, context?.args?.timeout),
+					).render(width);
+				}
+				if (isBashTreeClass(state.cls)) {
+					const treeState: { cls: BashTreeClass; parsed?: ParsedBashTree } = { cls: state.cls };
+					if (state.parsed !== undefined) treeState.parsed = state.parsed as ParsedBashTree;
+					return renderBashTreeLines(theme, treeState, width);
+				}
+				// Git classes only ever carry git parsed values (parseSemanticOutput
+				// dispatches on the class), so the narrowed cast is exact.
+				if (isGhClass(state.cls)) {
+					const ghState: { cls: GhSemanticClass; parsed?: GhParsedSemantic } = { cls: state.cls };
+					if (state.parsed !== undefined) ghState.parsed = state.parsed as GhParsedSemantic;
+					return renderGhCardLines(theme, ghState, width);
+				}
+				const gitState: { cls: GitSemanticClass; parsed?: GitParsedSemantic } = { cls: state.cls };
+				if (state.parsed !== undefined) gitState.parsed = state.parsed as GitParsedSemantic;
+				return renderGitCardLines(theme, gitState, width);
+			};
+			if (!state.finished) return renderFresh();
+			const cacheKey = [themeCacheKey(theme), getToolsRenderCacheSignature(), width, state.revision].join("|");
+			if (state.renderCache?.key === cacheKey) return state.renderCache.lines;
+			const lines = renderFresh();
+			state.renderCache = { key: cacheKey, lines };
+			return lines;
 		},
 	};
 }
@@ -911,7 +936,26 @@ export const bashTool: BoxedToolDefinition = {
 		noteExecutionStart(context);
 		const cls = classifyBashSemantic(String(args?.command ?? ""));
 		if (cls) {
-			semanticStates.set(context.toolCallId, { cls, command: String(args?.command ?? "") });
+			const command = String(args?.command ?? "");
+			const existing = semanticStates.get(context.toolCallId);
+			if (existing) {
+				if (existing.command !== command || existing.cls.kind !== cls.kind) {
+					delete existing.parsed;
+					delete existing.fallback;
+					existing.finished = false;
+					existing.revision++;
+					delete existing.renderCache;
+				}
+				existing.command = command;
+				existing.cls = cls;
+			} else {
+				semanticStates.set(context.toolCallId, {
+					cls,
+					command,
+					finished: false,
+					revision: 0,
+				});
+			}
 			return renderSemanticPanel(theme, context.toolCallId, context);
 		}
 		noteBoxedCallState(context);
@@ -939,12 +983,18 @@ export const bashTool: BoxedToolDefinition = {
 				const parsed = parseSemanticOutput(cls, output);
 				const state = semanticStates.get(context.toolCallId);
 				if (parsed) {
-					if (state) state.parsed = parsed;
-					else
+					if (state) {
+						state.parsed = parsed;
+						state.finished = !options.isPartial;
+						state.revision++;
+						delete state.renderCache;
+					} else
 						semanticStates.set(context.toolCallId, {
 							cls,
 							command: String(context?.args?.command ?? ""),
 							parsed,
+							finished: !options.isPartial,
+							revision: 0,
 						});
 					// `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
@@ -961,7 +1011,12 @@ export const bashTool: BoxedToolDefinition = {
 				// 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;
+				if (state) {
+					state.fallback = true;
+					state.finished = !options.isPartial;
+					state.revision++;
+					delete state.renderCache;
+				}
 			}
 		} else if (options.isPartial) {
 			startElapsedTicker(context.state, context.invalidate);
@@ -976,6 +1031,19 @@ export const bashTool: BoxedToolDefinition = {
 			if (firstResultPass) return EMPTY_BASH_RESULT;
 			return renderBashStreamingResult(theme, raw, options, context);
 		}
-		return renderBashFinalResult(theme, raw, options, context);
+		return memoizedStateComponent(
+			context.state,
+			"__piStyleBashFinalResult",
+			getRenderCacheKey(
+				"bash-final-result",
+				theme,
+				Boolean(options.expanded),
+				Boolean(context.isError),
+				String(context?.args?.command ?? ""),
+				raw,
+				getStateElapsedMs(context.state) ?? "",
+			),
+			() => renderBashFinalResult(theme, raw, options, context),
+		);
 	},
 };