@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-zentui/extensions/zentui/index.ts

@@ -5,17 +5,14 @@ import type {
 	Theme,
 } from "@earendil-works/pi-coding-agent";
 import type { EditorTheme, TUI } from "@earendil-works/pi-tui";
-import {
-	type AccentRailLayoutPatchDiagnostic,
-	installHostAccentRailLayoutPatch,
-	markAccentRailLayoutEditor,
-	retainAccentRailLayoutPatchInstallation,
-} from "./accent-rail-layout-patch";
+import { CodexQuotaCollector, editorWantsCodexQuota } from "./codex-quota";
+import { componentColor } from "./component-colors";
 import {
 	type AccentRailEditorStyleConfig,
 	type ContextStyle,
 	defaultConfig,
 	type EditorComponentConfig,
+	type ExtensionStatusChoice,
 	type ExtensionStatusColorMode,
 	type ExtensionStatusPlacement,
 	ensureConfigExists,
@@ -28,7 +25,8 @@ import {
 	hasUnsupportedComponentStyle,
 	type IconMode,
 	loadConfig,
-	type MinimalistConfig,
+	type MinimalistEditorStylePatch,
+	migrateComponentSelections,
 	type PathDisplayConfig,
 	type PolishedCopyFriendlyEditorStyleConfig,
 	type PolishedEditorStyleConfig,
@@ -36,12 +34,15 @@ import {
 	type SelectorBordersComponentConfig,
 	type SeparatorStyle,
 	saveAccentRailEditorStylePatch,
+	saveComponentColor,
 	saveComponentPreset,
+	saveCustomValueColor,
 	saveEditorComponentPatch,
+	saveExtensionStatusChoice,
 	saveExtensionStatusColorMode,
-	saveExtensionStatusDefaultPlacement,
-	saveExtensionStatusPlacement,
+	saveExtensionStatusDefaultChoice,
 	saveFooterComponentPatch,
+	saveHiddenExtensionStatusColorMode,
 	saveIconsModePatch,
 	saveMinimalistEditorStylePatch,
 	savePolishedCopyFriendlyEditorStylePatch,
@@ -56,26 +57,40 @@ import {
 	type WorkingLineComponentPatch,
 	type ZentuiConfig,
 } from "./config";
+import {
+	editorDemandsCustomVariable,
+	editorMetadataReferences,
+	footerDemandsCustomVariable,
+} from "./custom-variable-demand";
+import { CustomVariables } from "./custom-variables";
 import {
 	type EditorTransferFailureReason,
 	replaceEditorComponentWithExpandedText,
 } from "./editor-transfer";
+import { createExtensionStatusController } from "./extension-status-controller";
 import { installFooter, installHiddenFooter } from "./footer";
-import { collectFooterFormatReferences, parseFooterFormat } from "./footer-format";
+import { compiledFooterFormat } from "./footer-format";
 import {
 	buildSessionDurationLabel,
-	invalidateUsageTotalsCache,
+	EventUsageTotalsController,
 	resolveContextUsage,
 } from "./format";
 import { emptyGitStatus, readGitStatus } from "./git";
+import type { HostTemplateValues } from "./host-template-values";
 import {
+	createTurnSummaryData,
 	InteractionMetricsTracker,
 	renderTurnSummaryEntry,
 	TURN_SUMMARY_ENTRY_TYPE,
 } from "./interaction-summary";
+import { LayeredEditorConsumer } from "./layered-editor";
 import { LiveContextController } from "./live-context";
+import { LiveMetadataController } from "./live-metadata";
+import { editorHostReferences, liveMetadataDemand } from "./live-metadata-demand";
 import { readPackageVersionResult } from "./package-version";
 import { getComponentPreset } from "./presets";
+import { projectDemand } from "./project-demand";
+import { ProjectDiscovery } from "./project-discovery.js";
 import {
 	createProjectRefreshScheduler,
 	type ProjectRefreshRun,
@@ -83,22 +98,26 @@ import {
 	type StopProjectRefreshInterval,
 	startProjectRefreshInterval,
 } from "./project-refresh";
-import { applyProjectRefreshToState } from "./project-state";
+import { applyProjectRefreshToState, projectStateSnapshot } from "./project-state";
 import { RepositoryRootController, type RepositoryRootRequest } from "./repository-root";
 import { readRuntimeInfo } from "./runtime";
 import { installSelectorBorderStyle, removeSelectorBorderStyle } from "./selector-border";
 import { SessionLifecycle } from "./session-lifecycle";
 import { registerZentuiSettingsCommand } from "./settings-command";
-import { createInitialState, type FooterState, modelLabelFor, syncState } from "./state";
-import { resolveFooterTelemetry } from "./telemetry";
+import {
+	createInitialState,
+	type FooterState,
+	modelLabelFor,
+	syncModelState,
+	syncState,
+	syncUsageState,
+} from "./state";
+import { FooterTelemetryController } from "./telemetry";
 import { ThinkingExperimentalController } from "./thinking-experimental";
-import { PolishedEditor, WrappedPolishedEditor } from "./ui";
+import { TurnSummaryRateTracker } from "./turn-summary-rate";
+import { editorWantsContext, PolishedEditor, WrappedPolishedEditor } from "./ui";
 import { installUserMessageStyle, removeUserMessageStyle } from "./user-message";
-import {
-	AgentDurationClock,
-	snapshotWorkingLineHighStyle,
-	WorkingLineController,
-} from "./working-line";
+import { AgentDurationClock, WorkingLineController } from "./working-line";
 import { WorkingLineExtensionSegments } from "./working-line-extension-segments";
 
 const ZENTUI_EDITOR_FACTORY = Symbol.for("pi-zentui.editor-factory");
@@ -152,8 +171,13 @@ function getZentuiEditorBaseFactory(factory: EditorFactory | undefined): EditorF
 export function activeFooterReferences(config: ZentuiConfig): Set<string> {
 	const starship = config.components.footer.styles.starship;
 	const references = starship.format
-		? collectFooterFormatReferences(parseFooterFormat(starship.format), FOOTER_FORMAT_ALIASES)
+		? new Set(compiledFooterFormat(starship.format, FOOTER_FORMAT_ALIASES).references)
 		: new Set<string>([
+				...(starship.segments.cwd ? ["cwd"] : []),
+				...(starship.segments.gitBranch ? ["git_branch"] : []),
+				...(starship.segments.gitStatus ? ["git_status"] : []),
+				...(starship.segments.gitBranch || starship.segments.gitStatus ? ["git_state"] : []),
+				...(config.components.footer.codexQuota ? ["codex_quota"] : []),
 				...(starship.segments.sessionName ? ["session_name"] : []),
 				...(starship.segments.runtime ? ["runtime"] : []),
 				...(starship.segments.gitCommit ? ["git_commit"] : []),
@@ -161,12 +185,13 @@ export function activeFooterReferences(config: ZentuiConfig): Set<string> {
 				...(starship.segments.packageVersion ? ["package"] : []),
 				...(starship.segments.sessionDuration ? ["session_duration"] : []),
 				...(starship.segments.time ? ["time"] : []),
+				...(starship.segments.cost ? ["cost", "subscription"] : []),
+				...(starship.segments.tokens ? ["tokens"] : []),
+				...(starship.segments.context ? ["auto_compaction"] : []),
 			]);
 	if (starship.responsive) {
-		for (const name of collectFooterFormatReferences(
-			parseFooterFormat(starship.compactFormat),
-			FOOTER_FORMAT_ALIASES,
-		)) {
+		for (const name of compiledFooterFormat(starship.compactFormat, FOOTER_FORMAT_ALIASES)
+			.references) {
 			references.add(name);
 		}
 	}
@@ -182,21 +207,46 @@ function isTuiContext(ctx: ExtensionContext): boolean {
 	}
 }
 
-export default function (pi: ExtensionAPI) {
+export type ZentuiHost = {
+	wrapEditor?: boolean;
+	skinOnly?: boolean;
+	liveModel?: boolean;
+	subscribeProjectChanges?: (invalidate: () => void) => () => void;
+	getFastMode?: (ctx: ExtensionContext) => string | undefined;
+	getHostTemplateValues?: (
+		ctx: ExtensionContext,
+		names: ReadonlySet<string>,
+	) => HostTemplateValues | undefined;
+};
+
+export default function (pi: ExtensionAPI, host: ZentuiHost = {}) {
 	const state: FooterState = createInitialState(emptyGitStatus());
 	const sessionLifecycle = new SessionLifecycle();
 	const editorOwnerToken = Symbol("zentui-editor-owner");
 
-	let currentConfig: PolishedTuiConfig = structuredClone(defaultConfig);
+	// Unsupported OMP surfaces stay native; this runtime view is never written back.
+	const scopeConfig = (config: PolishedTuiConfig): PolishedTuiConfig =>
+		host.skinOnly
+			? {
+					...config,
+					components: {
+						...config.components,
+						thinkingSteps: { ...config.components.thinkingSteps, enabled: false },
+						workingLine: { ...config.components.workingLine, enabled: false },
+						selectorBorders: { ...config.components.selectorBorders, enabled: false },
+					},
+				}
+			: config;
+	let currentConfig: PolishedTuiConfig = scopeConfig(structuredClone(defaultConfig));
 	// Keep the capability guard defensive for hosts with incomplete extension APIs.
-	if (typeof pi.registerEntryRenderer === "function") {
+	if (!host.skinOnly && typeof pi.registerEntryRenderer === "function") {
 		pi.registerEntryRenderer(TURN_SUMMARY_ENTRY_TYPE, (entry, options, theme) =>
 			renderTurnSummaryEntry(
 				entry,
 				{
 					...options,
 					colorSource: currentConfig.components.workingLine.colorSource,
-					workingLineHigh: currentConfig.colors.workingLineHigh,
+					workingLineHigh: componentColor(currentConfig, "workingLine", "high"),
 				},
 				theme,
 			),
@@ -205,6 +255,9 @@ export default function (pi: ExtensionAPI) {
 	let activeTheme: Theme | undefined;
 	let requestFooterRender: (() => void) | undefined;
 	let requestEditorRender: (() => void) | undefined;
+	const extensionStatuses = createExtensionStatusController(
+		() => currentConfig.components.extensionStatuses,
+	);
 	let getActiveExtensionStatuses: () => ReadonlyMap<string, string> = () => new Map();
 	let stopRefreshInterval: StopProjectRefreshInterval = () => {};
 	let cleanupUserMessageStyle: () => void = () => {};
@@ -216,35 +269,34 @@ export default function (pi: ExtensionAPI) {
 	let editorInstalled = false;
 	let editorInstallMode: EditorInstallMode = "none";
 	let installedEditorFactory: EditorFactory | undefined;
+	let activeEditor:
+		| {
+				editor: PolishedEditor | WrappedPolishedEditor;
+				factory: EditorFactory;
+				generation: number;
+		  }
+		| undefined;
 	let wrappedEditorFactory: EditorFactory | undefined;
 	let stopSessionTimer: () => void = () => {};
 	let stopMinimalistDurationUpdates: () => void = () => {};
 	let minimalistDurationUpdatesActive = false;
-	let minimalistDecorationActive = false;
+	let minimalistDecorationEditor: PolishedEditor | WrappedPolishedEditor | undefined;
+	let customVariableSessionReady = false;
 	let sessionTimerRequirements = "";
 	let lastDurationLabel = "";
 	let lastProjectCwd: string | undefined;
 	const agentDurationClock = new AgentDurationClock();
 	const interactionMetrics = new InteractionMetricsTracker();
+	const summaryRate = new TurnSummaryRateTracker();
+	const summaryEnabled = () =>
+		!host.skinOnly &&
+		currentConfig.components.workingLine.enabled &&
+		currentConfig.components.workingLine.turnSummary;
 	let agentRunActive = false;
 	let minimalistProjectRoot: string | undefined;
 	const repositoryRoots = new RepositoryRootController();
 	let projectRefreshActive = false;
 	let activeTuiContext: ExtensionContext | undefined;
-	let cleanupAccentRailLayoutPatch: () => void = () => {};
-	let accentRailLayoutPatchInstallSerial = 0;
-
-	const recordAccentRailLayoutPatchDiagnostic = (
-		diagnostic: AccentRailLayoutPatchDiagnostic,
-		version?: string,
-	) => {
-		if (process.env.ZENTUI_DEBUG === "1") {
-			console.error(
-				`[zentui] Accent Rail fullscreen layout patch: ${diagnostic}${version ? ` (Pi TUI ${version})` : ""}`,
-			);
-		}
-	};
-
 	const isOwnedEditorFactory = (factory: EditorFactory | undefined) =>
 		(factory as ZentuiEditorFactory | undefined)?.[ZENTUI_EDITOR_OWNER] === editorOwnerToken;
 	const effectiveEditorEnabled = () =>
@@ -280,10 +332,61 @@ export default function (pi: ExtensionAPI) {
 		}
 	};
 
+	const layeredEditor = new LayeredEditorConsumer<
+		EditorFactory,
+		PolishedEditor | WrappedPolishedEditor
+	>((generation) => sessionLifecycle.isCurrent(generation));
+	const currentEditorFactory = (): EditorFactory | undefined => {
+		try {
+			return activeTuiContext?.ui.getEditorComponent();
+		} catch {
+			return undefined;
+		}
+	};
+	// Layered visibility does not grant installation ownership: editor install/restore stays exclusive.
+	// Data, demand, and timer consumers use these helpers; Working-line placement additionally
+	// requires focused, rendered border capability before its controller hides its own host row.
+	// Ownership counts before Pi constructs its editor; layered visibility requires the recorded
+	// instance to remain reachable through the current factory.
+	const layeredVisibleEditor = () => layeredEditor.editorVisibleThrough(currentEditorFactory());
+	const editorConsumerActive = () =>
+		ownsInstalledEditorFactory() || layeredVisibleEditor() !== undefined;
+	const visibleEditor = () =>
+		ownsInstalledEditorFactory() ? activeEditor?.editor : layeredVisibleEditor();
+	const requestEditorRepaint = () => {
+		requestEditorRender?.();
+		// The layered record intentionally outlives ownership clearing, so disabling the editor is
+		// gated here; a live wrapper keeps repainting while the editor remains enabled.
+		if (effectiveEditorEnabled()) layeredEditor.requestRender(currentEditorFactory());
+	};
+
+	const customVariables = new CustomVariables(
+		pi.events,
+		(key) => {
+			if (!customVariableSessionReady || !sessionLifecycle.isCurrent()) return false;
+			return (
+				(effectiveEditorEnabled() &&
+					visibleEditor()?.isMetadataDecorated() === true &&
+					editorDemandsCustomVariable(currentConfig, key)) ||
+				(installedFooterKind === "starship" &&
+					ownsInstalledFooter() &&
+					footerDemandsCustomVariable(currentConfig, key))
+			);
+		},
+		() => {
+			if (!customVariableSessionReady || !sessionLifecycle.isCurrent()) return;
+			requestEditorRepaint();
+			requestFooterRender?.();
+		},
+	);
 	const refresh = () => {
 		if (!sessionLifecycle.isCurrent()) return;
+		customVariables.reconcile();
+		summaryRate.reconcile(summaryEnabled());
+		codexQuota.reconcile();
+		reconcileLiveMetadata();
 		requestFooterRender?.();
-		requestEditorRender?.();
+		requestEditorRepaint();
 	};
 	const thinkingExperimental = new ThinkingExperimentalController(
 		() => currentConfig.components.thinkingSteps,
@@ -305,10 +408,28 @@ export default function (pi: ExtensionAPI) {
 		Date.now,
 		() => interactionMetrics.currentThought(),
 		() => invalidateWorkingLinePublisherState(),
+		undefined,
+		(ctx) => {
+			if (!activeTuiContext || ctx.ui !== activeTuiContext.ui) return false;
+			// Factory visibility alone is insufficient: the current focused editor must have
+			// rendered safe border geometry before the separately owned Working row can hide.
+			return Boolean(
+				sessionLifecycle.isCurrent() &&
+					effectiveEditorEnabled() &&
+					currentConfig.components.editor.style !== "accent-rail" &&
+					visibleEditor()?.canEmbedWorkingLineBorder(),
+			);
+		},
 	);
+	if (!host.skinOnly)
+		workingLine.setRequestRender(() => {
+			if (sessionLifecycle.isCurrent()) {
+				requestEditorRepaint();
+			}
+		});
 	let workingLineSessionReady = false;
 	const workingLineExtensions = new WorkingLineExtensionSegments(
-		pi.events,
+		host.skinOnly ? undefined : pi.events,
 		() =>
 			workingLineSessionReady &&
 			sessionLifecycle.isCurrent() &&
@@ -319,39 +440,81 @@ export default function (pi: ExtensionAPI) {
 			if (activeTuiContext && sessionLifecycle.isCurrent()) {
 				const applied = workingLine.updateExtensionSegments(segments, activeTuiContext);
 				if (!applied && !workingLine.isAvailable()) {
-					workingLine.invalidateExtensionSegments();
+					if (!host.skinOnly) workingLine.invalidateExtensionSegments();
 				}
 				return applied;
 			}
 			return false;
 		},
 	);
-	invalidateWorkingLinePublisherState = () => workingLineExtensions.invalidate();
-	const getContextSnapshot = (ctx: ExtensionContext) => resolveContextUsage(ctx, liveContext.get());
-	const getContextWindow = (ctx: ExtensionContext): number | undefined =>
-		getContextSnapshot(ctx).contextWindow;
-	const getContextPercent = (ctx: ExtensionContext): number | undefined =>
-		getContextSnapshot(ctx).percent;
+	invalidateWorkingLinePublisherState = () => {
+		workingLineExtensions.invalidate();
+		reconcileLiveMetadata();
+	};
+	const getEditorContextMetadata = (ctx: ExtensionContext) => {
+		const context = editorWantsContext(currentConfig)
+			? resolveContextUsage(ctx, liveContext.get())
+			: undefined;
+		return { contextPercent: context?.percent, contextWindow: context?.contextWindow };
+	};
+	const getEditorHostTemplateValues = (ctx: ExtensionContext) => {
+		const names = editorHostReferences(currentConfig);
+		return liveMetadata.read(names, host.getHostTemplateValues?.(ctx, names));
+	};
 	const getEditorMeta = (ctx: ExtensionContext) => {
-		const context = getContextSnapshot(ctx);
+		if (host.liveModel) syncModelState(state, ctx.model);
 		return {
+			codexQuota: getEditorQuota(),
 			modelLabel: modelLabelFor(state, currentConfig.components.editor.modelLabel),
 			modelId: state.modelId,
 			modelName: state.modelName,
 			providerLabel: state.providerLabel,
+			fastMode: host.getFastMode?.(ctx),
+			hostTemplateValues: getEditorHostTemplateValues(ctx),
 			sessionName: ctx.sessionManager.getSessionName() ?? "",
-			contextPercent: context.percent,
-			contextWindow: context.contextWindow,
+			...getEditorContextMetadata(ctx),
 			inputTokens: state.usageTotals.input,
 			outputTokens: state.usageTotals.output,
 			cacheHitRate: state.usageTotals.latestCacheHitRate,
+			customVariables: customVariables.snapshot(),
 		};
 	};
 	const getAgentDurationMs = () => agentDurationClock.elapsedMs();
 	const getThinkingLevel = () =>
 		sessionLifecycle.isCurrent() ? pi.getThinkingLevel() : ("off" as const);
+	const footerTelemetry = new FooterTelemetryController();
+	const getFooterTelemetry = (ctx: ExtensionContext) => {
+		const references = installedFooterReferences();
+		return footerTelemetry.resolve(ctx, {
+			subscription: references.has("subscription"),
+			autoCompaction: references.has("auto_compaction"),
+		});
+	};
+	const syncFooterTelemetry = (ctx: ExtensionContext) => {
+		const telemetry = getFooterTelemetry(ctx);
+		state.subscription = telemetry.subscription === true;
+		state.autoCompaction = telemetry.autoCompaction === true;
+	};
+	const usageTotals = new EventUsageTotalsController();
+	const getFooterUsage = (ctx: ExtensionContext) => {
+		const references = installedFooterReferences();
+		return usageTotals.resolve(
+			ctx,
+			(effectiveEditorEnabled() &&
+				editorConsumerActive() &&
+				["tokens", "input_tokens", "output_tokens", "cost", "cache_hit"].some((name) =>
+					editorMetadataReferences(currentConfig).has(name),
+				)) ||
+				["tokens", "cache_read", "cache_write", "cost"].some((name) => references.has(name)),
+		);
+	};
+	const syncFooterUsage = (ctx: ExtensionContext) =>
+		syncUsageState(state, getFooterUsage(ctx), currentConfig.icons.cacheHit);
 	const syncFooterState = (ctx: ExtensionContext) =>
-		syncState(state, ctx, currentConfig.icons.cacheHit, resolveFooterTelemetry(ctx));
+		syncState(state, ctx, currentConfig.icons.cacheHit, getFooterTelemetry(ctx), {
+			includeContextLabel: false,
+			usageTotals: getFooterUsage(ctx),
+		});
 	const ownsInstalledFooter = () =>
 		Boolean(
 			activeTuiContext &&
@@ -363,6 +526,81 @@ export default function (pi: ExtensionAPI) {
 			? activeFooterReferences(currentConfig)
 			: new Set<string>();
 
+	const createLiveMetadata = () =>
+		new LiveMetadataController(
+			(command, args, options) => pi.exec(command, args, options),
+			(text) => {
+				if (!host.skinOnly && activeTuiContext && sessionLifecycle.isCurrent())
+					workingLine.updateTokenRate(text, activeTuiContext);
+			},
+			() => {
+				if (sessionLifecycle.isCurrent()) {
+					requestEditorRepaint();
+					requestFooterRender?.();
+				}
+			},
+			() => reconcileLiveMetadata(),
+		);
+	let liveMetadata = createLiveMetadata();
+	let unsubscribeHostProjectChanges = () => {};
+	const reconcileLiveMetadata = () => {
+		const ctx = activeTuiContext;
+		const current = ctx && sessionLifecycle.isCurrent() && isTuiContext(ctx);
+		liveMetadata.reconcile(
+			current
+				? { cwd: ctx.cwd, scopeKey: String(sessionLifecycle.currentGeneration()) }
+				: undefined,
+			liveMetadataDemand(
+				currentConfig,
+				{
+					editor: Boolean(
+						current &&
+							effectiveEditorEnabled() &&
+							editorConsumerActive() &&
+							visibleEditor()?.isMetadataDecorated() === true,
+					),
+					footer: Boolean(current && installedFooterKind === "starship" && ownsInstalledFooter()),
+					workingLine: Boolean(
+						current && !host.skinOnly && workingLineSessionReady && workingLine.isAvailable(),
+					),
+				},
+				!host.skinOnly,
+			),
+		);
+	};
+	const suspendTokenRate = () => liveMetadata.suspendRate();
+	const clearTokenRate = () => liveMetadata.suspendRate(true);
+
+	const codexQuota = new CodexQuotaCollector(
+		() => {
+			const ctx = activeTuiContext;
+			if (
+				!ctx ||
+				!sessionLifecycle.isCurrent() ||
+				!isTuiContext(ctx) ||
+				ctx.model?.provider !== "openai-codex"
+			)
+				return undefined;
+			const editorDemand =
+				effectiveEditorEnabled() && editorConsumerActive() && editorWantsCodexQuota(currentConfig);
+			const footerDemand =
+				effectiveFooterStyle() === "starship" &&
+				currentConfig.components.footer.codexQuota &&
+				installedFooterReferences().has("codex_quota");
+			return editorDemand || footerDemand ? ctx : undefined;
+		},
+		() => {
+			if (!sessionLifecycle.isCurrent()) return;
+			requestFooterRender?.();
+			requestEditorRepaint();
+		},
+	);
+	const getEditorQuota = () =>
+		currentConfig.components.editor.codexQuota &&
+		activeTuiContext?.model?.provider === "openai-codex"
+			? codexQuota.get()
+			: undefined;
+
 	type ProjectRefreshTarget = {
 		repository: RepositoryRootRequest;
 		sessionGeneration: number;
@@ -377,29 +615,21 @@ export default function (pi: ExtensionAPI) {
 			!sessionLifecycle.isCurrent(sessionGeneration) ||
 			!repositoryRoots.isCurrent(repository)
 		) {
-			return;
+			return false;
 		}
-		const starship = currentConfig.components.footer.styles.starship;
-		const gitCommitConfig = starship.gitCommit;
-		const gitMetricsConfig = starship.gitMetrics;
-		const references = installedFooterReferences();
-		const wantExactTag =
-			(references.has("git_commit") && gitCommitConfig.showTag) || references.has("git_tag");
-		const wantMetrics =
-			references.has("git_metrics") || references.has("git_added") || references.has("git_deleted");
-		const wantPackage = references.has("package") || references.has("package_version");
-		const wantRuntime = references.has("runtime");
+		const demand = getProjectDemand();
+		if (!demand.active) return false;
+		const discovery =
+			demand.runtime || demand.packageVersion ? new ProjectDiscovery(cwd) : undefined;
 		const [git, runtime, packageVersion] = await Promise.all([
-			readGitStatus(cwd, {
-				readExactTag: wantExactTag,
-				readMetrics: wantMetrics,
-				ignoreSubmodules: gitMetricsConfig.ignoreSubmodules,
-			}),
-			wantRuntime
-				? readRuntimeInfo(cwd)
+			demand.git
+				? readGitStatus(cwd, demand.gitOptions)
+				: Promise.resolve({ kind: "not_a_repo" as const }),
+			demand.runtime
+				? readRuntimeInfo(cwd, discovery)
 				: Promise.resolve({ kind: "ok" as const, runtime: undefined }),
-			wantPackage
-				? readPackageVersionResult(cwd)
+			demand.packageVersion
+				? readPackageVersionResult(cwd, discovery)
 				: Promise.resolve({ kind: "ok" as const, result: null }),
 		]);
 		if (
@@ -407,9 +637,12 @@ export default function (pi: ExtensionAPI) {
 			!sessionLifecycle.isCurrent(sessionGeneration) ||
 			!repositoryRoots.isCurrent(repository)
 		) {
-			return;
+			return false;
 		}
-		minimalistProjectRoot = repositoryRoots.update(repository, git.kind === "ok");
+		if (JSON.stringify(demand) !== JSON.stringify(getProjectDemand())) return false;
+		const previous = projectStateSnapshot(state, lastProjectCwd, minimalistProjectRoot);
+		// Root-only consumers validate markers without paying for a git status probe.
+		minimalistProjectRoot = repositoryRoots.update(repository, demand.root);
 		lastProjectCwd = applyProjectRefreshToState(state, {
 			cwd,
 			previousCwd: lastProjectCwd,
@@ -417,6 +650,9 @@ export default function (pi: ExtensionAPI) {
 			runtime,
 			packageVersion,
 		});
+		const changed = previous !== projectStateSnapshot(state, lastProjectCwd, minimalistProjectRoot);
+		if (changed) liveMetadata.invalidateProject();
+		return changed;
 	};
 
 	const projectRefreshScheduler = createProjectRefreshScheduler(refreshProjectState, refresh);
@@ -426,30 +662,37 @@ export default function (pi: ExtensionAPI) {
 	) => {
 		const sessionGeneration = sessionLifecycle.currentGeneration();
 		if (!sessionLifecycle.isCurrent(sessionGeneration)) return;
+		if (!needsProjectRefresh()) {
+			stopProjectRefresh();
+			return;
+		}
 		const repository = repositoryRoots.request(ctx.cwd);
 		minimalistProjectRoot = repositoryRoots.cachedRootForCwd(ctx.cwd);
 		projectRefreshScheduler.schedule({ repository, sessionGeneration }, options);
 	};
 
-	const minimalistProjectRequired = () => {
-		const editor = currentConfig.components.editor;
-		const minimalist = editor.styles.minimalist;
-		return (
+	const getProjectDemand = () =>
+		projectDemand(
+			currentConfig,
+			installedFooterReferences(),
 			effectiveEditorEnabled() &&
-			ownsInstalledEditorFactory() &&
-			editor.style === "minimalist" &&
-			(minimalist.showGit || minimalist.pathDisplay === "project")
+				editorConsumerActive() &&
+				currentConfig.components.editor.style === "minimalist",
 		);
-	};
 
-	const needsProjectRefresh = () =>
-		(installedFooterKind === "starship" && ownsInstalledFooter()) || minimalistProjectRequired();
+	const needsProjectRefresh = () => getProjectDemand().active;
 
 	const stopProjectRefresh = () => {
 		stopRefreshInterval();
 		stopRefreshInterval = () => {};
 		projectRefreshScheduler.stop();
 		projectRefreshActive = false;
+		Object.assign(state, emptyGitStatus());
+		state.runtime = undefined;
+		state.packageVersion = undefined;
+		lastProjectCwd = undefined;
+		minimalistProjectRoot = undefined;
+		repositoryRoots.reset();
 	};
 
 	const reconcileProjectRefresh = (ctx: ExtensionContext, force = false) => {
@@ -480,7 +723,10 @@ export default function (pi: ExtensionAPI) {
 
 	const refreshInteractiveState = (ctx: ExtensionContext, project = false) => {
 		if (!sessionLifecycle.isCurrent() || !ctx.hasUI) return;
+		if (activeTuiContext?.ui === ctx.ui) activeTuiContext = ctx;
 		if (editorInstalled && !ownsInstalledEditorFactory()) reconcileObservedEditorOwnership(ctx);
+		// A layered editor can stop being visible without any ownership transition to observe.
+		if (projectRefreshActive && !needsProjectRefresh()) stopProjectRefresh();
 		syncFooterState(ctx);
 		if (project && needsProjectRefresh()) scheduleProjectRefresh(ctx);
 		refresh();
@@ -532,11 +778,10 @@ export default function (pi: ExtensionAPI) {
 			sessionLifecycle.isCurrent() &&
 			agentRunActive &&
 			agentDurationClock.isActive() &&
-			minimalistDecorationActive &&
+			minimalistDecorationActive() &&
 			effectiveEditorEnabled() &&
-			ownsInstalledEditorFactory() &&
 			currentConfig.components.editor.style === "minimalist" &&
-			currentConfig.components.editor.styles.minimalist.showTimer;
+			editorMetadataReferences(currentConfig).has("turn_duration");
 		if (!needed) {
 			stopMinimalistDurationUpdates();
 			stopMinimalistDurationUpdates = () => {};
@@ -555,12 +800,26 @@ export default function (pi: ExtensionAPI) {
 		});
 	};
 
-	const setMinimalistDecorationActive = (active: boolean) => {
-		const next = sessionLifecycle.isCurrent() && active && ownsInstalledEditorFactory();
-		if (minimalistDecorationActive === next) return;
-		minimalistDecorationActive = next;
+	// Decoration is bound to the editor instance that reported it, so it stays valid while that
+	// editor is visible (owned or layered) and cannot leak to a replacement editor.
+	const minimalistDecorationActive = () =>
+		sessionLifecycle.isCurrent() &&
+		minimalistDecorationEditor !== undefined &&
+		visibleEditor() === minimalistDecorationEditor;
+	const reconcileMinimalistDecoration = () => {
+		customVariables.reconcile();
+		reconcileLiveMetadata();
 		reconcileAgentTimer();
 	};
+	const setMinimalistDecorationActive = (
+		active: boolean,
+		editor?: PolishedEditor | WrappedPolishedEditor,
+	) => {
+		const next = active ? editor : undefined;
+		if (minimalistDecorationEditor === next) return;
+		minimalistDecorationEditor = next;
+		reconcileMinimalistDecoration();
+	};
 
 	const startAgentTurn = (interactionStarted: boolean) => {
 		agentRunActive = true;
@@ -601,7 +860,10 @@ export default function (pi: ExtensionAPI) {
 		const before = activeFooterReferences(currentConfig);
 		const nextConfig = save();
 		const after = activeFooterReferences(nextConfig);
-		currentConfig = nextConfig;
+		currentConfig = scopeConfig(nextConfig);
+		syncFooterUsage(ctx);
+		syncFooterTelemetry(ctx);
+		codexQuota.reconcile();
 		if (sameReferences(before, after)) return;
 		reconcileSessionTimer();
 		reconcileProjectRefresh(ctx, true);
@@ -678,20 +940,26 @@ export default function (pi: ExtensionAPI) {
 	};
 
 	const clearEditorOwnership = () => {
-		setMinimalistDecorationActive(false);
+		activeEditor = undefined;
+		if (activeTuiContext && workingLineSessionReady) {
+			if (!host.skinOnly) workingLine.reconcile(activeTuiContext);
+		}
 		requestEditorRender = undefined;
 		wrappedEditorFactory = undefined;
 		installedEditorFactory = undefined;
 		editorInstallMode = "none";
 		editorInstalled = false;
+		reconcileMinimalistDecoration();
+		codexQuota.reconcile();
 	};
 
 	const trackZentuiEditorFactory = (factory: EditorFactory): boolean => {
 		if (!isOwnedEditorFactory(factory)) return false;
+		if (activeEditor?.factory !== factory) activeEditor = undefined;
 		const baseFactory = getZentuiEditorBaseFactory(factory);
 		wrappedEditorFactory = baseFactory;
 		installedEditorFactory = factory;
-		editorInstallMode = baseFactory ? "wrapper" : "standalone";
+		editorInstallMode = baseFactory && host.wrapEditor !== false ? "wrapper" : "standalone";
 		editorInstalled = true;
 		return true;
 	};
@@ -708,7 +976,13 @@ export default function (pi: ExtensionAPI) {
 
 	const reconcileObservedEditorOwnership = (ctx: ExtensionContext) => {
 		const observed = observeEditorFactory(ctx);
-		if (!observed.known) return observed;
+		if (!observed.known) {
+			activeEditor = undefined;
+			if (workingLineSessionReady) {
+				if (!host.skinOnly) workingLine.reconcile(ctx);
+			}
+			return observed;
+		}
 		if (observed.factory && isOwnedEditorFactory(observed.factory)) {
 			trackZentuiEditorFactory(observed.factory);
 		} else {
@@ -718,52 +992,126 @@ export default function (pi: ExtensionAPI) {
 		return observed;
 	};
 
-	const accentRailLayoutActive = () =>
-		sessionLifecycle.isCurrent() &&
-		ownsInstalledEditorFactory() &&
-		effectiveEditorEnabled() &&
-		currentConfig.components.editor.style === "accent-rail";
+	// Also true for an editor still visible beneath a foreign wrapper; installation stays exclusive.
+	const isVisibleEditor = (editor: PolishedEditor | WrappedPolishedEditor, generation: number) =>
+		sessionLifecycle.isCurrent(generation) && visibleEditor() === editor;
+
+	const editorBorderCapabilityChanged = (
+		editor: PolishedEditor | WrappedPolishedEditor,
+		generation: number,
+	) => {
+		if (!isVisibleEditor(editor, generation) || !activeTuiContext || !workingLineSessionReady)
+			return;
+		if (!host.skinOnly) workingLine.reconcile(activeTuiContext);
+		if (workingLine.isAvailable()) requestEditorRepaint();
+	};
+
+	const editorMetadataDecorationChanged = (
+		editor: PolishedEditor | WrappedPolishedEditor,
+		generation: number,
+	) => {
+		if (isVisibleEditor(editor, generation)) {
+			customVariables.reconcile();
+			reconcileLiveMetadata();
+		}
+	};
 
-	const markOwnedAccentRailEditor = <T extends object>(editor: T): T => {
-		markAccentRailLayoutEditor(editor, editorOwnerToken, accentRailLayoutActive);
-		return editor;
+	const editorWorkingLineFrame = (
+		editor: PolishedEditor | WrappedPolishedEditor,
+		generation: number,
+	) => {
+		if (host.skinOnly || !sessionLifecycle.isCurrent(generation)) return undefined;
+		// Even a stale instance render must release a row whose current border disappeared.
+		const frame = workingLine.currentWorkingLineFrame();
+		return isVisibleEditor(editor, generation) ? frame : undefined;
+	};
+
+	/** Records a freshly constructed editor as owned (exclusive) or visible beneath a foreign wrapper. */
+	const registerConstructedEditor = (
+		ctx: ExtensionContext,
+		factory: ZentuiEditorFactory,
+		generation: number,
+		editor: PolishedEditor | WrappedPolishedEditor,
+		tui: TUI,
+	) => {
+		const observed = observeEditorFactory(ctx);
+		if (
+			!sessionLifecycle.isCurrent(generation) ||
+			activeTuiContext?.ui !== ctx.ui ||
+			!observed.known
+		) {
+			return;
+		}
+		if (observed.factory === factory) {
+			activeEditor = { editor, factory, generation };
+			requestEditorRender = () => tui.requestRender();
+		} else if (observed.factory && !isZentuiEditorFactory(observed.factory)) {
+			// A foreign wrapper built this editor beneath its own outer factory.
+			layeredEditor.attach(observed.factory, generation, editor, () => tui.requestRender());
+		}
 	};
 
-	const makeEditorFactory = (ctx: ExtensionContext): ZentuiEditorFactory => {
+	const makeEditorFactory = (
+		ctx: ExtensionContext,
+		baseFactory: EditorFactory | undefined,
+	): ZentuiEditorFactory => {
 		const sessionTheme = ctx.ui.theme;
+		const generation = sessionLifecycle.currentGeneration();
 		const factory = ((tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager) => {
-			requestEditorRender = () => tui.requestRender();
-			return markOwnedAccentRailEditor(
-				new PolishedEditor(
-					tui,
-					theme,
-					keybindings,
-					sessionTheme,
-					getCurrentConfig,
-					() => getEditorMeta(ctx),
-					getThinkingLevel,
-					() => ({
-						cwd: ctx.cwd,
+			const editor: PolishedEditor = new PolishedEditor(
+				tui,
+				theme,
+				keybindings,
+				sessionTheme,
+				getCurrentConfig,
+				() => getEditorMeta(activeTuiContext ?? ctx),
+				getThinkingLevel,
+				() => {
+					if (host.liveModel) syncModelState(state, (activeTuiContext ?? ctx).model);
+					const workingLineFrame = editorWorkingLineFrame(editor, generation);
+					if (currentConfig.components.editor.style !== "minimalist") {
+						return { cwd: "", workingLineFrame };
+					}
+					return {
+						codexQuota: getEditorQuota(),
+						cwd: (activeTuiContext ?? ctx).cwd,
 						projectRoot: minimalistProjectRoot,
 						branch: state.branch,
 						dirty: state.dirty,
 						ahead: state.ahead,
 						behind: state.behind,
 						costLabel: state.costLabel,
+						customVariables: customVariables.snapshot(),
+						modelId: state.modelId,
+						modelName: state.modelName,
+						provider: state.providerLabel,
+						inputTokens: state.usageTotals.input,
+						outputTokens: state.usageTotals.output,
 						modelLabel: modelLabelFor(state, currentConfig.components.editor.modelLabel),
 						thinkingLevel: getThinkingLevel(),
-						contextPercent: getContextPercent(ctx),
-						contextWindow: getContextWindow(ctx),
-						sessionName: ctx.sessionManager.getSessionName() ?? "",
+						fastMode: host.getFastMode?.(activeTuiContext ?? ctx),
+						hostTemplateValues: getEditorHostTemplateValues(activeTuiContext ?? ctx),
+						...getEditorContextMetadata(activeTuiContext ?? ctx),
+						cacheHitRate: state.usageTotals.latestCacheHitRate,
+						sessionName: (activeTuiContext ?? ctx).sessionManager.getSessionName() ?? "",
 						agentDurationMs: getAgentDurationMs(),
 						agentActive: agentRunActive,
-					}),
-					setMinimalistDecorationActive,
-				),
+						workingLineFrame,
+					};
+				},
+				(active) => {
+					if (isVisibleEditor(editor, generation)) setMinimalistDecorationActive(active, editor);
+				},
+				() => editorBorderCapabilityChanged(editor, generation),
+				() => editorMetadataDecorationChanged(editor, generation),
 			);
+			registerConstructedEditor(ctx, factory, generation, editor, tui);
+			return editor;
 		}) as ZentuiEditorFactory;
 		factory[ZENTUI_EDITOR_FACTORY] = true;
 		factory[ZENTUI_EDITOR_OWNER] = editorOwnerToken;
+		// Retain an observed predecessor for restoration without delegating input to it.
+		factory[ZENTUI_EDITOR_BASE_FACTORY] = baseFactory;
 		return factory;
 	};
 
@@ -772,34 +1120,55 @@ export default function (pi: ExtensionAPI) {
 		baseFactory: EditorFactory,
 	): ZentuiEditorFactory => {
 		const sessionTheme = ctx.ui.theme;
+		const generation = sessionLifecycle.currentGeneration();
 		const factory = ((tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager) => {
-			requestEditorRender = () => tui.requestRender();
-			return markOwnedAccentRailEditor(
-				new WrappedPolishedEditor(
-					baseFactory(tui, theme, keybindings),
-					sessionTheme,
-					getCurrentConfig,
-					() => getEditorMeta(ctx),
-					getThinkingLevel,
-					() => ({
-						cwd: ctx.cwd,
+			const editor: WrappedPolishedEditor = new WrappedPolishedEditor(
+				baseFactory(tui, theme, keybindings),
+				sessionTheme,
+				getCurrentConfig,
+				() => getEditorMeta(activeTuiContext ?? ctx),
+				getThinkingLevel,
+				() => {
+					if (host.liveModel) syncModelState(state, (activeTuiContext ?? ctx).model);
+					const workingLineFrame = editorWorkingLineFrame(editor, generation);
+					if (currentConfig.components.editor.style !== "minimalist") {
+						return { cwd: "", workingLineFrame };
+					}
+					return {
+						codexQuota: getEditorQuota(),
+						cwd: (activeTuiContext ?? ctx).cwd,
 						projectRoot: minimalistProjectRoot,
 						branch: state.branch,
 						dirty: state.dirty,
 						ahead: state.ahead,
 						behind: state.behind,
 						costLabel: state.costLabel,
+						customVariables: customVariables.snapshot(),
+						modelId: state.modelId,
+						modelName: state.modelName,
+						provider: state.providerLabel,
+						inputTokens: state.usageTotals.input,
+						outputTokens: state.usageTotals.output,
 						modelLabel: modelLabelFor(state, currentConfig.components.editor.modelLabel),
 						thinkingLevel: getThinkingLevel(),
-						contextPercent: getContextPercent(ctx),
-						contextWindow: getContextWindow(ctx),
-						sessionName: ctx.sessionManager.getSessionName() ?? "",
+						fastMode: host.getFastMode?.(activeTuiContext ?? ctx),
+						hostTemplateValues: getEditorHostTemplateValues(activeTuiContext ?? ctx),
+						...getEditorContextMetadata(activeTuiContext ?? ctx),
+						cacheHitRate: state.usageTotals.latestCacheHitRate,
+						sessionName: (activeTuiContext ?? ctx).sessionManager.getSessionName() ?? "",
 						agentDurationMs: getAgentDurationMs(),
 						agentActive: agentRunActive,
-					}),
-					setMinimalistDecorationActive,
-				),
+						workingLineFrame,
+					};
+				},
+				(active) => {
+					if (isVisibleEditor(editor, generation)) setMinimalistDecorationActive(active, editor);
+				},
+				() => editorBorderCapabilityChanged(editor, generation),
+				() => editorMetadataDecorationChanged(editor, generation),
 			);
+			registerConstructedEditor(ctx, factory, generation, editor, tui);
+			return editor;
 		}) as ZentuiEditorFactory;
 		factory[ZENTUI_EDITOR_FACTORY] = true;
 		factory[ZENTUI_EDITOR_OWNER] = editorOwnerToken;
@@ -826,9 +1195,10 @@ export default function (pi: ExtensionAPI) {
 		const baseFactory =
 			currentZentuiBaseFactory ??
 			(currentFactory && !isZentuiEditorFactory(currentFactory) ? currentFactory : undefined);
-		const nextFactory = baseFactory
-			? makeWrappedEditorFactory(ctx, baseFactory)
-			: makeEditorFactory(ctx);
+		const nextFactory =
+			baseFactory && host.wrapEditor !== false
+				? makeWrappedEditorFactory(ctx, baseFactory)
+				: makeEditorFactory(ctx, baseFactory);
 		const replacement = replaceEditor(ctx, nextFactory);
 		if (!replacement.ok) return replacement;
 
@@ -895,6 +1265,9 @@ export default function (pi: ExtensionAPI) {
 		requestFooterRender = undefined;
 		getActiveExtensionStatuses = () => new Map();
 		stopSessionTimer();
+		customVariables.reconcile();
+		codexQuota.reconcile();
+		reconcileLiveMetadata();
 		if (sessionLifecycle.isCurrent()) reconcileProjectRefresh(ctx, true);
 	};
 
@@ -937,6 +1310,7 @@ export default function (pi: ExtensionAPI) {
 	const installStatusLine = (ctx: ExtensionContext) => {
 		if (installedFooterKind === "starship" && ownsStatusLine(ctx)) return;
 		const token = Symbol("zentui-starship-footer");
+		const generation = sessionLifecycle.currentGeneration();
 		const previous = snapshotFooterBookkeeping(ctx);
 		try {
 			installFooter(ctx, state, getCurrentConfig, {
@@ -944,11 +1318,22 @@ export default function (pi: ExtensionAPI) {
 					requestFooterRender = fn;
 				},
 				scheduleProjectRefresh,
+				onProjectChanged: () => {
+					if (sessionLifecycle.isCurrent(generation) && ownsStatusLine(ctx))
+						liveMetadata.invalidateProject();
+				},
 				setExtensionStatusesGetter(fn) {
 					getActiveExtensionStatuses = fn ?? (() => new Map());
 				},
+				getThinkingLevel,
+				beforeRender: host.liveModel ? () => syncModelState(state, ctx.model) : undefined,
+				getFastMode: () => host.getFastMode?.(ctx),
+				getHostTemplateValues: (names) =>
+					liveMetadata.read(names, host.getHostTemplateValues?.(ctx, names)),
 				getLiveContext: () => liveContext.get(),
-				getRepositoryRoot: (cwd) => repositoryRoots.rootForCwd(cwd),
+				getCodexQuota: () => codexQuota.get(),
+				getCustomVariables: () => customVariables.snapshot(),
+				getRepositoryRoot: (cwd) => repositoryRoots.cachedRootForCwd(cwd),
 				onDispose: () => clearFooterOwnership(ctx, token),
 			});
 			installedFooterKind = "starship";
@@ -966,12 +1351,18 @@ export default function (pi: ExtensionAPI) {
 		const token = Symbol("zentui-hidden-footer");
 		const previous = snapshotFooterBookkeeping(ctx);
 		try {
-			installHiddenFooter(ctx, () => clearFooterOwnership(ctx, token));
+			installHiddenFooter(ctx, () => currentConfig.components.extensionStatuses, {
+				setRequestRender: (fn) => {
+					requestFooterRender = fn;
+				},
+				setExtensionStatusesGetter: (fn) => {
+					getActiveExtensionStatuses = fn ?? (() => new Map());
+				},
+				onDispose: () => clearFooterOwnership(ctx, token),
+			});
 			installedFooterKind = "hidden";
 			installedFooterToken = token;
 			setStatusLineOwnership(ctx, token);
-			requestFooterRender = undefined;
-			getActiveExtensionStatuses = () => new Map();
 			stopSessionTimer();
 		} catch {
 			resetFailedFooterInstallation(ctx, token, previous);
@@ -1006,6 +1397,7 @@ export default function (pi: ExtensionAPI) {
 				uninstallStatusLine(ctx);
 				break;
 		}
+		syncFooterTelemetry(ctx);
 	};
 
 	const reconcileEditor = (
@@ -1038,6 +1430,10 @@ export default function (pi: ExtensionAPI) {
 				ok: false,
 				reason: "the editor could not be reconciled safely; reload Pi to apply this change",
 			};
+		} finally {
+			if (workingLineSessionReady) {
+				if (!host.skinOnly) workingLine.reconcile(ctx);
+			}
 		}
 	};
 
@@ -1060,6 +1456,7 @@ export default function (pi: ExtensionAPI) {
 		reconcileProjectRefresh(ctx);
 		reconcileSessionTimer();
 		reconcileAgentTimer();
+		syncFooterUsage(ctx);
 		return result;
 	};
 
@@ -1080,10 +1477,12 @@ export default function (pi: ExtensionAPI) {
 		} catch {
 			// Startup alone may supersede a stale registration from an earlier reload.
 		}
-		try {
-			removeSelectorBorderStyle();
-		} catch {
-			// Startup alone may supersede a stale registration from an earlier reload.
+		if (!host.skinOnly) {
+			try {
+				removeSelectorBorderStyle();
+			} catch {
+				// Startup alone may supersede a stale registration from an earlier reload.
+			}
 		}
 		uninstallStatusLine(ctx);
 		if (effectiveEditorEnabled()) clearEditorOwnership();
@@ -1106,6 +1505,9 @@ export default function (pi: ExtensionAPI) {
 			if (!observed.known) return;
 			if (observed.factory === installedEditorFactory) {
 				reconcileProjectRefresh(ctx);
+				const previousTotals = state.usageTotals;
+				syncFooterUsage(ctx);
+				if (state.usageTotals !== previousTotals) refresh();
 				return;
 			}
 			if (!observed.factory || !isOwnedEditorFactory(observed.factory)) {
@@ -1116,6 +1518,7 @@ export default function (pi: ExtensionAPI) {
 			}
 			trackZentuiEditorFactory(observed.factory);
 			reconcileProjectRefresh(ctx);
+			syncFooterUsage(ctx);
 			refresh();
 		});
 	};
@@ -1123,6 +1526,11 @@ export default function (pi: ExtensionAPI) {
 	const cleanupUi = (ctx?: ExtensionContext) => {
 		if (!ctx || !sessionLifecycle.isCurrent()) return;
 		sessionLifecycle.shutdown();
+		activeEditor = undefined;
+		minimalistDecorationEditor = undefined;
+		layeredEditor.detach();
+		extensionStatuses.dispose();
+		codexQuota.stop();
 		stopSessionTimer();
 		resetAgentTimer();
 		stopProjectRefresh();
@@ -1154,9 +1562,6 @@ export default function (pi: ExtensionAPI) {
 			}
 		}
 		if (!retainedEditorOwnership) clearEditorOwnership();
-		accentRailLayoutPatchInstallSerial += 1;
-		cleanupAccentRailLayoutPatch();
-		cleanupAccentRailLayoutPatch = () => {};
 		uninstallUserMessages();
 		uninstallSelectorBorders();
 		installedFooterKind = undefined;
@@ -1176,80 +1581,115 @@ export default function (pi: ExtensionAPI) {
 	};
 
 	pi.on("session_start", async (_event, ctx) => {
+		unsubscribeHostProjectChanges();
+		liveMetadata.dispose();
+		liveMetadata = createLiveMetadata();
+		codexQuota.stop();
+		usageTotals.invalidate();
+		footerTelemetry.reset();
+		customVariableSessionReady = false;
+		customVariables.clear();
 		const lifecycleGeneration = sessionLifecycle.start();
+		unsubscribeHostProjectChanges = isTuiContext(ctx)
+			? (host.subscribeProjectChanges?.(() => {
+					if (sessionLifecycle.isCurrent(lifecycleGeneration)) liveMetadata.invalidateProject();
+				}) ?? (() => {}))
+			: () => {};
+		activeEditor = undefined;
+		minimalistDecorationEditor = undefined;
 		// A new generation must not expose or route extension segments through the previous
-		// session while asynchronous TUI startup is still pending.
+		// session while TUI startup is in progress.
 		workingLineSessionReady = false;
-		workingLineExtensions.invalidate();
-		if (activeTuiContext) workingLine.dispose(activeTuiContext);
-		else workingLine.invalidateExtensionSegments();
+		if (!host.skinOnly) workingLineExtensions.invalidate();
+		if (activeTuiContext) {
+			if (!host.skinOnly) workingLine.dispose(activeTuiContext);
+		} else {
+			if (!host.skinOnly) workingLine.invalidateExtensionSegments();
+		}
 		// Reload synchronously so private ownership uses this session's disk snapshot before
 		// any await or transcript restoration.
-		currentConfig = loadConfig();
-		thinkingExperimental.startSession(ctx);
-		const layoutInstallSerial = ++accentRailLayoutPatchInstallSerial;
-		cleanupAccentRailLayoutPatch();
-		cleanupAccentRailLayoutPatch = () => {};
-		if (isTuiContext(ctx)) {
-			const layoutPatchRetention = await retainAccentRailLayoutPatchInstallation(
-				() => installHostAccentRailLayoutPatch(editorOwnerToken),
-				() =>
-					sessionLifecycle.isCurrent(lifecycleGeneration) &&
-					layoutInstallSerial === accentRailLayoutPatchInstallSerial,
-				(layoutPatch) => {
-					cleanupAccentRailLayoutPatch = layoutPatch.cleanup;
-					recordAccentRailLayoutPatchDiagnostic(layoutPatch.diagnostic, layoutPatch.version);
-				},
-			);
-			if (layoutPatchRetention === "stale") return;
-			if (layoutPatchRetention === "failed") {
-				recordAccentRailLayoutPatchDiagnostic("host-module-unavailable");
-			}
-		}
+		currentConfig = scopeConfig(loadConfig());
+		extensionStatuses.dispose();
+		if (!host.skinOnly && isTuiContext(ctx)) extensionStatuses.install(ctx.ui);
+		if (!host.skinOnly) thinkingExperimental.startSession(ctx);
 		if (!sessionLifecycle.isCurrent(lifecycleGeneration)) return;
 		liveContext.clear();
 		interactionMetrics.shutdown();
-		workingLineExtensions.invalidate();
+		summaryRate.reset();
+		if (!host.skinOnly) workingLineExtensions.invalidate();
 		state.sessionStartEpoch = Date.now();
-		invalidateUsageTotalsCache();
 		resetAgentTimer();
 		lastProjectCwd = undefined;
 		minimalistProjectRoot = undefined;
 		repositoryRoots.reset();
 		installUi(ctx);
-		workingLine.startSession(ctx);
-		workingLineSessionReady = true;
+		customVariableSessionReady = isTuiContext(ctx);
+		if (!host.skinOnly) workingLine.startSession(ctx);
+		workingLineSessionReady = !host.skinOnly;
+		reconcileLiveMetadata();
 		scheduleEditorReconciliation(ctx);
 	});
 
 	registerZentuiSettingsCommand(pi, {
 		sessionLifecycle,
+		skinOnly: host.skinOnly,
 		getConfig: getCurrentConfig,
 		applyPreset(id, ctx, options) {
 			const preset = getComponentPreset(id);
 			if (!preset) throw new Error(`Unknown Zentui preset: ${id}`);
 			const previousFooterStyle = effectiveFooterStyle();
-			currentConfig = saveComponentPreset(preset);
+			currentConfig = scopeConfig(saveComponentPreset(preset));
 			if (!isTuiContext(ctx)) return { applied: true };
 			activeTheme = ctx.ui.theme;
 			const result = options?.deferEditor ? undefined : reconcileEditor(ctx);
 			if (currentConfig.components.editor.style !== "minimalist") {
 				setMinimalistDecorationActive(false);
 			}
+			if (!host.skinOnly) workingLine.reconcile(ctx);
 			reconcileUserMessages();
 			reconcileFooter(ctx);
 			reconcileProjectRefresh(ctx, effectiveFooterStyle() !== previousFooterStyle);
 			reconcileSessionTimer();
 			reconcileAgentTimer();
+			syncFooterUsage(ctx);
 			refresh();
 			return {
 				applied: !result || result.ok,
 				reason: result && !result.ok ? result.reason : undefined,
 			};
 		},
+		migrateSelections(ctx) {
+			currentConfig = scopeConfig(migrateComponentSelections());
+			if (!isTuiContext(ctx)) return;
+			activeTheme = ctx.ui.theme;
+			reconcileEditor(ctx);
+			reconcileUserMessages();
+			reconcileSelectorBorders();
+			reconcileFooter(ctx);
+			if (!host.skinOnly) workingLine.reconcile(ctx);
+			if (!host.skinOnly) thinkingExperimental.reconcile();
+			syncFooterState(ctx);
+			reconcileProjectRefresh(ctx);
+			reconcileSessionTimer();
+			reconcileAgentTimer();
+			refresh();
+		},
+		getCustomVariables: () => customVariables.snapshot(),
+		setCustomValueColor(owner, key, value) {
+			currentConfig = scopeConfig(saveCustomValueColor(owner, key, value));
+			refresh();
+		},
+		setComponentColor(owner, key, value, ctx) {
+			currentConfig = scopeConfig(saveComponentColor(owner, key, value));
+			if (owner === "workingLine") {
+				if (!host.skinOnly) workingLine.reconcile(ctx);
+			}
+			refresh();
+		},
 		reconcilePresetEditor(ctx) {
 			if (!isTuiContext(ctx) || !sessionLifecycle.isCurrent()) return { applied: true };
 			const result = reconcileEditor(ctx);
+			syncFooterUsage(ctx);
 			reconcileProjectRefresh(ctx);
 			reconcileAgentTimer();
 			refresh();
@@ -1259,7 +1699,7 @@ export default function (pi: ExtensionAPI) {
 			};
 		},
 		setEditorComponent(patch: Partial<EditorComponentConfig>, ctx: ExtensionContext, options) {
-			currentConfig = saveEditorComponentPatch(patch);
+			currentConfig = scopeConfig(saveEditorComponentPatch(patch));
 			let result: EditorChangeResult | undefined;
 			if (patch.enabled !== undefined && isTuiContext(ctx) && !options?.deferEditor) {
 				result = reconcileEditor(ctx);
@@ -1267,6 +1707,8 @@ export default function (pi: ExtensionAPI) {
 			if (patch.style !== undefined && patch.style !== "minimalist") {
 				setMinimalistDecorationActive(false);
 			}
+			if (!host.skinOnly) workingLine.reconcile(ctx);
+			syncFooterUsage(ctx);
 			if (patch.modelLabel !== undefined) syncFooterState(ctx);
 			reconcileProjectRefresh(ctx);
 			reconcileAgentTimer();
@@ -1276,29 +1718,38 @@ export default function (pi: ExtensionAPI) {
 				reason: result && !result.ok ? result.reason : undefined,
 			};
 		},
-		setPolished(patch: Partial<PolishedEditorStyleConfig>, _ctx: ExtensionContext) {
-			currentConfig = savePolishedEditorStylePatch(patch);
+		setPolished(patch: Partial<PolishedEditorStyleConfig>, ctx: ExtensionContext) {
+			currentConfig = scopeConfig(savePolishedEditorStylePatch(patch));
+			syncFooterUsage(ctx);
 			refresh();
 		},
 		setPolishedCopyFriendly(
 			patch: Partial<PolishedCopyFriendlyEditorStyleConfig>,
-			_ctx: ExtensionContext,
+			ctx: ExtensionContext,
 		) {
-			currentConfig = savePolishedCopyFriendlyEditorStylePatch(patch);
+			currentConfig = scopeConfig(savePolishedCopyFriendlyEditorStylePatch(patch));
+			syncFooterUsage(ctx);
 			refresh();
 		},
 		setAccentRail(patch: Partial<AccentRailEditorStyleConfig>, _ctx: ExtensionContext) {
-			currentConfig = saveAccentRailEditorStylePatch(patch);
+			currentConfig = scopeConfig(saveAccentRailEditorStylePatch(patch));
 			refresh();
 		},
-		setMinimalist(patch: Partial<MinimalistConfig>, ctx: ExtensionContext) {
-			currentConfig = saveMinimalistEditorStylePatch(patch);
+		setMinimalist(patch: MinimalistEditorStylePatch, ctx: ExtensionContext) {
+			currentConfig = scopeConfig(saveMinimalistEditorStylePatch(patch));
+			customVariables.reconcile();
+			syncFooterUsage(ctx);
 			reconcileAgentTimer();
-			reconcileProjectRefresh(ctx, patch.pathDisplay !== undefined || patch.showGit !== undefined);
+			reconcileProjectRefresh(
+				ctx,
+				patch.formats !== undefined ||
+					patch.pathDisplay !== undefined ||
+					patch.showGit !== undefined,
+			);
 			refresh();
 		},
 		setUserMessagesComponent(patch: Partial<UserMessagesComponentConfig>, _ctx: ExtensionContext) {
-			currentConfig = saveUserMessagesComponentPatch(patch);
+			currentConfig = scopeConfig(saveUserMessagesComponentPatch(patch));
 			if (patch.enabled !== undefined || patch.style !== undefined) reconcileUserMessages();
 			refresh();
 		},
@@ -1307,30 +1758,36 @@ export default function (pi: ExtensionAPI) {
 			patch: Partial<ThinkingStepsComponentConfig>,
 			_ctx: ExtensionContext,
 		) {
-			currentConfig = saveThinkingStepsComponentPatch(patch);
+			currentConfig = scopeConfig(saveThinkingStepsComponentPatch(patch));
 			return thinkingExperimental.reconcile();
 		},
 		setWorkingLineComponent(patch: WorkingLineComponentPatch, ctx: ExtensionContext) {
-			currentConfig = saveWorkingLineComponentPatch(patch);
-			if (patch.enabled === false) workingLineExtensions.clear();
-			return workingLine.reconcile(ctx);
+			currentConfig = scopeConfig(saveWorkingLineComponentPatch(patch));
+			if (patch.enabled === false) {
+				if (!host.skinOnly) workingLineExtensions.clear();
+			}
+			summaryRate.reconcile(summaryEnabled());
+			const result = workingLine.reconcile(ctx);
+			reconcileLiveMetadata();
+			return result;
 		},
 		setSelectorBordersComponent(
 			patch: Partial<SelectorBordersComponentConfig>,
 			_ctx: ExtensionContext,
 		) {
-			currentConfig = saveSelectorBordersComponentPatch(patch);
+			currentConfig = scopeConfig(saveSelectorBordersComponentPatch(patch));
 			if (patch.enabled !== undefined || patch.style !== undefined) reconcileSelectorBorders();
 			refresh();
 		},
 		setFooterComponent(patch: Partial<FooterComponentConfig>, ctx: ExtensionContext) {
 			const previousStyle = effectiveFooterStyle();
-			currentConfig = saveFooterComponentPatch(patch);
+			currentConfig = scopeConfig(saveFooterComponentPatch(patch));
 			const styleChanged = effectiveFooterStyle() !== previousStyle;
 			if (patch.style !== undefined) reconcileFooter(ctx);
 			if (patch.modelLabel !== undefined) syncFooterState(ctx);
 			reconcileProjectRefresh(ctx, styleChanged);
 			reconcileSessionTimer();
+			syncFooterUsage(ctx);
 			refresh();
 		},
 		setFooterSegments(patch: Partial<FooterSegmentsConfig>, ctx: ExtensionContext) {
@@ -1355,42 +1812,60 @@ export default function (pi: ExtensionAPI) {
 			);
 		},
 		setIconMode(mode: IconMode) {
-			currentConfig = saveIconsModePatch(mode);
+			currentConfig = scopeConfig(saveIconsModePatch(mode));
 		},
 		setContextStyle(style: ContextStyle) {
-			currentConfig = saveStarshipFooterStylePatch({ contextStyle: style });
+			currentConfig = scopeConfig(saveStarshipFooterStylePatch({ contextStyle: style }));
 		},
 		setSeparator(separator: SeparatorStyle) {
-			currentConfig = saveStarshipFooterStylePatch({ separator });
+			currentConfig = scopeConfig(saveStarshipFooterStylePatch({ separator }));
 		},
 		setPathDisplay(patch: Partial<PathDisplayConfig>) {
-			currentConfig = saveStarshipFooterStylePatch({ pathDisplay: patch as PathDisplayConfig });
+			currentConfig = scopeConfig(
+				saveStarshipFooterStylePatch({ pathDisplay: patch as PathDisplayConfig }),
+			);
+			if (activeTuiContext) reconcileProjectRefresh(activeTuiContext, true);
 		},
 		setGitBranch(patch: Partial<GitBranchConfig>) {
-			currentConfig = saveStarshipFooterStylePatch({ gitBranch: patch as GitBranchConfig });
+			currentConfig = scopeConfig(
+				saveStarshipFooterStylePatch({ gitBranch: patch as GitBranchConfig }),
+			);
 		},
 		setGitCommit(
 			patch: Partial<Pick<GitCommitConfig, "onlyDetached" | "showTag">>,
 			ctx: ExtensionContext,
 		) {
-			currentConfig = saveStarshipFooterStylePatch({ gitCommit: patch as GitCommitConfig });
+			currentConfig = scopeConfig(
+				saveStarshipFooterStylePatch({ gitCommit: patch as GitCommitConfig }),
+			);
 			if (patch.showTag !== undefined) reconcileProjectRefresh(ctx, true);
 		},
 		setGitMetrics(patch: Partial<GitMetricsConfig>, ctx: ExtensionContext) {
-			currentConfig = saveStarshipFooterStylePatch({ gitMetrics: patch as GitMetricsConfig });
+			currentConfig = scopeConfig(
+				saveStarshipFooterStylePatch({ gitMetrics: patch as GitMetricsConfig }),
+			);
 			if (patch.ignoreSubmodules !== undefined) reconcileProjectRefresh(ctx, true);
 		},
 		getActiveExtensionStatuses() {
-			return getActiveExtensionStatuses();
+			return new Map([...getActiveExtensionStatuses(), ...extensionStatuses.snapshot()]);
+		},
+		setExtensionStatusDefaultChoice(placement: ExtensionStatusPlacement) {
+			currentConfig = scopeConfig(
+				saveExtensionStatusDefaultChoice(placement, currentConfig.components.footer.style),
+			);
+			extensionStatuses.reconcile();
 		},
-		setExtensionStatusDefaultPlacement(placement: ExtensionStatusPlacement) {
-			currentConfig = saveExtensionStatusDefaultPlacement(placement);
+		setExtensionStatusChoice(key: string, choice: ExtensionStatusChoice) {
+			currentConfig = scopeConfig(
+				saveExtensionStatusChoice(key, choice, currentConfig.components.footer.style),
+			);
+			extensionStatuses.reconcile();
 		},
-		setExtensionStatusPlacement(key: string, placement: ExtensionStatusPlacement) {
-			currentConfig = saveExtensionStatusPlacement(key, placement);
+		setHiddenExtensionStatusColorMode(key, colorMode) {
+			currentConfig = scopeConfig(saveHiddenExtensionStatusColorMode(key, colorMode));
 		},
 		setExtensionStatusColorMode(key: string, colorMode: ExtensionStatusColorMode) {
-			currentConfig = saveExtensionStatusColorMode(key, colorMode);
+			currentConfig = scopeConfig(saveExtensionStatusColorMode(key, colorMode));
 		},
 		requestRender() {
 			refresh();
@@ -1398,66 +1873,95 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	pi.on("session_shutdown", async (_event, ctx) => {
+		unsubscribeHostProjectChanges();
+		liveMetadata.dispose();
+		customVariableSessionReady = false;
+		customVariables.clear();
+		usageTotals.invalidate();
+		footerTelemetry.reset();
 		workingLineSessionReady = false;
-		thinkingExperimental.shutdown();
+		if (!host.skinOnly) thinkingExperimental.shutdown();
 		liveContext.clear();
 		interactionMetrics.shutdown();
-		workingLine.dispose(ctx);
-		workingLineExtensions.invalidate();
+		summaryRate.reset();
+		if (!host.skinOnly) workingLine.dispose(ctx);
+		if (!host.skinOnly) workingLineExtensions.invalidate();
 		cleanupUi(ctx);
 	});
 
 	const syncInteractiveAndProjectStateWithUsage = (_event: unknown, ctx: ExtensionContext) => {
-		invalidateUsageTotalsCache();
+		usageTotals.invalidate();
 		refreshInteractiveState(ctx, true);
 	};
 
-	pi.on("message_start", (event) => thinkingExperimental.beginMessage(event));
+	if (!host.skinOnly) pi.on("message_start", (event) => thinkingExperimental.beginMessage(event));
 
 	pi.on("agent_start", (event, ctx) => {
 		liveContext.clear();
 		const { interactionStarted } = interactionMetrics.agentStart();
+		liveMetadata.startAgent(interactionStarted);
+		summaryRate.agentStart(interactionStarted, summaryEnabled());
 		startAgentTurn(interactionStarted);
-		workingLine.startAgent(ctx);
+		if (!host.skinOnly) workingLine.startAgent(ctx);
 		syncInteractiveState(event, ctx);
 	});
 	pi.on("turn_start", (_event, ctx) => {
+		liveMetadata.startResponse();
 		interactionMetrics.turnStart();
-		workingLine.startTurn(ctx);
+		summaryRate.turnStart();
+		if (!host.skinOnly) workingLine.startTurn(ctx);
 	});
 	pi.on("agent_end", (event, ctx) => {
-		thinkingExperimental.endAgent();
+		suspendTokenRate();
+		if (!host.skinOnly) thinkingExperimental.endAgent();
 		liveContext.clear();
 		const displayTokens = interactionMetrics.currentDisplayTokens();
 		interactionMetrics.agentEnd();
+		summaryRate.agentEnd();
 		pauseAgentRun();
-		workingLine.finishAgent(ctx);
-		workingLine.updateMetrics(displayTokens, interactionMetrics.currentThought(), ctx);
+		if (host.skinOnly) {
+			const settled = interactionMetrics.settle(ctx.isIdle());
+			if (settled) settleAgentTurn(settled.nextStartedAt);
+		}
+		if (!host.skinOnly) workingLine.finishAgent(ctx);
+		if (!host.skinOnly)
+			workingLine.flushMetrics(displayTokens, interactionMetrics.currentThought(), ctx);
 		// Reconcile once more after Pi has persisted the assistant message.
 		syncInteractiveAndProjectStateWithUsage(event, ctx);
 	});
 	pi.on("model_select", (event, ctx) => {
+		clearTokenRate();
 		liveContext.clear();
 		syncInteractiveState(event, ctx);
 	});
 	pi.on("thinking_level_select", syncInteractiveState);
 	pi.on("session_info_changed", syncInteractiveState);
 	pi.on("message_update", (event, ctx) => {
-		thinkingExperimental.updateMessage(event);
+		if (!host.skinOnly) thinkingExperimental.updateMessage(event);
 		liveContext.update(event.message);
+		summaryRate.observeTime();
+		if (!host.skinOnly)
+			liveMetadata.updateResponse(
+				event.message,
+				"assistantMessageEvent" in event ? event.assistantMessageEvent : undefined,
+			);
 		const metrics = interactionMetrics.messageUpdate(
 			event.message,
 			"assistantMessageEvent" in event ? event.assistantMessageEvent : undefined,
 		);
 		if (metrics.usageChanged || metrics.thoughtChanged) {
-			workingLine.updateMetrics(metrics.displayTokens, interactionMetrics.currentThought(), ctx);
+			if (!host.skinOnly)
+				workingLine.updateMetrics(metrics.displayTokens, interactionMetrics.currentThought(), ctx);
 		}
 	});
 	pi.on("message_end", (event, ctx) => {
-		thinkingExperimental.endMessage(event);
+		if (!host.skinOnly) thinkingExperimental.endMessage(event);
 		const result = interactionMetrics.messageEnd(event.message);
+		summaryRate.messageEnd(event.message, result);
+		if (!host.skinOnly) liveMetadata.endResponse(event.message, result);
 		if (result.status === "accepted") {
-			workingLine.updateMetrics(result.displayTokens, interactionMetrics.currentThought(), ctx);
+			if (!host.skinOnly)
+				workingLine.flushMetrics(result.displayTokens, interactionMetrics.currentThought(), ctx);
 		}
 		// Pi notifies extensions before persisting a successful message, so retain its live
 		// context until agent_end; accepted failed messages clear immediately instead of showing
@@ -1471,48 +1975,64 @@ export default function (pi: ExtensionAPI) {
 		}
 		syncInteractiveAndProjectStateWithUsage(event, ctx);
 	});
-	pi.on("agent_settled", (_event, ctx) => {
-		const settled = interactionMetrics.settle(ctx.isIdle());
-		if (!settled) return;
-		settleAgentTurn(settled.nextStartedAt);
-		workingLine.settle(settled.nextTokens, settled.nextThought, ctx);
-		const config = currentConfig.components.workingLine;
-		if (config.enabled && config.turnSummary) {
-			try {
-				pi.appendEntry(TURN_SUMMARY_ENTRY_TYPE, {
-					version: 3,
-					...settled.summary,
-					stylePrefix: snapshotWorkingLineHighStyle(ctx.ui.theme, config, currentConfig.colors),
-				});
-			} catch {
-				// A transcript persistence failure must not break settlement cleanup.
+	if (!host.skinOnly)
+		pi.on("agent_settled", (_event, ctx) => {
+			// Includes usage persisted by later agent_end handlers and pre-settlement drafts.
+			usageTotals.invalidate();
+			refreshInteractiveState(ctx);
+			const settled = interactionMetrics.settle(ctx.isIdle());
+			if (!settled) return;
+			const averageTokenRate = summaryRate.settle(settled.nextStartedAt === undefined);
+			if (settled.nextStartedAt !== undefined) liveMetadata.partitionRates();
+			settleAgentTurn(settled.nextStartedAt);
+			if (!host.skinOnly) workingLine.settle(settled.nextTokens, settled.nextThought, ctx);
+			const config = currentConfig.components.workingLine;
+			if (config.enabled && config.turnSummary) {
+				try {
+					const summary = createTurnSummaryData(
+						settled.summary,
+						averageTokenRate,
+						ctx.ui.theme,
+						config,
+						currentConfig.colors,
+					);
+					pi.appendEntry(TURN_SUMMARY_ENTRY_TYPE, summary);
+				} catch {
+					// A transcript persistence failure must not break settlement cleanup.
+				}
 			}
-		}
-		// Gateway cost reconciliation lands a few seconds after settle; refresh
-		// once late so the cost label picks up authoritative totals when they
-		// arrive. Best-effort: harmless in non-TUI contexts.
-		sessionLifecycle.defer(
-			() => {
-				invalidateUsageTotalsCache();
+			// Gateway cost reconciliation lands a few seconds after settle; refresh
+			// once late so the cost label picks up authoritative totals when they
+			// arrive. Best-effort: harmless in non-TUI contexts.
+			sessionLifecycle.defer(() => {
+				usageTotals.invalidate();
 				refreshInteractiveState(ctx);
-			},
-			12_000,
-		);
-	});
+			}, 12_000);
+		});
 	pi.on("tool_execution_start", (event, ctx) => {
+		suspendTokenRate();
 		liveContext.clear();
-		workingLine.startTool(event.toolCallId, event.toolName, ctx);
+		if (!host.skinOnly) workingLine.startTool(event.toolCallId, event.toolName, ctx);
 		syncInteractiveState(event, ctx);
 	});
 	pi.on("tool_execution_end", (event, ctx) => {
-		workingLine.finishTool(event.toolCallId, ctx);
+		liveMetadata.invalidateProject();
+		if (!host.skinOnly) workingLine.finishTool(event.toolCallId, ctx);
 		syncInteractiveAndProjectState(event, ctx);
 	});
+	// Hook presence changes OMP maintenance/transition behavior, even for no-op handlers.
+	if (!host.skinOnly) {
+		pi.on("session_before_compact", clearTokenRate);
+		pi.on("session_before_switch", clearTokenRate);
+	}
 	pi.on("session_compact", (event, ctx) => {
+		clearTokenRate();
 		liveContext.clear();
 		syncInteractiveAndProjectStateWithUsage(event, ctx);
 	});
 	pi.on("session_tree", (event, ctx) => {
+		liveMetadata.resetRate();
+		liveMetadata.invalidateProject();
 		liveContext.clear();
 		syncInteractiveAndProjectStateWithUsage(event, ctx);
 	});