@quandev104/pi-style 0.2.0 → 0.2.2

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/compatibility-probe.ts

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

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

@@ -7,16 +7,16 @@ import {
 	invalidateTurnMembers,
 	rebuildTurnRegistryFromEntries,
 	registerTurnFromMessage,
+	releaseTurnInvalidators,
 } from "../features/tools/boxed/turn-summary.js";
 import { requestToolPresentationRender } from "../features/tools/index.js";
 import { registerPiStyleCommand } from "./commands.js";
 import { type CompatibilityTestHooks, createPiStyleSessionCoordinator } from "./session-coordinator.js";
-import { usageFromSession } from "./session-usage.js";
+import { resetUsageFromSessionCache, usageFromSession } from "./session-usage.js";
 
-/** Usage patch that omits the key when no session usage exists (exact optional types). */
+/** Usage patch clears stale usage when the active branch/session has none. */
 function usagePatch(ctx: ExtensionContext): StatusSnapshot {
-	const usage = usageFromSession(ctx.sessionManager);
-	return usage ? { usage } : {};
+	return { usage: usageFromSession(ctx.sessionManager) } as StatusSnapshot;
 }
 
 /**
@@ -65,6 +65,7 @@ export default function piStyleExtension(pi: ExtensionAPI): void {
 	const coordinator = createPiStyleSessionCoordinator(pi, compatibilityTestHooks);
 	registerPiStyleCommand(pi, coordinator.app);
 	pi.on("session_start", async (event, ctx) => {
+		resetUsageFromSessionCache(ctx.sessionManager);
 		// Pi only activates read/bash/edit/write by default; grep/find/ls are
 		// registered but inactive (kept out of the model's tool list to keep the
 		// core small). Activate them so the TUI shows them and the model can call
@@ -110,7 +111,9 @@ export default function piStyleExtension(pi: ExtensionAPI): void {
 		),
 	);
 	pi.on("thinking_level_select", (event) => coordinator.app.update({ thinkingLevel: event.level }, "immediate"));
-	pi.on("session_info_changed", (event) => coordinator.app.update({ sessionName: event.name }, "coalesced"));
+	pi.on("session_info_changed", (event) =>
+		coordinator.app.update({ sessionName: event.name }, "coalesced", { refreshExtensionStatuses: true }),
+	);
 	pi.on("message_start", () => {
 		// A new message is a batch boundary: quiet-tool (read/ls/find) calls of the
 		// new message start a fresh batch instead of joining the previous one.
@@ -123,11 +126,13 @@ export default function piStyleExtension(pi: ExtensionAPI): void {
 	// Usage (tokens + cost) is aggregated from finalized session entries at
 	// message/turn boundaries, mirroring Pi's native footer; per-chunk updates
 	// stay usage-free to keep streaming cheap.
-	pi.on("message_end", (_event, ctx) => coordinator.app.update({ ...usagePatch(ctx) }, "coalesced"));
+	pi.on("message_end", (_event, ctx) =>
+		coordinator.app.update({ ...usagePatch(ctx) }, "coalesced", { refreshContextUsage: true }),
+	);
 	pi.on("turn_end", (event, ctx) => {
 		// Append the finalized assistant message's tool batch to the current run.
 		registerTurnFromMessage(event.message, event.toolResults);
-		coordinator.app.update({ ...usagePatch(ctx) }, "deferred");
+		coordinator.app.update({ ...usagePatch(ctx) }, "deferred", { refreshContextUsage: true });
 	});
 	pi.on("agent_end", () => {
 		// The run is complete: collapse its tool blocks into one summary line.
@@ -138,26 +143,36 @@ export default function piStyleExtension(pi: ExtensionAPI): void {
 		const run = finishAgentRun();
 		if (run) {
 			invalidateTurnMembers(run);
+			releaseTurnInvalidators(run);
 			requestToolPresentationRender();
 		}
 	});
-	pi.on("agent_settled", (_event, ctx) => coordinator.app.update({ ...usagePatch(ctx) }, "coalesced"));
+	pi.on("agent_settled", (_event, ctx) =>
+		coordinator.app.update({ ...usagePatch(ctx) }, "coalesced", { refreshContextUsage: true }),
+	);
 	pi.on("session_tree", (_event, ctx) => {
+		resetUsageFromSessionCache(ctx.sessionManager);
 		// Rebuild the turn registry from session content so restored/branched
 		// history renders collapsed consistently (no in-process turn_end events).
 		rebuildTurnRegistryFromEntries(ctx.sessionManager.getEntries());
-		coordinator.app.update({ ...usagePatch(ctx) }, "deferred");
+		coordinator.app.update({ ...usagePatch(ctx) }, "deferred", { refreshContextUsage: true });
+	});
+	pi.on("session_compact", (_event, ctx) => {
+		resetUsageFromSessionCache(ctx.sessionManager);
+		coordinator.app.update({ ...usagePatch(ctx) }, "deferred", { refreshContextUsage: true });
 	});
-	pi.on("session_compact", (_event, ctx) => coordinator.app.update({ ...usagePatch(ctx) }, "deferred"));
 	pi.on("tool_result", (event, ctx) => {
 		if (["write", "edit", "bash"].includes(event.toolName)) {
 			coordinator.app.runtime.current?.invalidateGit();
-			coordinator.app.update({ ...usagePatch(ctx) }, "delayed-retry");
+			coordinator.app.update({ ...usagePatch(ctx) }, "delayed-retry", { refreshContextUsage: true });
 		}
 	});
 	pi.on("user_bash", (_event, ctx) => {
 		coordinator.app.runtime.current?.invalidateGit();
-		coordinator.app.update({ ...usagePatch(ctx) }, "delayed-retry");
+		coordinator.app.update({ ...usagePatch(ctx) }, "delayed-retry", { refreshContextUsage: true });
+	});
+	pi.on("session_shutdown", (_event, ctx) => {
+		resetUsageFromSessionCache(ctx.sessionManager);
+		coordinator.shutdown();
 	});
-	pi.on("session_shutdown", () => coordinator.shutdown());
 }

package/extension-src/pi-style/pi/session-usage.ts

@@ -18,27 +18,197 @@ interface UsageTotals {
 	cost: number;
 }
 
+interface UsageContribution extends UsageTotals {
+	sawUsage: boolean;
+}
+
+interface SessionUsageCacheState {
+	processedLength: number;
+	lastEntryId: string | undefined;
+	lastEntryRef: SessionEntry | undefined;
+	lastContribution: UsageContribution;
+	totals: UsageTotals;
+	cached: UsageSnapshot | undefined;
+	scannedEntries: number;
+	cacheHits: number;
+	rebuilds: number;
+	tailRefreshes: number;
+}
+
+export interface SessionUsageCacheStats {
+	processedLength: number;
+	scannedEntries: number;
+	cacheHits: number;
+	rebuilds: number;
+	tailRefreshes: number;
+}
+
+let usageCache = new WeakMap<SessionUsageSource, SessionUsageCacheState>();
+
 /**
- * Aggregate cumulative token/cost usage from all session entries, mirroring
- * Pi's native footer: assistant messages always carry usage, tool results and
- * compaction/branch summaries carry it when available.
+ * Aggregate cumulative token/cost usage from finalized session entries,
+ * mirroring Pi's native footer. The result is cached incrementally so repeated
+ * reads only scan appended entries and refresh the finalized tail entry when it
+ * changes in place.
  */
 export function usageFromSession(session: SessionUsageSource): UsageSnapshot | undefined {
-	const totals: UsageTotals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
-	let sawUsage = false;
-	for (const entry of session.getEntries()) {
-		if (entry.type === "message") {
-			if (entry.message.role !== "assistant" && entry.message.role !== "toolResult") continue;
-			const usage = "usage" in entry.message ? entry.message.usage : undefined;
-			if (!usage) continue;
-			addUsage(totals, usage);
-			sawUsage = true;
-		} else if ((entry.type === "branch_summary" || entry.type === "compaction") && entry.usage) {
-			addUsage(totals, entry.usage);
-			sawUsage = true;
+	const entries = session.getEntries();
+	const state = usageCache.get(session) ?? createState();
+	usageCache.set(session, state);
+
+	if (entries.length === 0) {
+		state.cacheHits++;
+		state.processedLength = 0;
+		state.lastEntryId = undefined;
+		state.lastEntryRef = undefined;
+		state.lastContribution = emptyContribution();
+		state.totals = emptyTotals();
+		state.cached = undefined;
+		return undefined;
+	}
+
+	if (state.processedLength === 0) {
+		rebuildFrom(entries, state);
+		return state.cached;
+	}
+
+	if (entries.length < state.processedLength) {
+		rebuildFrom(entries, state);
+		return state.cached;
+	}
+
+	const currentLast = entries.at(-1);
+	if (!currentLast) {
+		state.cacheHits++;
+		state.cached = undefined;
+		return undefined;
+	}
+
+	if (entries.length === state.processedLength) {
+		if (currentLast.id !== state.lastEntryId) {
+			rebuildFrom(entries, state);
+			return state.cached;
 		}
+		if (currentLast !== state.lastEntryRef) refreshTailEntry(currentLast, state);
+		else state.cacheHits++;
+		return state.cached;
+	}
+
+	const previousLast = entries[state.processedLength - 1];
+	if (!previousLast || previousLast.id !== state.lastEntryId) {
+		rebuildFrom(entries, state);
+		return state.cached;
 	}
-	if (!sawUsage) return undefined;
+	if (previousLast !== state.lastEntryRef) refreshTailEntry(previousLast, state);
+	for (const entry of entries.slice(state.processedLength)) appendEntry(entry, state);
+	return state.cached;
+}
+
+export function resetUsageFromSessionCache(session?: SessionUsageSource): void {
+	if (session) {
+		usageCache.delete(session);
+		return;
+	}
+	usageCache = new WeakMap<SessionUsageSource, SessionUsageCacheState>();
+}
+
+export function getUsageFromSessionCacheStats(session: SessionUsageSource): SessionUsageCacheStats {
+	const state = usageCache.get(session) ?? createState();
+	if (!usageCache.has(session)) usageCache.set(session, state);
+	return {
+		processedLength: state.processedLength,
+		scannedEntries: state.scannedEntries,
+		cacheHits: state.cacheHits,
+		rebuilds: state.rebuilds,
+		tailRefreshes: state.tailRefreshes,
+	};
+}
+
+function createState(): SessionUsageCacheState {
+	return {
+		processedLength: 0,
+		lastEntryId: undefined,
+		lastEntryRef: undefined,
+		lastContribution: emptyContribution(),
+		totals: emptyTotals(),
+		cached: undefined,
+		scannedEntries: 0,
+		cacheHits: 0,
+		rebuilds: 0,
+		tailRefreshes: 0,
+	};
+}
+
+function rebuildFrom(entries: readonly SessionEntry[], state: SessionUsageCacheState): void {
+	state.rebuilds++;
+	state.processedLength = 0;
+	state.lastEntryId = undefined;
+	state.lastEntryRef = undefined;
+	state.lastContribution = emptyContribution();
+	state.totals = emptyTotals();
+	state.cached = undefined;
+	for (const entry of entries) appendEntry(entry, state);
+}
+
+function refreshTailEntry(entry: SessionEntry, state: SessionUsageCacheState): void {
+	state.tailRefreshes++;
+	subtractContribution(state.totals, state.lastContribution);
+	const contribution = usageContribution(entry);
+	addContribution(state.totals, contribution);
+	state.lastEntryId = entry.id;
+	state.lastEntryRef = entry;
+	state.lastContribution = contribution;
+	state.cached = snapshotFromTotals(state.totals);
+	state.scannedEntries++;
+}
+
+function appendEntry(entry: SessionEntry, state: SessionUsageCacheState): void {
+	const contribution = usageContribution(entry);
+	addContribution(state.totals, contribution);
+	state.processedLength++;
+	state.lastEntryId = entry.id;
+	state.lastEntryRef = entry;
+	state.lastContribution = contribution;
+	state.cached = snapshotFromTotals(state.totals);
+	state.scannedEntries++;
+}
+
+function usageContribution(entry: SessionEntry): UsageContribution {
+	if (entry.type === "message") {
+		if (entry.message.role !== "assistant" && entry.message.role !== "toolResult") return emptyContribution();
+		const usage = "usage" in entry.message ? entry.message.usage : undefined;
+		if (!usage) return emptyContribution();
+		return {
+			input: usage.input,
+			output: usage.output,
+			cacheRead: usage.cacheRead,
+			cacheWrite: usage.cacheWrite,
+			cost: usage.cost.total,
+			sawUsage: true,
+		};
+	}
+	if ((entry.type === "branch_summary" || entry.type === "compaction") && entry.usage) {
+		return {
+			input: entry.usage.input,
+			output: entry.usage.output,
+			cacheRead: entry.usage.cacheRead,
+			cacheWrite: entry.usage.cacheWrite,
+			cost: entry.usage.cost.total,
+			sawUsage: true,
+		};
+	}
+	return emptyContribution();
+}
+
+function snapshotFromTotals(totals: UsageTotals): UsageSnapshot | undefined {
+	if (
+		totals.input === 0 &&
+		totals.output === 0 &&
+		totals.cacheRead === 0 &&
+		totals.cacheWrite === 0 &&
+		totals.cost === 0
+	)
+		return undefined;
 	return {
 		inputTokens: totals.input,
 		outputTokens: totals.output,
@@ -50,13 +220,26 @@ export function usageFromSession(session: SessionUsageSource): UsageSnapshot | u
 	};
 }
 
-function addUsage(
-	totals: UsageTotals,
-	usage: { input: number; output: number; cacheRead: number; cacheWrite: number; cost: { total: number } },
-): void {
+function addContribution(totals: UsageTotals, usage: UsageContribution): void {
 	totals.input += usage.input;
 	totals.output += usage.output;
 	totals.cacheRead += usage.cacheRead;
 	totals.cacheWrite += usage.cacheWrite;
-	totals.cost += usage.cost.total;
+	totals.cost += usage.cost;
+}
+
+function subtractContribution(totals: UsageTotals, usage: UsageContribution): void {
+	totals.input -= usage.input;
+	totals.output -= usage.output;
+	totals.cacheRead -= usage.cacheRead;
+	totals.cacheWrite -= usage.cacheWrite;
+	totals.cost -= usage.cost;
+}
+
+function emptyTotals(): UsageTotals {
+	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+}
+
+function emptyContribution(): UsageContribution {
+	return { ...emptyTotals(), sawUsage: false };
 }

package/extension-src/pi-style/shared/ansi.ts

@@ -1,3 +1,5 @@
+import { visibleWidth as tuiVisibleWidth } from "@earendil-works/pi-tui";
+
 function isFinal(byte: string): boolean {
 	return byte >= "@" && byte <= "~";
 }
@@ -91,8 +93,12 @@ export function stripAnsi(value: string): string {
 	}
 	return output;
 }
+/**
+ * Terminal-correct visible width: delegates to pi-tui (ANSI-stripping,
+ * ASCII fast path, per-string cache, wide chars = 2 columns, tabs = 3).
+ */
 export function visibleWidth(value: string): number {
-	return [...stripAnsi(value)].length;
+	return tuiVisibleWidth(value);
 }
 export function resetAnsi(value: string): string {
 	return `${value}\x1b[0m`;
@@ -105,9 +111,10 @@ export function fitAnsiWidth(value: string, width: number, ellipsis = "…"): st
 export function truncateAnsi(value: string, width: number, ellipsis = "…"): string {
 	if (width <= 0) return "";
 	if (visibleWidth(value) <= width) return resetAnsi(value);
+	const ellipsisWidth = visibleWidth(ellipsis);
 	let output = "";
 	let visible = 0;
-	for (let i = 0; i < value.length && visible < width - visibleWidth(ellipsis); i++) {
+	for (let i = 0; i < value.length && visible < width - ellipsisWidth; i++) {
 		if (value.charCodeAt(i) === 27) {
 			const start = i;
 			i++;
@@ -125,12 +132,17 @@ export function wrapAnsi(value: string, width: number): string[] {
 	if (width <= 0) return [""];
 	const lines: string[] = [];
 	let line = "";
+	let lineWidth = 0;
 	for (const word of value.split(/\s+/)) {
-		const next = line ? `${line} ${word}` : word;
-		if (visibleWidth(next) <= width) line = next;
-		else {
+		const wordWidth = visibleWidth(word);
+		const nextWidth = line ? lineWidth + 1 + wordWidth : wordWidth;
+		if (nextWidth <= width) {
+			line = line ? `${line} ${word}` : word;
+			lineWidth = nextWidth;
+		} else {
 			if (line) lines.push(resetAnsi(line));
 			line = truncateAnsi(word, width);
+			lineWidth = visibleWidth(line);
 		}
 	}
 	if (line || lines.length === 0) lines.push(resetAnsi(line));

package/extension-src/pi-style/shared/box.ts

@@ -36,6 +36,17 @@ export interface BoxTheme {
 	getColorMode?(): string;
 }
 
+const THEME_CACHE_KEYS = new WeakMap<object, number>();
+let nextThemeCacheKey = 1;
+
+export function themeCacheKey(theme: object): number {
+	const cached = THEME_CACHE_KEYS.get(theme);
+	if (cached !== undefined) return cached;
+	const created = nextThemeCacheKey++;
+	THEME_CACHE_KEYS.set(theme, created);
+	return created;
+}
+
 export interface BoxedRenderOptions {
 	widthKey?: string;
 	/** Detail embedded in the top-border title after the tool name (e.g. the path). */
@@ -138,12 +149,63 @@ export function countLines(text: string): number {
 	return normalized.split("\n").length;
 }
 
+// Word-character membership table powering countWords. ASCII and the UTF-16
+// surrogate range are initialized eagerly; every other BMP code point is
+// resolved through the Unicode letter/digit class on first sight and memoized,
+// so repeat scans are pure table lookups. The per-code-point regex dispatch
+// this replaces measured ~1.9ms per 90KB output on every boxed footer render;
+// note that String.match with a \p{L}\p{N} class is no faster on V8 — the
+// memoized scan is the only variant that hit the <0.2ms budget.
+const WORD_CP_UNKNOWN = 255;
+const WORD_CP_SURROGATE = 254;
+const WORD_CP_CLASS = new Uint8Array(0x10000).fill(WORD_CP_UNKNOWN);
+for (let code = 0x30; code <= 0x39; code++) WORD_CP_CLASS[code] = 1; // 0-9
+for (let code = 0x41; code <= 0x5a; code++) WORD_CP_CLASS[code] = 1; // A-Z
+for (let code = 0x61; code <= 0x7a; code++) WORD_CP_CLASS[code] = 1; // a-z
+WORD_CP_CLASS[0x27] = 1; // '
+WORD_CP_CLASS[0x2d] = 1; // -
+WORD_CP_CLASS[0x5f] = 1; // _
+WORD_CP_CLASS.fill(WORD_CP_SURROGATE, 0xd800, 0xe000);
+const NON_ASCII_WORD_RE = /[\p{L}\p{N}]/u;
+const ASTRAL_WORD_CP = new Map<number, 0 | 1>();
+
+function astralWordMembership(codePoint: number): 0 | 1 {
+	const cached = ASTRAL_WORD_CP.get(codePoint);
+	if (cached !== undefined) return cached;
+	const membership: 0 | 1 = NON_ASCII_WORD_RE.test(String.fromCodePoint(codePoint)) ? 1 : 0;
+	ASTRAL_WORD_CP.set(codePoint, membership);
+	return membership;
+}
+
+/** Counts words as maximal runs of word characters (letters, digits,
+ *  underscore, apostrophe, hyphen) — identical counts to a per-code-point
+ *  `\p{L}\p{N}_'-` class test, in one table-driven pass with no allocations. */
 export function countWords(text: string): number {
+	const len = text.length;
 	let count = 0;
-	let inWord = false;
-	for (const char of text) {
-		const isWord = /[\p{L}\p{N}_'-]/u.test(char);
-		if (isWord && !inWord) count++;
+	let inWord: number = 0;
+	for (let i = 0; i < len; i++) {
+		const code = text.charCodeAt(i);
+		const membership = WORD_CP_CLASS[code] ?? 0;
+		let isWord: number;
+		if (membership <= 1) {
+			isWord = membership;
+		} else if (membership === WORD_CP_SURROGATE) {
+			const next = i + 1 < len ? text.charCodeAt(i + 1) : 0;
+			if (code <= 0xdbff && next >= 0xdc00 && next <= 0xdfff) {
+				// Astral word characters (e.g. mathematical alphanumerics) count as
+				// one code point, exactly like the previous code-point iteration.
+				isWord = astralWordMembership(0x10000 + ((code - 0xd800) << 10) + (next - 0xdc00));
+				i++; // consumed the pair's low surrogate half
+			} else {
+				isWord = 0; // lone surrogate half: never a word character
+			}
+		} else {
+			// First sight of this non-ASCII BMP code point: resolve once, memoize.
+			isWord = NON_ASCII_WORD_RE.test(String.fromCharCode(code)) ? 1 : 0;
+			WORD_CP_CLASS[code] = isWord;
+		}
+		count += isWord & (inWord ^ 1);
 		inWord = isWord;
 	}
 	return count;
@@ -199,6 +261,9 @@ const BOX_DIVIDER_RIGHT = "┤";
 /** Dash run before the right corner when a right-side border label is present. */
 const BOX_LABELED_RIGHT_DASH_MIN = 3;
 const BOX_WIDTH_CACHE = new Map<string, number>();
+/** Hard cap for BOX_WIDTH_CACHE; the oldest entry is evicted beyond this. Keys
+ *  embed full bash commands, so the cache must stay bounded across a session. */
+const BOX_WIDTH_CACHE_MAX_ENTRIES = 512;
 
 export function boxWidth(width: number): number {
 	return Math.max(BOX_MIN_WIDTH, width);
@@ -225,6 +290,13 @@ function _tightBoxWidth(
 	if (!widthKey) return measuredWidth;
 	const cachedWidth = BOX_WIDTH_CACHE.get(widthKey) ?? 0;
 	const nextWidth = Math.min(boxWidth(availableWidth), Math.max(cachedWidth, measuredWidth));
+	// Bounded LRU: Map preserves insertion order, so delete+set refreshes the
+	// key's recency and the first key is the oldest evict candidate.
+	BOX_WIDTH_CACHE.delete(widthKey);
+	if (BOX_WIDTH_CACHE.size >= BOX_WIDTH_CACHE_MAX_ENTRIES) {
+		const oldestKey = BOX_WIDTH_CACHE.keys().next().value;
+		if (oldestKey !== undefined) BOX_WIDTH_CACHE.delete(oldestKey);
+	}
 	BOX_WIDTH_CACHE.set(widthKey, nextWidth);
 	return nextWidth;
 }
@@ -233,6 +305,11 @@ export function boxedToolWidthKey(toolName: string, detail: string): string {
 	return `${toolName}:${detail}`;
 }
 
+/** Test-only debug view of the bounded box width cache. */
+export function __getBoxWidthCacheDebugState(): { size: number } {
+	return { size: BOX_WIDTH_CACHE.size };
+}
+
 export function formatToolName(toolName: string): string {
 	const spaced = toolName
 		.replace(/[_-]+/g, " ")
@@ -384,10 +461,10 @@ export function dimLine(text: string): string {
 	return `\x1b[2m${text}\x1b[22m`;
 }
 
-function boxText(theme: BoxTheme, text: string): string {
+function boxText(_theme: BoxTheme, text: string): string {
 	return dimLine(text);
 }
-function boxFrameText(theme: BoxTheme, text: string): string {
+function boxFrameText(_theme: BoxTheme, text: string): string {
 	return dimLine(text);
 }
 

package/extension-src/pi-style/shared/split-diff.ts

@@ -56,7 +56,13 @@ type DiffEntry =
 
 const ESC = "\x1b";
 const BG_ANSI_PATTERN = new RegExp(`${ESC}\\[(?:4\\d|10\\d|48;5;\\d{1,3}|48;2;\\d{1,3};\\d{1,3};\\d{1,3}|49)m`, "g");
+/** Any SGR escape (capture: parameter bytes). Shared with String.replace only —
+ *  replace resets lastIndex, so the global flag is safe here. */
+const ANSI_SGR_PATTERN = new RegExp(`${ESC}\\[([0-9;]*)m`, "g");
 const CONTROL_CHARS = "\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F";
+/** Control characters (minus \r/\n, handled separately) stripped from diff
+ *   text. Replace-only usage, so the global flag is safe (see above). */
+const CONTROL_CHARS_PATTERN = new RegExp(`[${CONTROL_CHARS}]`, "g");
 
 const ADD_ROW_BACKGROUND_MIX_RATIO = 0.24;
 const REMOVE_ROW_BACKGROUND_MIX_RATIO = 0.12;
@@ -173,7 +179,7 @@ function resolveDiffPalette(theme: SplitDiffTheme): DiffPalette {
 function keepBackgroundAcrossResets(text: string, rowBgAnsi: string): string {
 	if (!text) return text;
 
-	return text.replace(new RegExp(`${ESC}\\[([0-9;]*)m`, "g"), (sequence, rawCodes) => {
+	return text.replace(ANSI_SGR_PATTERN, (sequence, rawCodes) => {
 		const split = String(rawCodes ?? "")
 			.split(";")
 			.filter(Boolean);
@@ -233,10 +239,7 @@ function applyBackgroundToVisibleRange(
 // ── Text utilities ─────────────────────────────────────────────────
 
 function sanitizeSingleLineText(value: string): string {
-	return value
-		.replace(/\r/g, "")
-		.replace(/\n/g, "")
-		.replace(new RegExp(`[${CONTROL_CHARS}]`, "g"), "");
+	return value.replace(/\r/g, "").replace(/\n/g, "").replace(CONTROL_CHARS_PATTERN, "");
 }
 
 function stripInlineBreaksPreserveAnsi(value: string): string {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quandev104/pi-style",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "A native-layout, cohesive visual style package for Pi.",
   "license": "MIT",
   "type": "module",