@oh-my-pi/pi-tui 18.4.1 → 18.4.3

package/src/status-line/component.ts

@@ -7,7 +7,7 @@ import {
 } from "@oh-my-pi/pi-ai/usage/google-antigravity";
 import { getNextTimeBasedPricingTransition } from "@oh-my-pi/pi-catalog/models";
 import type { Model, ModelCost } from "@oh-my-pi/pi-catalog/types";
-import type { VcsRepo } from "@oh-my-pi/pi-natives";
+import type { VcsGitRepo, VcsRepo } from "@oh-my-pi/pi-natives";
 import * as vcs from "@oh-my-pi/pi-natives/vcs";
 import {
 	type Component,
@@ -48,6 +48,13 @@ import type {
 	StatusLineSettings,
 } from "./types";
 
+/**
+ * Freshness window for the git segment's working-tree counts. A whole-worktree
+ * `git status` costs ~1 CPU-second on large repos and every open session polls
+ * it, so edits surface within this window; HEAD moves refetch immediately via
+ * {@link StatusLineComponent.invalidateGitCaches}.
+ */
+const GIT_STATUS_TTL_MS = 10_000;
 const JJ_REFRESH_TTL_MS = 5000;
 const JJ_COMMAND_TIMEOUT_MS = 5_000;
 const WATCHER_FAILURE_POLL_TTL_MS = 5000;
@@ -255,57 +262,62 @@ interface ContextUsageMemo {
 	skillsRef: readonly any[] | undefined;
 }
 
-interface StatusLineExternalInputs {
-	themeRef: unknown;
-	themeEpoch: number;
-	projectDir: string;
-	sessionRef: StatusLineSession;
-	sessionFile: string | undefined;
-	sessionSettingsRef: unknown;
-	sessionSettingsRevision: number;
-	globalSettingsRevision: number;
-	stateRef: unknown;
-	stateMessagesRef: readonly AgentMessage[];
-	stateMessagesLength: number;
-	stateLastMessageRef: AgentMessage | undefined;
-	stateLastMessageContentRef: unknown;
-	messagesRef: readonly AgentMessage[];
-	messagesLength: number;
-	lastMessageRef: AgentMessage | undefined;
-	lastMessageRole: string | undefined;
-	lastMessageTimestamp: number;
-	lastMessageContentSize: number;
-	lastMessageBlockCount: number;
-	lastMessageUsageTotal: number;
-	lastMessageStopReason: string | undefined;
-	modelRef: unknown;
-	sessionModelRef: unknown;
-	sessionModelId: string | undefined;
-	sessionModelContextWindow: Model["contextWindow"] | undefined;
-	modelId: string | undefined;
-	modelName: string | undefined;
-	modelProvider: string | undefined;
-	modelContextWindow: Model["contextWindow"] | undefined;
-	modelThinking: Model["thinking"];
-	thinkingLevel: unknown;
-	modelCostRef: unknown;
-	contextUsageRevision: number;
-	systemPromptRef: unknown;
-	systemPromptLength: number;
-	systemPromptContentSize: number;
-	toolsRef: readonly unknown[] | undefined;
-	toolsLength: number;
-	toolSchemaMetadataRevision: number;
-	tokenizerRef: unknown;
-	skillsRef: unknown;
-	skillsLength: number;
-	sessionName: string | undefined;
-	sessionId: string | undefined;
-	isStreaming: boolean | undefined;
-	isAutoThinking: boolean | undefined;
-	isFastModeActive: boolean;
-	anthropicSlowModeLabel: string | undefined;
-	compactionSpeculation: unknown;
+/**
+ * Snapshot of the cheap external inputs a cached bar depends on. Mutable and
+ * refilled in place: the per-frame cache probe writes into a recycled
+ * instance instead of allocating a fresh ~50-field object every frame.
+ */
+class StatusLineExternalInputs {
+	themeRef: unknown = undefined;
+	themeEpoch = 0;
+	projectDir = "";
+	sessionRef: StatusLineSession | undefined = undefined;
+	sessionFile: string | undefined = undefined;
+	sessionSettingsRef: unknown = undefined;
+	sessionSettingsRevision = 0;
+	globalSettingsRevision = 0;
+	stateRef: unknown = undefined;
+	stateMessagesRef: readonly AgentMessage[] = EMPTY_MESSAGES;
+	stateMessagesLength = 0;
+	stateLastMessageRef: AgentMessage | undefined = undefined;
+	stateLastMessageContentRef: unknown = undefined;
+	messagesRef: readonly AgentMessage[] = EMPTY_MESSAGES;
+	messagesLength = 0;
+	lastMessageRef: AgentMessage | undefined = undefined;
+	lastMessageRole: string | undefined = undefined;
+	lastMessageTimestamp = 0;
+	lastMessageContentSize = 0;
+	lastMessageBlockCount = 0;
+	lastMessageUsageTotal = 0;
+	lastMessageStopReason: string | undefined = undefined;
+	modelRef: unknown = undefined;
+	sessionModelRef: unknown = undefined;
+	sessionModelId: string | undefined = undefined;
+	sessionModelContextWindow: Model["contextWindow"] | undefined = undefined;
+	modelId: string | undefined = undefined;
+	modelName: string | undefined = undefined;
+	modelProvider: string | undefined = undefined;
+	modelContextWindow: Model["contextWindow"] | undefined = undefined;
+	modelThinking: Model["thinking"] = undefined;
+	thinkingLevel: unknown = undefined;
+	modelCostRef: unknown = undefined;
+	contextUsageRevision = 0;
+	systemPromptRef: unknown = undefined;
+	systemPromptLength = 0;
+	systemPromptContentSize = 0;
+	toolsRef: readonly unknown[] | undefined = undefined;
+	toolsLength = 0;
+	toolSchemaMetadataRevision = 0;
+	tokenizerRef: unknown = undefined;
+	skillsRef: unknown = undefined;
+	skillsLength = 0;
+	sessionName: string | undefined = undefined;
+	sessionId: string | undefined = undefined;
+	isStreaming: boolean | undefined = undefined;
+	isAutoThinking: boolean | undefined = undefined;
+	isFastModeActive = false;
+	anthropicSlowModeLabel: string | undefined = undefined;
+	compactionSpeculation: unknown = undefined;
 }
 
 interface CachedStatusLine {
@@ -445,6 +457,17 @@ function hasGitBackedSegment(segments: readonly StatusLineSegmentId[]): boolean
 
 type StatusLineLayout = "box" | "band" | "plain-full" | "plain-left" | "plain-right";
 
+/**
+ * Git views of immutable `VcsRepo` handles. `asGit()` mints a fresh napi
+ * wrapper around the same backend handle on every call, which the per-frame
+ * branch lookup would otherwise pay each render.
+ */
+const GIT_VIEW = Symbol("status-line.git-view");
+
+interface GitViewTaggedRepo extends VcsRepo {
+	[GIT_VIEW]?: VcsGitRepo | null;
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // StatusLineComponent
 // ═══════════════════════════════════════════════════════════════════════════
@@ -465,6 +488,22 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 	};
 	#statusLineInputRevision = 0;
 	#statusLineClockTick = 0;
+	/** Reused probe buffer for {@link #readStatusLineExternalInputs}; handed to the new cache entry on a miss. */
+	#externalInputsProbe = new StatusLineExternalInputs();
+	/** `adjustHsv` result for the gauge's threshold tint; pure in its source hex. */
+	#dimmedAccentMemo: { sourceHex: string; hex: string } | undefined;
+	/** Gauge boundary markers; a pure function of the session's compaction settings, model, and window. */
+	#compactionBoundariesMemo:
+		| {
+				sessionRef: StatusLineSession;
+				contextWindow: number;
+				modelRef: unknown;
+				settingsRef: unknown;
+				settingsRevision: number;
+				globalSettingsRevision: number;
+				boundaries: CompactionBoundaries | null;
+		  }
+		| undefined;
 	#settings: StatusLineSettings = {};
 	#effectiveSettings: EffectiveStatusLineSettings | undefined;
 	#cachedBranch: string | null | undefined = undefined;
@@ -554,6 +593,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 	#cachedGitStatus: { staged: number; unstaged: number; untracked: number } | null = null;
 	#cachedGitStatusCwd: string | undefined = undefined;
 	#gitStatusLastFetch = 0;
+	#gitStatusGeneration = 0;
 	#gitStatusInFlightCwd: string | undefined = undefined;
 	#cachedJjBranch: string | null = null;
 	#jjBranchLastFetch = 0;
@@ -1070,8 +1110,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		const sessionName = sessionAccentEnabled ? this.session.sessionManager?.getSessionName() : undefined;
 		const idleHex = theme.getColorHex("dim");
 		const workingHex =
-			(sessionName ? getSessionAccentHex(sessionName, theme.sessionAccentInputs) : undefined) ??
-			theme.getColorHex("accent");
+			(sessionName && getSessionAccentHex(sessionName, theme.sessionAccentInputs)) || theme.getColorHex("accent");
 		const now = Date.now();
 		if (working !== this.#brandWorking) {
 			const previousTargetHex = this.#brandWorking ? workingHex : idleHex;
@@ -1223,6 +1262,11 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		this.#branchLastFetch = undefined;
 		this.#branchCacheGeneration++;
 		this.#cachedPrContext = undefined;
+		// A HEAD move (commit, checkout, reset) changes the dirty counts; keep the
+		// stale counts on screen but refetch on the next render. The generation
+		// bump stops an in-flight pre-move result from re-stamping freshness.
+		this.#gitStatusLastFetch = 0;
+		this.#gitStatusGeneration++;
 		// jj label/status share the git segment's lifecycle: a HEAD move (e.g. a
 		// colocated `jj new`/bookmark move) must drop the throttled jj caches too,
 		// so the next render refetches.
@@ -1267,7 +1311,12 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 
 		const gitCwd = activeRepoCache.effectiveGitCwd;
 		if (!repository) return null;
-		const gitRepository = repository.asGit();
+		const taggedRepository: GitViewTaggedRepo = repository;
+		let gitRepository = taggedRepository[GIT_VIEW];
+		if (gitRepository === undefined) {
+			gitRepository = repository.asGit();
+			taggedRepository[GIT_VIEW] = gitRepository;
+		}
 		if (!gitRepository) {
 			if (this.#jjBranchActive || Date.now() - this.#jjBranchLastFetch < JJ_REFRESH_TTL_MS) {
 				return this.#cachedJjBranch;
@@ -1457,11 +1506,12 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		if (this.#gitStatusInFlightCwd !== undefined) {
 			return this.#cachedGitStatusCwd === gitCwd ? this.#cachedGitStatus : null;
 		}
-		if (this.#cachedGitStatusCwd === gitCwd && Date.now() - this.#gitStatusLastFetch < 1000) {
+		if (this.#cachedGitStatusCwd === gitCwd && Date.now() - this.#gitStatusLastFetch < GIT_STATUS_TTL_MS) {
 			return this.#cachedGitStatus;
 		}
 
 		this.#gitStatusInFlightCwd = gitCwd;
+		const generation = this.#gitStatusGeneration;
 
 		(async () => {
 			let nextStatus: { staged: number; unstaged: number; untracked: number } | null = null;
@@ -1474,7 +1524,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 					const prev = this.#cachedGitStatusCwd === gitCwd ? this.#cachedGitStatus : null;
 					this.#cachedGitStatus = nextStatus;
 					this.#cachedGitStatusCwd = gitCwd;
-					this.#gitStatusLastFetch = Date.now();
+					this.#gitStatusLastFetch = this.#gitStatusGeneration === generation ? Date.now() : 0;
 					this.#gitStatusInFlightCwd = undefined;
 					if (!this.#disposed && JSON.stringify(prev) !== JSON.stringify(nextStatus)) {
 						this.#invalidateStatusLineRenderCache();
@@ -2294,8 +2344,9 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 	 * going through this component's setters. This deliberately uses refs,
 	 * scalars, and string lengths only: no schema estimation, serialization,
 	 * usage aggregation, VCS probing, or segment getters run on a cache hit.
+	 * Fills `target` in place so the per-frame probe allocates nothing.
 	 */
-	#readStatusLineExternalInputs(): StatusLineExternalInputs {
+	#readStatusLineExternalInputs(target: StatusLineExternalInputs): void {
 		const state = this.session.state;
 		const stateMessages = state.messages ?? EMPTY_MESSAGES;
 		const stateLastMessage = stateMessages[stateMessages.length - 1];
@@ -2346,62 +2397,61 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 			if (typeof part === "string") systemPromptContentSize += part.length;
 		}
 		const tools = this.session.agent?.state?.tools;
-		return {
-			themeRef: theme,
-			themeEpoch: getThemeEpoch(),
-			projectDir: getProjectDir(),
-			sessionRef: this.session,
-			sessionFile: this.session.sessionFile,
-			sessionSettingsRef: this.host.getSessionSettingsIdentity(this.session),
-			sessionSettingsRevision: this.host.getSessionSettingsRevision(this.session),
-			globalSettingsRevision: this.host.getSettingsRevision(),
-			stateRef: state,
-			stateMessagesRef: stateMessages,
-			stateMessagesLength: stateMessages.length,
-			stateLastMessageRef: stateLastMessage,
-			stateLastMessageContentRef: stateLastMessageContent,
-			messagesRef: messages,
-			messagesLength: messages.length,
-			lastMessageRef: lastMessage,
-			lastMessageRole: lastMessageView?.role,
-			lastMessageTimestamp: lastMessageView?.timestamp ?? 0,
-			lastMessageContentSize,
-			lastMessageBlockCount,
-			lastMessageUsageTotal: lastMessageView?.usage?.totalTokens ?? 0,
-			lastMessageStopReason: lastMessageView?.stopReason,
-			modelRef: model,
-			sessionModelRef: sessionModel,
-			sessionModelId: sessionModel?.id,
-			sessionModelContextWindow: sessionModel?.contextWindow,
-			modelId: model?.id,
-			modelName: model?.name,
-			modelProvider: model?.provider,
-			modelContextWindow: model?.contextWindow,
-			modelThinking: model?.thinking,
-			thinkingLevel: state.thinkingLevel,
-			modelCostRef: model?.cost,
-			contextUsageRevision: this.session.contextUsageRevision ?? 0,
-			systemPromptRef: systemPrompt,
-			systemPromptLength: systemPrompt?.length ?? 0,
-			systemPromptContentSize,
-			toolsRef: tools,
-			toolsLength: tools?.length ?? 0,
-			toolSchemaMetadataRevision: tools ? getToolSchemaMetadataRevision(tools) : 0,
-			tokenizerRef: this.session.agent?.tokenizer,
-			skillsRef: this.session.skills,
-			skillsLength: this.session.skills?.length ?? 0,
-			sessionName: this.session.sessionManager?.getSessionName?.(),
-			sessionId: this.session.sessionManager?.getSessionId?.(),
-			isStreaming: this.session.isStreaming,
-			isAutoThinking: this.session.isAutoThinking,
-			isFastModeActive:
-				typeof this.session.isFastModeActive === "function" ? this.session.isFastModeActive() : false,
-			anthropicSlowModeLabel:
-				typeof this.session.getAnthropicSlowModeLabel === "function"
-					? this.session.getAnthropicSlowModeLabel()
-					: undefined,
-			compactionSpeculation: this.session.compactionSpeculation,
-		};
+		const skills = this.session.skills;
+		target.themeRef = theme;
+		target.themeEpoch = getThemeEpoch();
+		target.projectDir = getProjectDir();
+		target.sessionRef = this.session;
+		target.sessionFile = this.session.sessionFile;
+		target.sessionSettingsRef = this.host.getSessionSettingsIdentity(this.session);
+		target.sessionSettingsRevision = this.host.getSessionSettingsRevision(this.session);
+		target.globalSettingsRevision = this.host.getSettingsRevision();
+		target.stateRef = state;
+		target.stateMessagesRef = stateMessages;
+		target.stateMessagesLength = stateMessages.length;
+		target.stateLastMessageRef = stateLastMessage;
+		target.stateLastMessageContentRef = stateLastMessageContent;
+		target.messagesRef = messages;
+		target.messagesLength = messages.length;
+		target.lastMessageRef = lastMessage;
+		target.lastMessageRole = lastMessageView?.role;
+		target.lastMessageTimestamp = lastMessageView?.timestamp ?? 0;
+		target.lastMessageContentSize = lastMessageContentSize;
+		target.lastMessageBlockCount = lastMessageBlockCount;
+		target.lastMessageUsageTotal = lastMessageView?.usage?.totalTokens ?? 0;
+		target.lastMessageStopReason = lastMessageView?.stopReason;
+		target.modelRef = model;
+		target.sessionModelRef = sessionModel;
+		target.sessionModelId = sessionModel?.id;
+		target.sessionModelContextWindow = sessionModel?.contextWindow;
+		target.modelId = model?.id;
+		target.modelName = model?.name;
+		target.modelProvider = model?.provider;
+		target.modelContextWindow = model?.contextWindow;
+		target.modelThinking = model?.thinking;
+		target.thinkingLevel = state.thinkingLevel;
+		target.modelCostRef = model?.cost;
+		target.contextUsageRevision = this.session.contextUsageRevision ?? 0;
+		target.systemPromptRef = systemPrompt;
+		target.systemPromptLength = systemPrompt?.length ?? 0;
+		target.systemPromptContentSize = systemPromptContentSize;
+		target.toolsRef = tools;
+		target.toolsLength = tools?.length ?? 0;
+		target.toolSchemaMetadataRevision = tools ? getToolSchemaMetadataRevision(tools) : 0;
+		target.tokenizerRef = this.session.agent?.tokenizer;
+		target.skillsRef = skills;
+		target.skillsLength = skills?.length ?? 0;
+		target.sessionName = this.session.sessionManager?.getSessionName?.();
+		target.sessionId = this.session.sessionManager?.getSessionId?.();
+		target.isStreaming = this.session.isStreaming;
+		target.isAutoThinking = this.session.isAutoThinking;
+		target.isFastModeActive =
+			typeof this.session.isFastModeActive === "function" ? this.session.isFastModeActive() : false;
+		target.anthropicSlowModeLabel =
+			typeof this.session.getAnthropicSlowModeLabel === "function"
+				? this.session.getAnthropicSlowModeLabel()
+				: undefined;
+		target.compactionSpeculation = this.session.compactionSpeculation;
 	}
 
 	#sameStatusLineExternalInputs(left: StatusLineExternalInputs, right: StatusLineExternalInputs): boolean {
@@ -2496,7 +2546,8 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 
 	#buildStatusLine(width: number, layout: StatusLineLayout = "box", previewTitle?: string): CachedStatusLine {
 		const effectiveSettings = this.#resolveSettings();
-		const externalInputs = this.#readStatusLineExternalInputs();
+		const externalInputs = this.#externalInputsProbe;
+		this.#readStatusLineExternalInputs(externalInputs);
 		const nowMs = Date.now();
 		const clockTick = this.#statusLineClock(nowMs, effectiveSettings);
 		if (clockTick !== this.#statusLineClockTick) {
@@ -2516,6 +2567,8 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 			return cached;
 		}
 
+		// The probe now belongs to the new cache entry; later probes need their own buffer.
+		this.#externalInputsProbe = new StatusLineExternalInputs();
 		const content = this.#renderStatusLine(width, layout, previewTitle, nowMs);
 		const result = {
 			content,
@@ -2642,8 +2695,11 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 			if (subagentBadge) rightParts.unshift(subagentBadge);
 		}
 		const topFillWidth = Math.max(0, width);
-		const left = [...leftParts];
-		const right = [...rightParts];
+		// These arrays are local to this render; overflow handling can mutate them.
+		const left = leftParts;
+		const right = rightParts;
+		const leftWidths = left.map(part => visibleWidth(part));
+		const rightWidths = right.map(part => visibleWidth(part));
 
 		const leftSepWidth = visibleWidth(separatorDef.left);
 		const rightSepWidth = visibleWidth(separatorDef.right);
@@ -2657,15 +2713,15 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		const bandCap = layout === "band" && separatorDef.endCaps && !transparentBg ? theme.sep.powerlineCapLeft : "";
 		const bandCapWidth = visibleWidth(bandCap);
 
-		const groupWidth = (parts: string[], capWidth: number, sepWidth: number): number => {
-			if (parts.length === 0) return 0;
-			const partsWidth = parts.reduce((sum, part) => sum + visibleWidth(part), 0);
-			const sepTotal = Math.max(0, parts.length - 1) * (sepWidth + 2);
+		const groupWidth = (widths: number[], capWidth: number, sepWidth: number): number => {
+			if (widths.length === 0) return 0;
+			const partsWidth = widths.reduce((sum, partWidth) => sum + partWidth, 0);
+			const sepTotal = (widths.length - 1) * (sepWidth + 2);
 			return partsWidth + sepTotal + 2 + capWidth;
 		};
 
-		let leftWidth = groupWidth(left, leftCapWidth + bandCapWidth, leftSepWidth);
-		let rightWidth = groupWidth(right, rightCapWidth, rightSepWidth);
+		let leftWidth = groupWidth(leftWidths, leftCapWidth + bandCapWidth, leftSepWidth);
+		let rightWidth = groupWidth(rightWidths, rightCapWidth, rightSepWidth);
 		// Embedded mode removes the standalone context segment before overflow
 		// handling, so the gauge must reserve enough room for both labels. Without
 		// this budget a long path/session title can leave a one-cell gap: the
@@ -2694,23 +2750,27 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 			if (nameSegIdx >= 0 && totalWidth() > topFillWidth) {
 				// Badge/job parts were unshifted ahead of the tracked segment ids.
 				const nameIdx = nameSegIdx + (right.length - rightSegIds.length);
-				const currentNameVW = visibleWidth(right[nameIdx]);
+				const currentNameVW = rightWidths[nameIdx];
 				const minNameVW = 8;
 				const shrinkBy = Math.min(Math.max(0, currentNameVW - minNameVW), totalWidth() - topFillWidth);
 				if (shrinkBy > 0) {
 					right[nameIdx] = truncateToWidth(right[nameIdx], currentNameVW - shrinkBy);
-					rightWidth = groupWidth(right, rightCapWidth, rightSepWidth);
+					const nameWidth = visibleWidth(right[nameIdx]);
+					rightWidth += nameWidth - currentNameVW;
+					rightWidths[nameIdx] = nameWidth;
 				}
 			}
 			while (totalWidth() > topFillWidth && right.length > 0) {
+				const removedWidth = rightWidths[right.length - 1];
 				right.pop();
-				rightWidth = groupWidth(right, rightCapWidth, rightSepWidth);
+				rightWidths.pop();
+				rightWidth = right.length > 0 ? rightWidth - removedWidth - rightSepWidth - 2 : 0;
 			}
 			// Shrink path before dropping left segments — path is the only elastic segment
 			const pathIdx = leftSegIds.indexOf("path");
 			if (pathIdx >= 0 && totalWidth() > topFillWidth) {
 				const overflow = totalWidth() - topFillWidth;
-				const currentPathVW = visibleWidth(left[pathIdx]);
+				const currentPathVW = leftWidths[pathIdx];
 				const minPathVW = 8; // icon + ellipsis + a few chars
 				const shrinkable = currentPathVW - minPathVW;
 				if (shrinkable > 0) {
@@ -2723,9 +2783,10 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 					});
 					let reRendered = renderSegment("path", pathCtx(newMaxLen));
 					if (reRendered.visible && reRendered.content) {
+						let pathWidth = visibleWidth(reRendered.content);
 						// maxLength governs path text, not icon prefix; iterate to compensate
 						for (let i = 0; i < 8; i++) {
-							const saved = currentPathVW - visibleWidth(reRendered.content);
+							const saved = currentPathVW - pathWidth;
 							if (saved >= shrinkBy) break;
 							const nextMaxLen = Math.max(4, newMaxLen - (shrinkBy - saved));
 							if (nextMaxLen >= newMaxLen) break; // no progress or hit floor
@@ -2733,9 +2794,11 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 							const adjusted = renderSegment("path", pathCtx(newMaxLen));
 							if (!adjusted.visible || !adjusted.content) break;
 							reRendered = adjusted;
+							pathWidth = visibleWidth(adjusted.content);
 						}
 						left[pathIdx] = reRendered.content;
-						leftWidth = groupWidth(left, leftCapWidth + bandCapWidth, leftSepWidth);
+						leftWidth += pathWidth - currentPathVW;
+						leftWidths[pathIdx] = pathWidth;
 					}
 				}
 			}
@@ -2752,9 +2815,11 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 
 			while (totalWidth() > topFillWidth && left.length > 0) {
 				const dropIdx = leftOverflowDropIndex();
+				const removedWidth = leftWidths[dropIdx];
 				left.splice(dropIdx, 1);
+				leftWidths.splice(dropIdx, 1);
 				leftSegIds.splice(dropIdx, 1);
-				leftWidth = groupWidth(left, leftCapWidth + bandCapWidth, leftSepWidth);
+				leftWidth = left.length > 0 ? leftWidth - removedWidth - leftSepWidth - 2 : 0;
 			}
 		}
 
@@ -2906,8 +2971,12 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		const speculationColor = theme.getFgAnsi("muted");
 		const overflowColor = theme.getFgAnsi("error");
 		const rawAccentHex = accentHex ?? theme.getColorHex("borderAccent");
-		const dimmedAccentHex = adjustHsv(rawAccentHex, { s: 0.7, v: 0.75 });
-		const thresholdColor = getSessionAccentAnsi(dimmedAccentHex) ?? usedColor;
+		let dimmedAccent = this.#dimmedAccentMemo;
+		if (dimmedAccent?.sourceHex !== rawAccentHex) {
+			dimmedAccent = { sourceHex: rawAccentHex, hex: adjustHsv(rawAccentHex, { s: 0.7, v: 0.75 }) };
+			this.#dimmedAccentMemo = dimmedAccent;
+		}
+		const thresholdColor = getSessionAccentAnsi(dimmedAccent.hex) ?? usedColor;
 
 		let out = "\x1b[49m";
 		let activeColor = "";
@@ -2938,9 +3007,35 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 
 	/** Auto-compaction boundary percents, or null when unavailable (disabled, no window). */
 	#compactionBoundaries(contextWindow: number): CompactionBoundaries | null {
-		const model = this.session.state?.model ?? this.session.model;
+		const session = this.session;
+		const model = session.state?.model ?? session.model;
+		const settingsRef = this.host.getSessionSettingsIdentity(session);
+		const settingsRevision = this.host.getSessionSettingsRevision(session);
+		const globalSettingsRevision = this.host.getSettingsRevision();
+		const memo = this.#compactionBoundariesMemo;
+		if (
+			memo &&
+			memo.sessionRef === session &&
+			memo.contextWindow === contextWindow &&
+			memo.modelRef === model &&
+			memo.settingsRef === settingsRef &&
+			memo.settingsRevision === settingsRevision &&
+			memo.globalSettingsRevision === globalSettingsRevision
+		) {
+			return memo.boundaries;
+		}
 		try {
-			return this.host.computeCompactionBoundaries(this.session, contextWindow, model);
+			const boundaries = this.host.computeCompactionBoundaries(session, contextWindow, model);
+			this.#compactionBoundariesMemo = {
+				sessionRef: session,
+				contextWindow,
+				modelRef: model,
+				settingsRef,
+				settingsRevision,
+				globalSettingsRevision,
+				boundaries,
+			};
+			return boundaries;
 		} catch {
 			return null;
 		}

package/src/status-line/segments.ts

@@ -9,7 +9,6 @@ import {
 	getProjectDir,
 	normalizePathForComparison,
 	relativePathWithinNormalizedRoot,
-	relativePathWithinRoot,
 } from "@oh-my-pi/pi-utils";
 import { type SymbolKey, type Theme, type ThemeColor, theme } from "../theme";
 import { shortenPath, TRUNCATE_LENGTHS, truncateToWidth } from "../render/render-utils";
@@ -70,14 +69,6 @@ function leadingGlyph(display: string): string {
 	return space === -1 ? display : display.slice(0, space);
 }
 
-function stripDisplayRoot(pwd: string): string {
-	for (const root of [path.join(os.homedir(), "Projects"), "/work"]) {
-		const relative = relativePathWithinRoot(root, pwd);
-		if (relative) return relative;
-	}
-	return pwd;
-}
-
 /**
  * Single-field usage counter (`token_in`, `token_out`, `cache_read`,
  * `cache_write`). Hidden on zero, startup-placeholder aware, icon omitted when
@@ -121,28 +112,50 @@ const NORMALIZED_SCRATCH_ROOTS: readonly string[] = (() => {
 	return [...new Set(Array.from(roots, normalizePathForComparison))];
 })();
 
-interface ProjectDirClassification {
+interface ProjectDirDisplay {
+	projectDir: string;
+	homeDir: string;
+	displayRoots: readonly string[] | undefined;
 	scratch: boolean;
-	relative: string | null;
+	displayPath: string;
 }
 
-const PROJECT_DIR_CLASSIFICATIONS = new Map<string, ProjectDirClassification>();
+let projectDirDisplay: ProjectDirDisplay | undefined;
 
-function classifyProjectDir(projectDir: string): ProjectDirClassification {
-	const cached = PROJECT_DIR_CLASSIFICATIONS.get(projectDir);
-	if (cached) return cached;
+/**
+ * Retain only the active directory: switching cwd re-resolves its aliases,
+ * while repeated paints reuse both scratch classification and root stripping.
+ * Display roots remain normalized while the home directory is unchanged.
+ */
+function getProjectDirDisplay(projectDir: string): ProjectDirDisplay {
+	const cached = projectDirDisplay;
+	if (cached?.projectDir === projectDir) return cached;
 
+	const homeDir = os.homedir();
+	let displayRoots = cached?.homeDir === homeDir ? cached.displayRoots : undefined;
 	const normalizedProjectDir = normalizePathForComparison(projectDir);
-	let classification: ProjectDirClassification = { scratch: false, relative: null };
+	let scratch = false;
+	let displayPath = projectDir;
 	for (const normalizedRoot of NORMALIZED_SCRATCH_ROOTS) {
 		const relative = relativePathWithinNormalizedRoot(normalizedRoot, normalizedProjectDir);
 		if (relative !== null) {
-			classification = { scratch: true, relative: relative || null };
+			scratch = true;
+			displayPath = relative || projectDir;
 			break;
 		}
 	}
-	PROJECT_DIR_CLASSIFICATIONS.set(projectDir, classification);
-	return classification;
+	if (!scratch) {
+		displayRoots ??= [path.join(homeDir, "Projects"), "/work"].map(normalizePathForComparison);
+		for (const root of displayRoots) {
+			const relative = relativePathWithinNormalizedRoot(root, normalizedProjectDir);
+			if (relative) {
+				displayPath = relative;
+				break;
+			}
+		}
+	}
+	projectDirDisplay = { projectDir, homeDir, displayRoots, scratch, displayPath };
+	return projectDirDisplay;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -421,16 +434,8 @@ const pathSegment: StatusLineSegment = {
 		}
 
 		const projectDir = ctx.activeRepo?.cwd ?? getProjectDir();
-		const { scratch, relative } = classifyProjectDir(projectDir);
-		let pwd = projectDir;
-
-		if (stripPrefix) {
-			if (scratch) {
-				if (relative) pwd = relative;
-			} else {
-				pwd = stripDisplayRoot(pwd);
-			}
-		}
+		const { scratch, displayPath } = getProjectDirDisplay(projectDir);
+		let pwd = stripPrefix ? displayPath : projectDir;
 		const repoSuffix = ctx.activeRepo ? ` ↳ ${ctx.activeRepo.relativeRepoRoot}` : "";
 		if (opts.abbreviate !== false) {
 			pwd = shortenPath(pwd);