@linxiraos/pi-tui 1.1.26 → 1.2.0

package/src/status-line/component.ts

@@ -27,7 +27,7 @@ import type {
 } from "./host";
 import type { Editor } from "../components/editor";
 import { getSessionAccentAnsi, getSessionAccentHex } from "../theme/session-color";
-import { sanitizeStatusText } from "../chrome/shared";
+import { sanitizeHookStatusText, sanitizeStatusText } from "../chrome/shared";
 import { getThemeEpoch, theme } from "../theme";
 import { type CompactionBoundaries, EMPTY_STRING_PARTS, getToolSchemaMetadataRevision } from "./context-usage";
 import {
@@ -51,9 +51,12 @@ import type {
 	ComposerFactsSource,
 	EffectiveStatusLineSettings,
 	SegmentView,
+	SeparatorDef,
 	StatusLineSegmentId,
 	StatusLineSegmentOptions,
+	StatusLineSeparatorStyle,
 	StatusLineSettings,
+	StatusResetExpiry,
 } from "./types";
 
 /** What a click on a native status segment asks zeta to open. */
@@ -81,9 +84,9 @@ const PINNED_NATIVE_PRIORITY = 1000;
 /**
  * Segments a TSP terminal shows outside the composer's facts: the model chip,
  * the context hairline and usage text (context, cost), Tern's pane header
- * (path, git), the tab title (session name, PR), the HUD pills (subagents),
- * the editor (vim) and the brand (`pi`; while focus-proxied, the viewed agent
- * is the composer's viewing header).
+ * (path), the tab title (session name, PR), the HUD pills (subagents), the
+ * editor (vim) and the brand (`pi`; while focus-proxied, the viewed agent is
+ * the composer's viewing header).
  */
 const COMPOSER_HOMED_SEGMENTS: Partial<Record<StatusLineSegmentId, true>> = {
 	pi: true,
@@ -92,7 +95,6 @@ const COMPOSER_HOMED_SEGMENTS: Partial<Record<StatusLineSegmentId, true>> = {
 	context_total: true,
 	cost: true,
 	path: true,
-	git: true,
 	pr: true,
 	session_name: true,
 	subagents: true,
@@ -222,12 +224,51 @@ function reportMatchesExactIdentity(report: UsageReport, identity: OAuthAccountI
 // Context-usage memo
 // ═══════════════════════════════════════════════════════════════════════════
 
+/**
+ * Serialized length of tool-call arguments, memoized per arguments object.
+ * Streaming providers may grow the same object in place (at any depth), so
+ * each entry keeps a shape check — key/element counts plus string and number
+ * lengths over the whole tree — and is recomputed when it differs, without
+ * re-serializing the whole (possibly multi-KB edit/write) payload on every
+ * status-line rebuild.
+ */
+const toolArgumentsLengthCache = new WeakMap<object, { check: number; length: number }>();
+
+/** Past this depth the check stops descending; JSON.stringify rejects real cycles anyway. */
+const SHAPE_CHECK_MAX_DEPTH = 32;
+
+function toolArgumentsShapeCheck(value: unknown, depth = 0): number {
+	if (typeof value === "string") return value.length + 1;
+	if (typeof value === "number" || typeof value === "bigint") return String(value).length + 1;
+	if (value === null || typeof value !== "object" || depth >= SHAPE_CHECK_MAX_DEPTH) return 1;
+	let check = 1;
+	for (const child of Object.values(value)) check += 1 + toolArgumentsShapeCheck(child, depth + 1);
+	return check;
+}
+
+function toolArgumentsLength(args: unknown): number {
+	if (typeof args === "string") return args.length;
+	if (args === null || typeof args !== "object") return String(args).length;
+	const check = toolArgumentsShapeCheck(args);
+	const cached = toolArgumentsLengthCache.get(args);
+	if (cached !== undefined && cached.check === check) return cached.length;
+	let length: number;
+	try {
+		length =
+			JSON.stringify(args, (_key, value) => (typeof value === "bigint" ? value.toString() : value))?.length ?? 0;
+	} catch {
+		length = String(args).length;
+	}
+	toolArgumentsLengthCache.set(args, { check, length });
+	return length;
+}
+
 /**
  * Cheap structural fingerprint of a message's tokenizable content. O(blocks) —
- * only reads string `.length` and primitives, never copies or serializes.
- * Detects in-place growth of the streaming tail (and other in-place mutations)
- * so the cached `getContextUsage()` result is recomputed when — and only when —
- * the numbers it depends on change.
+ * only reads string `.length`, primitives, and memoized tool-argument sizes;
+ * never copies. Detects growth of the streaming tail (in-place text appends,
+ * freshly parsed tool arguments) so the cached `getContextUsage()` result is
+ * recomputed when — and only when — the numbers it depends on change.
  */
 function messageFingerprint(msg: AgentMessage): string {
 	const role = (msg as { role?: string }).role ?? "";
@@ -309,15 +350,7 @@ function messageFingerprint(msg: AgentMessage): string {
 					redactedLen += b.data.length;
 				} else if (b.type === "toolCall") {
 					if (typeof b.name === "string") textLen += b.name.length;
-					if (b.arguments !== undefined) {
-						try {
-							textLen += JSON.stringify(b.arguments, (_key, value) =>
-								typeof value === "bigint" ? value.toString() : value,
-							).length;
-						} catch {
-							textLen += String(b.arguments).length;
-						}
-					}
+					if (b.arguments !== undefined) textLen += toolArgumentsLength(b.arguments);
 				}
 			}
 		}
@@ -429,6 +462,25 @@ interface CachedStatusLine {
 	externalInputs: StatusLineExternalInputs;
 }
 
+/** Dot separator of the plain (borderless) layouts; carries no caps. */
+const PLAIN_SEPARATOR: SeparatorDef = { left: "·", right: "·" };
+
+/** A separator style's glyphs and cell widths: theme-pure, so measured once per theme. */
+interface SeparatorMetrics {
+	themeRef: unknown;
+	themeEpoch: number;
+	style: StatusLineSeparatorStyle;
+	def: SeparatorDef;
+	leftSepWidth: number;
+	rightSepWidth: number;
+	/** Left group's closing cap (`endCaps.right`); 0 without caps. */
+	leftCapWidth: number;
+	/** Right group's opening cap (`endCaps.left`); 0 without caps. */
+	rightCapWidth: number;
+	/** Band layout's flush-left soft cap; 0 without caps. */
+	bandCapWidth: number;
+}
+
 interface ActiveRepoCache {
 	projectDir: string;
 	activeRepo: ActiveRepoContext | null;
@@ -588,10 +640,21 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 	};
 	#statusLineInputRevision = 0;
 	#statusLineClockTick = 0;
+	/**
+	 * Earliest wall-clock ms at which a TTL-throttled VCS cache the render path
+	 * served goes stale (git/jj status, watcher-less branch poll, repository
+	 * re-probe, PR activity refresh); `Infinity` when none can. The first frame
+	 * past it expires the render memo so the getters refetch — instead of a
+	 * fixed polling tick that rebuilt the whole bar every second.
+	 */
+	#vcsStaleAt = Number.POSITIVE_INFINITY;
 	/** 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;
+	/** Separator widths for the plain and the styled (box/band) layouts; see {@link #separatorMetrics}. */
+	#plainSeparatorMetrics: SeparatorMetrics | undefined;
+	#styledSeparatorMetrics: SeparatorMetrics | undefined;
 	/** Gauge boundary markers; a pure function of the session's compaction settings, model, and window. */
 	#compactionBoundariesMemo:
 		| {
@@ -672,7 +735,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 	 * round-trips because the same {@link StatusLineSession} ref is reused.
 	 */
 	#activeMeters: WeakMap<TSession, ActiveMeter> = new WeakMap();
-	#planModeStatus: { enabled: boolean; paused: boolean } | null = null;
+	#planModeStatus: { enabled: boolean; paused: boolean; workflow?: "parallel" | "iterative" | "ultra" } | null = null;
 	#loopModeStatus: SegmentContext["loopMode"] = null;
 	#goalModeStatus: { enabled: boolean; paused: boolean } | null = null;
 	#vibeModeStatus: { enabled: boolean } | null = null;
@@ -733,6 +796,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 			expiryHours?: number;
 			expired?: boolean;
 			unavailableReason?: string;
+			expiring?: StatusResetExpiry;
 		};
 	} | null = null;
 	#cachedUsageContextKey: string | null = null;
@@ -745,6 +809,9 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 	#latestAppliedUsageRefreshSequence = 0;
 	#codexResetSnapshots = new Map<string, CodexResetUsageSnapshot>();
 	#onCodexResetFireworks: ((event: CodexResetFireworksEvent) => void) | undefined;
+	#onResetExpiryNotice: ((notice: string) => void) | undefined;
+	/** Conversations already warned about expiring saved resets: later refreshes stay quiet. */
+	#resetExpiryNoticedSessions = new Set<string>();
 	// Context-usage memo. The status line redraws on every agent event, so the
 	// hot path must not recompute context tokens unless an input changed.
 	// `getContextUsage()` anchors on the last assistant's real prompt-token
@@ -815,27 +882,46 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 	#resolveRepository(cache: ActiveRepoCache): VcsRepo | null {
 		if (cache.repository) return cache.repository;
 		const now = Date.now();
-		if (now - cache.repositoryCheckedAt < WATCHER_FAILURE_POLL_TTL_MS) return null;
-		cache.repository = vcs.repo(cache.effectiveGitCwd);
-		cache.repositoryCheckedAt = now;
+		if (now - cache.repositoryCheckedAt >= WATCHER_FAILURE_POLL_TTL_MS) {
+			cache.repository = vcs.repo(cache.effectiveGitCwd);
+			cache.repositoryCheckedAt = now;
+		}
+		// Still absent: re-probe on the bounded interval so a later `git init` shows up.
+		if (!cache.repository) this.#noteVcsStaleAt(cache.repositoryCheckedAt + WATCHER_FAILURE_POLL_TTL_MS);
 		return cache.repository;
 	}
 
 	#resolveDisplayRepository(cache: ActiveRepoCache): VcsRepo | null {
 		if (cache.displayRepository) return cache.displayRepository;
 		const now = Date.now();
-		if (now - cache.displayRepositoryCheckedAt < WATCHER_FAILURE_POLL_TTL_MS) return null;
-		let display: VcsRepo | null;
-		try {
-			display = vcs.repoForDisplay(cache.effectiveGitCwd);
-		} catch {
-			display = null;
+		if (now - cache.displayRepositoryCheckedAt >= WATCHER_FAILURE_POLL_TTL_MS) {
+			let display: VcsRepo | null;
+			try {
+				display = vcs.repoForDisplay(cache.effectiveGitCwd);
+			} catch {
+				display = null;
+			}
+			cache.displayRepository = display ?? cache.repository;
+			cache.displayRepositoryCheckedAt = now;
+		}
+		if (!cache.displayRepository) {
+			this.#noteVcsStaleAt(cache.displayRepositoryCheckedAt + WATCHER_FAILURE_POLL_TTL_MS);
 		}
-		cache.displayRepository = display ?? cache.repository;
-		cache.displayRepositoryCheckedAt = now;
 		return cache.displayRepository;
 	}
 
+	/** Lower {@link #vcsStaleAt} to `at` when a served VCS cache expires sooner. */
+	#noteVcsStaleAt(at: number): void {
+		if (at < this.#vcsStaleAt) this.#vcsStaleAt = at;
+	}
+
+	/** Expire the render memo once a served VCS cache has gone stale, so this frame refetches. */
+	#expireStaleVcsRender(nowMs: number): void {
+		if (nowMs < this.#vcsStaleAt) return;
+		this.#vcsStaleAt = Number.POSITIVE_INFINITY;
+		this.#invalidateStatusLineRenderCache();
+	}
+
 	/**
 	 * Re-point the status line at another session (focus proxy). Invalidate: model/context/usage all derive
 	 * from it. `focusedAgentId` is the focused subagent id while the view is proxied, undefined for main.
@@ -1025,11 +1111,15 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		return meter;
 	}
 
-	setPlanModeStatus(status: { enabled: boolean; paused: boolean } | undefined): void {
+	setPlanModeStatus(
+		status: { enabled: boolean; paused: boolean; workflow?: "parallel" | "iterative" | "ultra" } | undefined,
+	): void {
 		const next = status ?? null;
 		if (
 			this.#planModeStatus === next ||
-			(this.#planModeStatus?.enabled === next?.enabled && this.#planModeStatus?.paused === next?.paused)
+			(this.#planModeStatus?.enabled === next?.enabled &&
+				this.#planModeStatus?.paused === next?.paused &&
+				this.#planModeStatus?.workflow === next?.workflow)
 		) {
 			return;
 		}
@@ -1129,6 +1219,11 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		this.#onCodexResetFireworks = handler;
 	}
 
+	/** Set the callback that presents the first pool-wide saved-reset expiry warning, or clear it with `undefined`. */
+	setResetExpiryNoticeHandler(handler: ((notice: string) => void) | undefined): void {
+		this.#onResetExpiryNotice = handler;
+	}
+
 	setHookStatus(key: string, text: string | undefined): void {
 		if (text === undefined) {
 			if (!this.#hookStatuses.delete(key)) return;
@@ -1198,6 +1293,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		this.#stopPricingTimer();
 		this.#clearUsageStartTimer();
 		this.#onCodexResetFireworks = undefined;
+		this.#onResetExpiryNotice = undefined;
 		this.#codexResetSnapshots.clear();
 		this.#retireGitWatcher();
 	}
@@ -1236,7 +1332,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 	 * a 40ms frame timer so the fade keeps animating after the working loader
 	 * (the usual repaint driver) has stopped.
 	 */
-	#brandFgAnsi(working: boolean, sessionAccentEnabled: boolean): string {
+	#brandFgAnsi(working: boolean, sessionAccentEnabled: boolean, brandVisible: boolean): string {
 		const sessionName = sessionAccentEnabled ? this.session.sessionManager?.getSessionName() : undefined;
 		const idleHex = theme.getColorHex("dim");
 		const workingHex =
@@ -1250,7 +1346,8 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 				startedAt: now,
 			};
 			this.#brandWorking = working;
-			this.#startBrandFadeTimer();
+			// Only a visible `pi` segment needs fade frames; other bars stay quiet.
+			if (brandVisible) this.#startBrandFadeTimer();
 		}
 		const hex = this.#sampleBrandHex(working ? workingHex : idleHex, now);
 		return getSessionAccentAnsi(hex) ?? theme.getFgAnsi(working ? "accent" : "dim");
@@ -1449,7 +1546,9 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 			taggedRepository[GIT_VIEW] = gitRepository;
 		}
 		if (!gitRepository) {
-			if (this.#jjBranchActive || Date.now() - this.#jjBranchLastFetch < JJ_REFRESH_TTL_MS) {
+			if (this.#jjBranchActive) return this.#cachedJjBranch;
+			if (Date.now() - this.#jjBranchLastFetch < JJ_REFRESH_TTL_MS) {
+				this.#noteVcsStaleAt(this.#jjBranchLastFetch + JJ_REFRESH_TTL_MS);
 				return this.#cachedJjBranch;
 			}
 			const request: JjResolveRequest = {
@@ -1476,6 +1575,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 					if (this.#jjCacheGeneration === generation) this.#jjBranchLastFetch = Date.now();
 				}
 				if (this.#jjCacheGeneration !== generation || this.#disposed) return;
+				this.#noteVcsStaleAt(this.#jjBranchLastFetch + JJ_REFRESH_TTL_MS);
 				const changed = next !== this.#cachedJjBranch;
 				this.#cachedJjBranch = next;
 				if (changed) {
@@ -1489,6 +1589,9 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 			this.#gitWatcherUnavailable &&
 			(this.#branchLastFetch === undefined || Date.now() - this.#branchLastFetch >= WATCHER_FAILURE_POLL_TTL_MS);
 		if (this.#cachedBranch !== undefined && this.#cachedBranchCwd === gitCwd && !fallbackCacheExpired) {
+			if (this.#gitWatcherUnavailable && this.#branchLastFetch !== undefined) {
+				this.#noteVcsStaleAt(this.#branchLastFetch + WATCHER_FAILURE_POLL_TTL_MS);
+			}
 			return this.#cachedBranch;
 		}
 
@@ -1541,6 +1644,9 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 				this.#cachedBranchRepoId = repoId;
 				this.#cachedBranch = next;
 				this.#branchLastFetch = Date.now();
+				if (this.#gitWatcherUnavailable) {
+					this.#noteVcsStaleAt(this.#branchLastFetch + WATCHER_FAILURE_POLL_TTL_MS);
+				}
 				if (prev !== next) {
 					this.#invalidateStatusLineRenderCache();
 					this.#onBranchChange?.();
@@ -1561,6 +1667,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		this.#cachedBranchCwd = gitCwd;
 		this.#cachedBranchRepoId = gitHeadPath;
 		this.#branchLastFetch = Date.now();
+		if (this.#gitWatcherUnavailable) this.#noteVcsStaleAt(this.#branchLastFetch + WATCHER_FAILURE_POLL_TTL_MS);
 		if (!head) {
 			this.#cachedBranch = null;
 			return null;
@@ -1602,7 +1709,9 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		const repository = this.#resolveRepository(activeRepoCache);
 		if (!repository) return null;
 		if (repository.kind() === "jj") {
-			if (this.#jjStatusActive || Date.now() - this.#jjStatusLastFetch < JJ_REFRESH_TTL_MS) {
+			if (this.#jjStatusActive) return this.#cachedJjStatus;
+			if (Date.now() - this.#jjStatusLastFetch < JJ_REFRESH_TTL_MS) {
+				this.#noteVcsStaleAt(this.#jjStatusLastFetch + JJ_REFRESH_TTL_MS);
 				return this.#cachedJjStatus;
 			}
 			const request: JjResolveRequest = {
@@ -1624,6 +1733,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 					if (this.#jjCacheGeneration === generation) this.#jjStatusLastFetch = Date.now();
 				}
 				if (this.#jjCacheGeneration !== generation || this.#disposed) return;
+				this.#noteVcsStaleAt(this.#jjStatusLastFetch + JJ_REFRESH_TTL_MS);
 				const prev = this.#cachedJjStatus;
 				this.#cachedJjStatus = next;
 				if (JSON.stringify(prev) !== JSON.stringify(next)) {
@@ -1638,6 +1748,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 			return this.#cachedGitStatusCwd === gitCwd ? this.#cachedGitStatus : null;
 		}
 		if (this.#cachedGitStatusCwd === gitCwd && Date.now() - this.#gitStatusLastFetch < GIT_STATUS_TTL_MS) {
+			this.#noteVcsStaleAt(this.#gitStatusLastFetch + GIT_STATUS_TTL_MS);
 			return this.#cachedGitStatus;
 		}
 
@@ -1657,6 +1768,8 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 					this.#cachedGitStatusCwd = gitCwd;
 					this.#gitStatusLastFetch = this.#gitStatusGeneration === generation ? Date.now() : 0;
 					this.#gitStatusInFlightCwd = undefined;
+					// A zeroed stamp (superseded generation) is already due: refetch next frame.
+					this.#noteVcsStaleAt(this.#gitStatusLastFetch + GIT_STATUS_TTL_MS);
 					if (!this.#disposed && JSON.stringify(prev) !== JSON.stringify(nextStatus)) {
 						this.#invalidateStatusLineRenderCache();
 						this.#onBranchChange?.();
@@ -1935,6 +2048,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 			this.#invalidateStatusLineRenderCache();
 			this.#onBranchChange?.();
 		}
+		this.#noticeResetExpiry(session, reports);
 		if (!resetSnapshot) return;
 		const contextKey = this.#formatUsageContextKey(activeProvider, activeIdentity);
 		const previous = this.#codexResetSnapshots.get(contextKey);
@@ -1944,6 +2058,33 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		if (event) this.#onCodexResetFireworks?.(event);
 	}
 
+	#noticeResetExpiry(session: TSession, reports: unknown): void {
+		// A focused subagent's view is not a conversation the user started; warn in their own.
+		if (
+			this.#focusedAgentId !== undefined ||
+			!this.#onResetExpiryNotice ||
+			!this.host.resetExpiryNotice ||
+			!Array.isArray(reports)
+		) {
+			return;
+		}
+		const sessionId = session.sessionManager.getSessionId();
+		if (this.#resetExpiryNoticedSessions.has(sessionId)) return;
+		// fetchUsageReports supplies normalized rows; keep only entries shaped like reports.
+		const usageReports = reports.filter(
+			(report): report is UsageReport =>
+				!!report &&
+				typeof report === "object" &&
+				"provider" in report &&
+				"limits" in report &&
+				Array.isArray(report.limits),
+		);
+		const notice = this.host.resetExpiryNotice(usageReports, Date.now());
+		if (!notice) return;
+		this.#resetExpiryNoticedSessions.add(sessionId);
+		this.#onResetExpiryNotice(notice);
+	}
+
 	#observeLateUsageRefresh(session: TSession, reportsPromise: Promise<unknown>, sequence: number): void {
 		void reportsPromise
 			.then(reports => {
@@ -2050,6 +2191,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 			expiryHours?: number;
 			expired?: boolean;
 			unavailableReason?: string;
+			expiring?: StatusResetExpiry;
 		};
 	} | null {
 		if (!Array.isArray(reports)) return null;
@@ -2167,7 +2309,16 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 					? resetReports.find(report => reportMatchesExactIdentity(report, context.identity))
 					: undefined;
 		const resetSummary = summarizeUsageResetCredits(resetReport?.resetCredits, now);
-		const resetExpiryMs = resetSummary?.soonestExpiry ? Date.parse(resetSummary.soonestExpiry) - now : undefined;
+		const expiring =
+			resetSummary && resetSummary.bankedCount > 0 && resetReport
+				? this.host.classifyResetExpiry?.(resetReport, now)
+				: undefined;
+		// The highlighted countdown is the warned reset's, not an earlier one that is not worth warning about.
+		const resetExpiryMs = expiring
+			? expiring.expiresAtMs - now
+			: resetSummary?.soonestExpiry
+				? Date.parse(resetSummary.soonestExpiry) - now
+				: undefined;
 		const resetCredits =
 			resetSummary && resetSummary.bankedCount > 0
 				? {
@@ -2179,6 +2330,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 								: undefined,
 						expired: resetExpiryMs !== undefined && resetExpiryMs <= 0,
 						unavailableReason: resetSummary.unavailableReason,
+						expiring,
 					}
 				: undefined;
 		if (!selectedGroup) return resetCredits ? { resetCredits } : null;
@@ -2387,7 +2539,9 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		const gitPr = includePr ? this.#lookupPr(activeRepoCache) : null;
 		const compactionSpeculation = this.session.compactionSpeculation ?? "idle";
 		this.#syncSpeculationBlink(compactionSpeculation);
-		const sessionAccentEnabled = this.#resolveSettings().sessionAccent !== false;
+		const settings = this.#resolveSettings();
+		const sessionAccentEnabled = settings.sessionAccent !== false;
+		const brandVisible = settings.leftSegments.includes("pi") || settings.rightSegments.includes("pi");
 		const turnElapsedMs = this.getTurnElapsedMs();
 		return {
 			session: this.session,
@@ -2426,7 +2580,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 			activeMs: this.getActiveMs(),
 			turnElapsedMs,
 			now: new Date(nowMs),
-			brandFgAnsi: this.#brandFgAnsi(turnElapsedMs !== null, sessionAccentEnabled),
+			brandFgAnsi: this.#brandFgAnsi(turnElapsedMs !== null, sessionAccentEnabled, brandVisible),
 			git: {
 				branch: gitBranch,
 				status: gitStatus,
@@ -2655,19 +2809,30 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 
 	/**
 	 * Smallest wall-clock unit that can change a visible configured segment.
-	 * A zero tick keeps truly static bars cached indefinitely; active animation,
-	 * clocks, countdowns, and VCS fallback polling advance only at their own
-	 * display/probe cadence.
+	 * A zero tick keeps truly static bars cached indefinitely; animation, clocks,
+	 * and countdowns advance only at their own display cadence. VCS refreshes are
+	 * deadline-driven ({@link #expireStaleVcsRender}), not ticked.
 	 */
 	#statusLineClock(nowMs: number, effectiveSettings: EffectiveStatusLineSettings): number {
 		const leftSegments = effectiveSettings.leftSegments;
 		const rightSegments = effectiveSettings.rightSegments;
-		const meter = this.#meter();
-		if (meter.activeStartedAt !== null || this.#brandFade !== null) {
+		const turnActive = this.#meter().activeStartedAt !== null;
+		// The `pi` brand is the only spinner-rate animation: its braille spinner
+		// while a turn runs and its color fade across turn edges. While
+		// focus-proxied it shows the viewed agent's id instead.
+		if (
+			(turnActive || this.#brandFade !== null) &&
+			this.#focusedAgentId === undefined &&
+			(leftSegments.includes("pi") || rightSegments.includes("pi"))
+		) {
 			return Math.floor(nowMs / SPINNER_ADVANCE_MS);
 		}
 		const includesTime = leftSegments.includes("time") || rightSegments.includes("time");
 		if (
+			// A running turn also moves readouts that have no invalidation path of
+			// their own (background-job badge, live and vibe-worker tok/s): refresh
+			// them once a second instead of on the spinner tick.
+			turnActive ||
 			leftSegments.includes("time_spent") ||
 			rightSegments.includes("time_spent") ||
 			(this.#loopModeStatus?.limit?.kind === "duration" &&
@@ -2679,12 +2844,6 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		if (includesTime) {
 			return Math.floor(nowMs / 60_000);
 		}
-		if (this.#gitEnabled() && (hasGitBackedSegment(leftSegments) || hasGitBackedSegment(rightSegments))) {
-			return Math.floor(nowMs / 1_000);
-		}
-		if (this.#gitEnabled() && (hasPathSegment(leftSegments) || hasPathSegment(rightSegments))) {
-			return Math.floor(nowMs / WATCHER_FAILURE_POLL_TTL_MS);
-		}
 		return 0;
 	}
 
@@ -2693,6 +2852,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		const externalInputs = this.#externalInputsProbe;
 		this.#readStatusLineExternalInputs(externalInputs);
 		const nowMs = Date.now();
+		this.#expireStaleVcsRender(nowMs);
 		const clockTick = this.#statusLineClock(nowMs, effectiveSettings);
 		if (clockTick !== this.#statusLineClockTick) {
 			this.#statusLineClockTick = clockTick;
@@ -2728,6 +2888,33 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		return result;
 	}
 
+	/**
+	 * Separator glyphs and cell widths for the plain or styled layouts, measured
+	 * once per theme (and style) instead of on every rebuild.
+	 */
+	#separatorMetrics(plain: boolean, style: StatusLineSeparatorStyle): SeparatorMetrics {
+		const themeEpoch = getThemeEpoch();
+		const memo = plain ? this.#plainSeparatorMetrics : this.#styledSeparatorMetrics;
+		if (memo && memo.themeRef === theme && memo.themeEpoch === themeEpoch && (plain || memo.style === style)) {
+			return memo;
+		}
+		const def = plain ? PLAIN_SEPARATOR : getSeparator(style, theme);
+		const metrics: SeparatorMetrics = {
+			themeRef: theme,
+			themeEpoch,
+			style,
+			def,
+			leftSepWidth: visibleWidth(def.left),
+			rightSepWidth: visibleWidth(def.right),
+			leftCapWidth: def.endCaps ? visibleWidth(def.endCaps.right) : 0,
+			rightCapWidth: def.endCaps ? visibleWidth(def.endCaps.left) : 0,
+			bandCapWidth: def.endCaps ? visibleWidth(theme.sep.powerlineCapLeft) : 0,
+		};
+		if (plain) this.#plainSeparatorMetrics = metrics;
+		else this.#styledSeparatorMetrics = metrics;
+		return metrics;
+	}
+
 	/**
 	 * Build the status bar for one of five layouts:
 	 * - `box`: powerline groups joined by the context-reactive gauge line
@@ -2764,9 +2951,8 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 			nowMs,
 			previewTitle,
 		);
-		const separatorDef = plain
-			? { left: "·", right: "·" }
-			: getSeparator(effectiveSettings.separator ?? "powerline-thin", theme);
+		const separators = this.#separatorMetrics(plain, effectiveSettings.separator ?? "powerline-thin");
+		const separatorDef = separators.def;
 
 		// `transparent` reuses the empty-string sentinel (`\x1b[49m`) so the bar
 		// inherits the terminal's default background, matching custom themes that
@@ -2837,17 +3023,18 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		const leftWidths = left.map(part => visibleWidth(part));
 		const rightWidths = right.map(part => visibleWidth(part));
 
-		const leftSepWidth = visibleWidth(separatorDef.left);
-		const rightSepWidth = visibleWidth(separatorDef.right);
+		const leftSepWidth = separators.leftSepWidth;
+		const rightSepWidth = separators.rightSepWidth;
 		// Transparent mode drops powerline caps (they need a bg fill to bridge),
 		// so the width budget excludes them too.
-		const leftCapWidth = separatorDef.endCaps && !transparentBg ? visibleWidth(separatorDef.endCaps.right) : 0;
-		const rightCapWidth = separatorDef.endCaps && !transparentBg ? visibleWidth(separatorDef.endCaps.left) : 0;
+		const capsVisible = separatorDef.endCaps !== undefined && !transparentBg;
+		const leftCapWidth = capsVisible ? separators.leftCapWidth : 0;
+		const rightCapWidth = capsVisible ? separators.rightCapWidth : 0;
 		// The band layout opens flush against the terminal edge with a soft cap
 		// (rust zeta's status band). Like the other caps it needs an opaque
 		// background to bridge, and only powerline separator styles carry caps.
-		const bandCap = layout === "band" && separatorDef.endCaps && !transparentBg ? theme.sep.powerlineCapLeft : "";
-		const bandCapWidth = visibleWidth(bandCap);
+		const bandCap = layout === "band" && capsVisible ? theme.sep.powerlineCapLeft : "";
+		const bandCapWidth = bandCap ? separators.bandCapWidth : 0;
 
 		const groupWidth = (widths: number[], capWidth: number, sepWidth: number): number => {
 			if (widths.length === 0) return 0;
@@ -3114,29 +3301,51 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		}
 		const thresholdColor = getSessionAccentAnsi(dimmedAccent.hex) ?? usedColor;
 
+		// Emit runs, not cells: each stretch of plain rule between markers and
+		// labels is one `repeat`, and color escapes change only at run edges.
+		// Precedence per cell: percent label > threshold > speculation > window label.
+		const percentEnd = percentStart >= 0 ? percentStart + percentLabel.length : -1;
+		const windowEnd = windowStart >= 0 ? windowStart + windowLabel.length : -1;
 		let out = "\x1b[49m";
 		let activeColor = "";
-		for (let i = 0; i < gapWidth; i++) {
-			let color = i < usedCount ? usedColor : unusedColor;
-			let glyph = horizontal;
-			if (percentStart >= 0 && i >= percentStart && i < percentStart + percentLabel.length) {
+		let i = 0;
+		while (i < gapWidth) {
+			let color: string;
+			let text: string;
+			if (i >= percentStart && i < percentEnd) {
+				const end = Math.min(percentEnd, gapWidth);
 				color = percentOverflow ? overflowColor : usedColor;
-				glyph = percentLabel.charAt(i - percentStart);
+				text = percentLabel.slice(i - percentStart, end - percentStart);
+				i = end;
 			} else if (i === thresholdIdx) {
 				color = thresholdColor;
-				glyph = thresholdGlyph;
+				text = thresholdGlyph;
+				i++;
 			} else if (i === speculationIdx) {
 				color = speculationColor;
-				glyph = speculationGlyph;
-			} else if (windowStart >= 0 && i >= windowStart && i < windowStart + windowLabel.length) {
-				color = thresholdColor;
-				glyph = windowLabel.charAt(i - windowStart);
+				text = speculationGlyph;
+				i++;
+			} else {
+				const inWindow = i >= windowStart && i < windowEnd;
+				let end = Math.min(inWindow ? windowEnd : i < usedCount ? usedCount : gapWidth, gapWidth);
+				if (percentStart > i && percentStart < end) end = percentStart;
+				if (thresholdIdx > i && thresholdIdx < end) end = thresholdIdx;
+				if (speculationIdx > i && speculationIdx < end) end = speculationIdx;
+				if (!inWindow && windowStart > i && windowStart < end) end = windowStart;
+				if (inWindow) {
+					color = thresholdColor;
+					text = windowLabel.slice(i - windowStart, end - windowStart);
+				} else {
+					color = i < usedCount ? usedColor : unusedColor;
+					text = horizontal.repeat(end - i);
+				}
+				i = end;
 			}
 			if (color !== activeColor) {
 				out += color;
 				activeColor = color;
 			}
-			out += glyph;
+			out += text;
 		}
 		return `${out}\x1b[39m`;
 	}
@@ -3323,6 +3532,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		const probe = this.#nativeInputsProbe;
 		this.#readStatusLineExternalInputs(probe);
 		const nowMs = Date.now();
+		this.#expireStaleVcsRender(nowMs);
 		const clockTick = this.#nativeClock(nowMs, effectiveSettings);
 		const memo = this.#nativeMemo;
 		if (
@@ -3380,13 +3590,14 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 	#buildComposerFacts(effectiveSettings: EffectiveStatusLineSettings, nowMs: number): ComposerFacts {
 		const { leftSegments, rightSegments } = effectiveSettings;
 		const segments = [...leftSegments, ...rightSegments];
-		// Tern's pane header shows the path and branch from the pane's cwd; only the PR is looked up here.
+		// Tern's pane header shows the path from the pane's cwd; the branch sits by the model chip.
+		const gitEnabled = this.#gitEnabled();
 		const ctx = this.#buildSegmentContext(
 			0,
 			effectiveSettings.segmentOptions,
 			false,
-			false,
-			this.#gitEnabled() && hasPrSegment(segments),
+			gitEnabled && hasGitSegment(segments),
+			gitEnabled && hasPrSegment(segments),
 			nowMs,
 		);
 		const pr = ctx.git.pr ?? undefined;
@@ -3404,8 +3615,12 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 				if (!view) return;
 				const props: TspProps<"seg"> = {
 					role: "zeta.composer.fact",
-					priority: statusSegmentPriority(side, index, ids.length),
+					priority:
+						(PINNED_NATIVE_SEGMENTS[id] === true ? PINNED_NATIVE_PRIORITY : 0) +
+						statusSegmentPriority(side, index, ids.length),
 				};
+				const action = NATIVE_SEGMENT_ACTIONS[id];
+				if (action) props.actions = { click: action };
 				facts.push(describeSeg(id, props, view, dim));
 			});
 		};
@@ -3509,7 +3724,8 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 	/**
 	 * Wall-clock granularity of the native bar. Spinners, turn timers and the
 	 * brand fade are terminal-clocked, so only wall-clock text (time, loop
-	 * countdowns) and VCS fallback polling advance it.
+	 * countdowns) advances it; VCS refreshes are deadline-driven
+	 * ({@link #expireStaleVcsRender}).
 	 */
 	#nativeClock(nowMs: number, effectiveSettings: EffectiveStatusLineSettings): number {
 		const segments = [...effectiveSettings.leftSegments, ...effectiveSettings.rightSegments];
@@ -3521,8 +3737,6 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 			return Math.floor(nowMs / 1_000);
 		}
 		if (includesTime) return Math.floor(nowMs / 60_000);
-		if (this.#gitEnabled() && hasGitBackedSegment(segments)) return Math.floor(nowMs / 1_000);
-		if (this.#gitEnabled() && hasPathSegment(segments)) return Math.floor(nowMs / WATCHER_FAILURE_POLL_TTL_MS);
 		return 0;
 	}
 
@@ -3614,7 +3828,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		}
 		const showHooks = this.#settings.showHookStatus ?? true;
 		if (showHooks && this.#sortedHookStatuses.length > 0) {
-			lines.push(...this.#sortedHookStatuses.map(text => truncateToWidth(sanitizeStatusText(text), width)));
+			lines.push(...this.#sortedHookStatuses.map(text => truncateToWidth(sanitizeHookStatusText(text), width)));
 		}
 		return lines;
 	}