@oh-my-pi/pi-tui 18.4.0 → 18.4.2

package/src/status-line/metrics.ts

@@ -7,7 +7,6 @@ export interface BillingSummaryOptions {
 	readonly usingSubscription: boolean;
 	readonly premiumRequests: number;
 	readonly fractionDigits: number;
-	readonly startupPlaceholder?: boolean;
 	readonly pricingPeriod?: "peak" | "off-peak";
 	readonly advisor?: {
 		readonly cost: number;
@@ -30,24 +29,13 @@ function formatSpend(amount: number, usingSubscription: boolean, fractionDigits:
 	return `S${formatted}`;
 }
 
-function formatSpendPlaceholder(usingSubscription: boolean, uiTheme: Theme): string {
-	if (!usingSubscription) return "$…";
-	if (uiTheme.getSymbolPreset() === "nerd" && uiTheme.icon.subscription) {
-		return `${uiTheme.icon.subscription} …`;
-	}
-	return "S…";
-}
-
 function formatAdvisorSpend(
 	amount: number,
 	usingSubscription: boolean,
 	fractionDigits: number,
-	placeholder: boolean,
 	uiTheme: Theme,
 ): string {
-	const spend = placeholder
-		? formatSpendPlaceholder(usingSubscription, uiTheme)
-		: formatSpend(amount, usingSubscription, fractionDigits, uiTheme);
+	const spend = formatSpend(amount, usingSubscription, fractionDigits, uiTheme);
 	const icon = uiTheme.icon.advisor;
 	return icon && icon !== "(adv)" ? `${icon} ${spend}` : `${spend} (adv)`;
 }
@@ -63,21 +51,16 @@ export function formatBillingSummary(options: BillingSummaryOptions, uiTheme: Th
 		return undefined;
 	}
 
-	const placeholder = options.startupPlaceholder === true;
 	const parts: string[] = [];
 	if (options.cost || options.pricingPeriod) {
-		parts.push(
-			placeholder
-				? formatSpendPlaceholder(options.usingSubscription, uiTheme)
-				: formatSpend(options.cost, options.usingSubscription, options.fractionDigits, uiTheme),
-		);
+		parts.push(formatSpend(options.cost, options.usingSubscription, options.fractionDigits, uiTheme));
 	} else if (options.usingSubscription) {
 		parts.push(
 			uiTheme.getSymbolPreset() === "nerd" && uiTheme.icon.subscription ? uiTheme.icon.subscription : "(sub)",
 		);
 	}
 	if (options.pricingPeriod) parts.push(options.pricingPeriod === "peak" ? "↑" : "↓");
-	if (premiumRequests) parts.push(`★ ${placeholder ? "…" : formatNumber(premiumRequests)}`);
+	if (premiumRequests) parts.push(`★ ${formatNumber(premiumRequests)}`);
 	if (advisorCost && options.advisor) {
 		const prefix = parts.length > 0 ? "+ " : "";
 		parts.push(
@@ -85,7 +68,6 @@ export function formatBillingSummary(options: BillingSummaryOptions, uiTheme: Th
 				advisorCost,
 				options.advisor.usingSubscription,
 				options.fractionDigits,
-				placeholder,
 				uiTheme,
 			)}`,
 		);

package/src/status-line/segments.ts

@@ -9,7 +9,6 @@ import {
 	getProjectDir,
 	normalizePathForComparison,
 	relativePathWithinNormalizedRoot,
-	relativePathWithinRoot,
 } from "@oh-my-pi/pi-utils";
 import { type SymbolKey, type Theme, type ThemeColor, theme } from "../theme";
 import { shortenPath, TRUNCATE_LENGTHS, truncateToWidth } from "../render/render-utils";
@@ -28,15 +27,10 @@ export type { SegmentContext } from "./types";
 // Helpers
 // ═══════════════════════════════════════════════════════════════════════════
 
-const STARTUP_PLACEHOLDER = "…";
-
 function withIcon(icon: string, text: string): string {
 	return icon ? `${icon} ${text}` : text;
 }
 
-function statusValue(ctx: SegmentContext, value: string): string {
-	return ctx.startupPlaceholder ? STARTUP_PLACEHOLDER : value;
-}
 /**
  * Hash-derived accent ANSI for the session title (or preview stand-in title).
  * Undefined when `statusLine.sessionAccent` is off or the session is unnamed,
@@ -75,14 +69,6 @@ function leadingGlyph(display: string): string {
 	return space === -1 ? display : display.slice(0, space);
 }
 
-function stripDisplayRoot(pwd: string): string {
-	for (const root of [path.join(os.homedir(), "Projects"), "/work"]) {
-		const relative = relativePathWithinRoot(root, pwd);
-		if (relative) return relative;
-	}
-	return pwd;
-}
-
 /**
  * Single-field usage counter (`token_in`, `token_out`, `cache_read`,
  * `cache_write`). Hidden on zero, startup-placeholder aware, icon omitted when
@@ -101,7 +87,7 @@ function singleStatSegment(
 			if (!value) return { content: "", visible: false };
 			const content = formatMetric({
 				leading: theme.icon[iconKey] || undefined,
-				value: statusValue(ctx, formatNumber(value)),
+				value: formatNumber(value),
 			});
 			return { content: theme.fg(color, content ?? ""), visible: true };
 		},
@@ -126,28 +112,50 @@ const NORMALIZED_SCRATCH_ROOTS: readonly string[] = (() => {
 	return [...new Set(Array.from(roots, normalizePathForComparison))];
 })();
 
-interface ProjectDirClassification {
+interface ProjectDirDisplay {
+	projectDir: string;
+	homeDir: string;
+	displayRoots: readonly string[] | undefined;
 	scratch: boolean;
-	relative: string | null;
+	displayPath: string;
 }
 
-const PROJECT_DIR_CLASSIFICATIONS = new Map<string, ProjectDirClassification>();
+let projectDirDisplay: ProjectDirDisplay | undefined;
 
-function classifyProjectDir(projectDir: string): ProjectDirClassification {
-	const cached = PROJECT_DIR_CLASSIFICATIONS.get(projectDir);
-	if (cached) return cached;
+/**
+ * Retain only the active directory: switching cwd re-resolves its aliases,
+ * while repeated paints reuse both scratch classification and root stripping.
+ * Display roots remain normalized while the home directory is unchanged.
+ */
+function getProjectDirDisplay(projectDir: string): ProjectDirDisplay {
+	const cached = projectDirDisplay;
+	if (cached?.projectDir === projectDir) return cached;
 
+	const homeDir = os.homedir();
+	let displayRoots = cached?.homeDir === homeDir ? cached.displayRoots : undefined;
 	const normalizedProjectDir = normalizePathForComparison(projectDir);
-	let classification: ProjectDirClassification = { scratch: false, relative: null };
+	let scratch = false;
+	let displayPath = projectDir;
 	for (const normalizedRoot of NORMALIZED_SCRATCH_ROOTS) {
 		const relative = relativePathWithinNormalizedRoot(normalizedRoot, normalizedProjectDir);
 		if (relative !== null) {
-			classification = { scratch: true, relative: relative || null };
+			scratch = true;
+			displayPath = relative || projectDir;
 			break;
 		}
 	}
-	PROJECT_DIR_CLASSIFICATIONS.set(projectDir, classification);
-	return classification;
+	if (!scratch) {
+		displayRoots ??= [path.join(homeDir, "Projects"), "/work"].map(normalizePathForComparison);
+		for (const root of displayRoots) {
+			const relative = relativePathWithinNormalizedRoot(root, normalizedProjectDir);
+			if (relative) {
+				displayPath = relative;
+				break;
+			}
+		}
+	}
+	projectDirDisplay = { projectDir, homeDir, displayRoots, scratch, displayPath };
+	return projectDirDisplay;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -160,7 +168,7 @@ const piSegment: StatusLineSegment = {
 		if (ctx.focusedAgentId) {
 			const icon = theme.icon.ghost ? `${theme.icon.ghost} ` : "";
 			return {
-				content: theme.fg("warning", `${icon}${statusValue(ctx, ctx.focusedAgentId)}`),
+				content: theme.fg("warning", `${icon}${ctx.focusedAgentId}`),
 				visible: true,
 			};
 		}
@@ -173,7 +181,7 @@ const piSegment: StatusLineSegment = {
 		// trailing space here would double the gap at the first separator (#11103).
 		const content =
 			ctx.turnElapsedMs != null
-				? `${brandSpinnerFrame(ctx.now?.getTime())} ${statusValue(ctx, brandTimer(ctx.turnElapsedMs))}`
+				? `${brandSpinnerFrame(ctx.now?.getTime())} ${brandTimer(ctx.turnElapsedMs)}`
 				: theme.icon.omp
 					? theme.icon.omp
 					: "";
@@ -220,7 +228,6 @@ const modelSegment: StatusLineSegment = {
 		if (modelName.startsWith("Claude ")) {
 			modelName = modelName.slice(7);
 		}
-		modelName = statusValue(ctx, modelName);
 
 		// Resolve the current thinking-level display ("◉ xhigh", "⟳ auto", …)
 		// when the model supports thinking and the segment isn't hiding it.
@@ -242,10 +249,6 @@ const modelSegment: StatusLineSegment = {
 			}
 		}
 
-		if (ctx.startupPlaceholder && thinkingDisplay) {
-			thinkingDisplay = withIcon(leadingGlyph(thinkingDisplay), STARTUP_PLACEHOLDER);
-		}
-
 		// Compact mode swaps the model icon for the thinking-level glyph and drops
 		// the " · <level>" tail, keeping the level visible as a single icon.
 		const compact = ctx.compactThinkingLevel && thinkingDisplay !== "";
@@ -337,7 +340,7 @@ function renderGoalMode(ctx: SegmentContext, mode: { enabled: boolean; paused: b
 	const parts: string[] = [withIcon(icon, "Goal")];
 	const showBudget = ctx.goalStatusInFooter === true;
 	if (showBudget && goal) {
-		parts.push(statusValue(ctx, formatGoalBudget(goal.tokensUsed, goal.tokenBudget)));
+		parts.push(formatGoalBudget(goal.tokensUsed, goal.tokenBudget));
 	}
 	return {
 		content: color === "accent" ? accentFg(ctx, color, parts.join(" ")) : theme.fg(color, parts.join(" ")),
@@ -397,11 +400,13 @@ const modeSegment: StatusLineSegment = {
 		if (loop) {
 			const icon = loop.state === "paused" ? theme.icon.pause || theme.icon.loop : theme.icon.loop;
 			const color: ThemeColor = loop.state === "paused" ? "warning" : "customMessageLabel";
-			const parts = [withIcon(icon, `Loop ${statusValue(ctx, loop.state)}`)];
+			const stateLabel = loop.state === "waiting" ? "next prompt repeats" : loop.state;
+			const label = `Loop${loop.state === "waiting" ? ":" : ""} ${stateLabel}`;
+			const parts = [withIcon(icon, label)];
 			const limit = formatLoopLimit(loop.limit, ctx.now?.getTime());
-			if (limit) parts.push(statusValue(ctx, limit));
+			if (limit) parts.push(limit);
 			if (loop.condition) {
-				parts.push(statusValue(ctx, summarizeLoopCondition(loop.condition, TRUNCATE_LENGTHS.SHORT)));
+				parts.push(summarizeLoopCondition(loop.condition, TRUNCATE_LENGTHS.SHORT));
 			}
 			return { content: theme.fg(color, parts.join(" ")), visible: true };
 		}
@@ -423,24 +428,14 @@ const pathSegment: StatusLineSegment = {
 		if (stripPrefix && ctx.worktree) {
 			const { projectName, worktreeName } = ctx.worktree;
 			const label = ctx.git.branch === worktreeName ? projectName : `${projectName}/${worktreeName}`;
-			const text = ctx.startupPlaceholder
-				? STARTUP_PLACEHOLDER
-				: fileHyperlink(getProjectDir(), clampPathLength(label, opts.maxLength ?? 40));
+			const text = fileHyperlink(getProjectDir(), clampPathLength(label, opts.maxLength ?? 40));
 			const content = withIcon(theme.icon.worktree, text);
 			return { content: theme.fg("statusLinePath", content), visible: true };
 		}
 
 		const projectDir = ctx.activeRepo?.cwd ?? getProjectDir();
-		const { scratch, relative } = classifyProjectDir(projectDir);
-		let pwd = projectDir;
-
-		if (stripPrefix) {
-			if (scratch) {
-				if (relative) pwd = relative;
-			} else {
-				pwd = stripDisplayRoot(pwd);
-			}
-		}
+		const { scratch, displayPath } = getProjectDirDisplay(projectDir);
+		let pwd = stripPrefix ? displayPath : projectDir;
 		const repoSuffix = ctx.activeRepo ? ` ↳ ${ctx.activeRepo.relativeRepoRoot}` : "";
 		if (opts.abbreviate !== false) {
 			pwd = shortenPath(pwd);
@@ -450,7 +445,7 @@ const pathSegment: StatusLineSegment = {
 
 		const showScratchIcon = scratch && stripPrefix;
 		const icon = showScratchIcon ? theme.icon.scratchFolder : theme.icon.folder;
-		const text = ctx.startupPlaceholder ? STARTUP_PLACEHOLDER : `${fileHyperlink(projectDir, pwd)}${repoSuffix}`;
+		const text = `${fileHyperlink(projectDir, pwd)}${repoSuffix}`;
 		const content = withIcon(icon, text);
 		return { content: theme.fg("statusLinePath", content), visible: true };
 	},
@@ -469,20 +464,20 @@ const gitSegment: StatusLineSegment = {
 		const showBranch = opts.showBranch !== false;
 		let content = "";
 		if (showBranch && branch) {
-			content = withIcon(theme.icon.branch, statusValue(ctx, branch));
+			content = withIcon(theme.icon.branch, branch);
 		}
 
 		// Add status indicators
 		if (gitStatus) {
 			const indicators: string[] = [];
 			if (opts.showUnstaged !== false && gitStatus.unstaged > 0) {
-				indicators.push(theme.fg("statusLineDirty", `*${statusValue(ctx, `${gitStatus.unstaged}`)}`));
+				indicators.push(theme.fg("statusLineDirty", `*${gitStatus.unstaged}`));
 			}
 			if (opts.showStaged !== false && gitStatus.staged > 0) {
-				indicators.push(theme.fg("statusLineStaged", `+${statusValue(ctx, `${gitStatus.staged}`)}`));
+				indicators.push(theme.fg("statusLineStaged", `+${gitStatus.staged}`));
 			}
 			if (opts.showUntracked !== false && gitStatus.untracked > 0) {
-				indicators.push(theme.fg("statusLineUntracked", `?${statusValue(ctx, `${gitStatus.untracked}`)}`));
+				indicators.push(theme.fg("statusLineUntracked", `?${gitStatus.untracked}`));
 			}
 			if (indicators.length > 0) {
 				const indicatorText = indicators.join(" ");
@@ -507,9 +502,8 @@ const prSegment: StatusLineSegment = {
 		const { pr } = ctx.git;
 		if (!pr) return { content: "", visible: false };
 
-		const label = withIcon(theme.icon.pr, `#${statusValue(ctx, `${pr.number}`)}`);
-		const content =
-			!ctx.startupPlaceholder && TERMINAL.hyperlinks ? `\x1b]8;;${pr.url}\x07${label}\x1b]8;;\x07` : label;
+		const label = withIcon(theme.icon.pr, `#${pr.number}`);
+		const content = TERMINAL.hyperlinks ? `\x1b]8;;${pr.url}\x07${label}\x1b]8;;\x07` : label;
 		return { content: accentFg(ctx, "accent", content), visible: true };
 	},
 };
@@ -520,7 +514,7 @@ const subagentsSegment: StatusLineSegment = {
 		if (ctx.subagentCount === 0) {
 			return { content: "", visible: false };
 		}
-		const content = withIcon(theme.icon.agents, statusValue(ctx, `${ctx.subagentCount}`));
+		const content = withIcon(theme.icon.agents, `${ctx.subagentCount}`);
 		return { content: theme.fg("statusLineSubagents", content), visible: true };
 	},
 };
@@ -542,7 +536,7 @@ const tokenTotalSegment: StatusLineSegment = {
 
 		const content = formatMetric({
 			leading: theme.icon.tokens || undefined,
-			value: statusValue(ctx, formatNumber(total)),
+			value: formatNumber(total),
 		});
 		return { content: theme.fg("statusLineSpend", content ?? ""), visible: true };
 	},
@@ -556,7 +550,7 @@ const tokenRateSegment: StatusLineSegment = {
 
 		const content = formatMetric({
 			leading: theme.icon.throughput || undefined,
-			value: `${statusValue(ctx, tokensPerSecond.toFixed(1))} tok/s`,
+			value: `${tokensPerSecond.toFixed(1)} tok/s`,
 		});
 		return { content: theme.fg("statusLineOutput", content ?? ""), visible: true };
 	},
@@ -583,7 +577,6 @@ const costSegment: StatusLineSegment = {
 				usingSubscription,
 				premiumRequests,
 				fractionDigits: 2,
-				startupPlaceholder: ctx.startupPlaceholder,
 				pricingPeriod,
 				advisor: advisorCost
 					? {
@@ -623,9 +616,10 @@ const contextPctSegment: StatusLineSegment = {
 						: theme.fg(color, theme.icon.auto)
 			}`;
 		}
+		// A known window with unknown usage (startup prepaint) shows the window alone.
 		const text = theme.fg(
 			color,
-			ctx.startupPlaceholder ? STARTUP_PLACEHOLDER : formatContextUsage(pct, window, ctx.contextTokens),
+			pct === null && window > 0 ? formatNumber(window) : formatContextUsage(pct, window, ctx.contextTokens),
 		);
 		const content = withIcon(theme.icon.context, `${text}${autoIcon}`);
 
@@ -639,7 +633,7 @@ const contextTotalSegment: StatusLineSegment = {
 		const window = ctx.contextWindow;
 		if (!window) return { content: "", visible: false };
 		return {
-			content: theme.fg("statusLineContext", withIcon(theme.icon.context, statusValue(ctx, formatNumber(window)))),
+			content: theme.fg("statusLineContext", withIcon(theme.icon.context, formatNumber(window))),
 			visible: true,
 		};
 	},
@@ -657,7 +651,7 @@ const timeSpentSegment: StatusLineSegment = {
 	id: "time_spent",
 	render(ctx) {
 		if (ctx.activeMs < 1000) return { content: "", visible: false };
-		return { content: withIcon(theme.icon.time, statusValue(ctx, formatDuration(ctx.activeMs))), visible: true };
+		return { content: withIcon(theme.icon.time, formatDuration(ctx.activeMs)), visible: true };
 	},
 };
 
@@ -681,7 +675,7 @@ const timeSegment: StatusLineSegment = {
 		}
 		timeStr += suffix;
 
-		return { content: withIcon(theme.icon.time, statusValue(ctx, timeStr)), visible: true };
+		return { content: withIcon(theme.icon.time, timeStr), visible: true };
 	},
 };
 
@@ -690,7 +684,7 @@ const sessionSegment: StatusLineSegment = {
 	render(ctx) {
 		const sessionManager = ctx.session.sessionManager;
 		const sessionId = sessionManager?.getSessionId?.();
-		const display = statusValue(ctx, sessionId?.slice(0, 8) || "new");
+		const display = sessionId?.slice(0, 8) || "new";
 
 		return { content: withIcon(theme.icon.session, display), visible: true };
 	},
@@ -699,7 +693,7 @@ const sessionSegment: StatusLineSegment = {
 const hostnameSegment: StatusLineSegment = {
 	id: "hostname",
 	render(ctx) {
-		const name = statusValue(ctx, ctx.hostname ?? os.hostname().split(".")[0]);
+		const name = ctx.hostname ?? os.hostname().split(".")[0];
 		const content = withIcon(theme.icon.host, name);
 		const ansi = sessionAccentAnsi(ctx);
 		return { content: ansi ? `${ansi}${content}\x1b[39m` : content, visible: true };
@@ -729,7 +723,7 @@ const cacheHitSegment: StatusLineSegment = {
 		const total = cacheRead + cacheWrite + input;
 
 		const rate = (cacheRead / total) * 100;
-		const rateStr = statusValue(ctx, rate.toFixed(2));
+		const rateStr = rate.toFixed(2);
 
 		const parts: string[] = [theme.icon.cache];
 		parts.push(theme.fg("statusLineSpend", `${rateStr}%`));
@@ -744,7 +738,7 @@ const sessionNameSegment: StatusLineSegment = {
 		const name = sessionManager?.getSessionName() || ctx.previewTitle;
 		if (!name) return { content: "", visible: false };
 
-		const content = ctx.startupPlaceholder ? STARTUP_PLACEHOLDER : sanitizeStatusText(name);
+		const content = sanitizeStatusText(name);
 		return { content: accentFg(ctx, "accent", content), visible: true };
 	},
 };
@@ -753,7 +747,7 @@ const collabSegment: StatusLineSegment = {
 	id: "collab",
 	render(ctx) {
 		if (!ctx.collab) return { content: "", visible: false };
-		const participants = statusValue(ctx, `${ctx.collab.participantCount}`);
+		const participants = `${ctx.collab.participantCount}`;
 		const label = ctx.collab.role === "host" ? `⇄ collab:${participants}` : `⇄ collab guest:${participants}`;
 		return { content: accentFg(ctx, "accent", label), visible: true };
 	},
@@ -763,7 +757,7 @@ const streamSegment: StatusLineSegment = {
 	id: "stream",
 	render(ctx) {
 		const badges: string[] = [];
-		if (ctx.stream) badges.push(`● LIVE ${statusValue(ctx, `${ctx.stream.viewers}`)}`);
+		if (ctx.stream) badges.push(`● LIVE ${ctx.stream.viewers}`);
 		if (ctx.recording) badges.push("● REC");
 		if (badges.length === 0) return { content: "", visible: false };
 		return { content: theme.fg("thinkingHigh", badges.join(" ")), visible: true };
@@ -838,11 +832,8 @@ function formatQuotaWindow(
 	integer: "round" | "floor",
 ): string {
 	const whole = integer === "floor" ? Math.floor(percent) : Math.round(percent);
-	const pctText = theme.fg(pickUsageColor(percent), `${statusValue(ctx, `${whole}`)}%`);
-	const resetText =
-		reset !== undefined
-			? theme.fg("muted", ctx.startupPlaceholder ? " (…)" : ` (${formatUsageReset(reset, resetUnit)})`)
-			: "";
+	const pctText = theme.fg(pickUsageColor(percent), `${whole}%`);
+	const resetText = reset !== undefined ? theme.fg("muted", ` (${formatUsageReset(reset, resetUnit)})`) : "";
 	return `${label} ${pctText}${resetText}`;
 }
 
@@ -870,9 +861,7 @@ const usageSegment: StatusLineSegment = {
 		}
 		const parts: string[] = [];
 		if (u.tier) {
-			const tier = ctx.startupPlaceholder
-				? STARTUP_PLACEHOLDER
-				: truncateToWidth(sanitizeStatusText(u.tier), TRUNCATE_LENGTHS.SHORT);
+			const tier = truncateToWidth(sanitizeStatusText(u.tier), TRUNCATE_LENGTHS.SHORT);
 			if (tier) parts.push(accentFg(ctx, "accent", tier));
 		}
 		if (u.fiveHour) {

package/src/status-line/startup.ts

@@ -0,0 +1,181 @@
+/**
+ * Status line for the speculative first frame, before any session exists.
+ *
+ * InteractiveMode persists {@link StatusLineStartupData} (settings plus the last
+ * session's model and thinking state); the next launch renders it through the
+ * real {@link StatusLineComponent} as a fresh, unnamed session at the live
+ * terminal width. Path and git branch are read live; context usage is reported
+ * unknown so the gauge shows the window without a percent.
+ *
+ * @example
+ * ```ts ignore
+ * const statusLine = createStartupStatusLine(cached.statusLine);
+ * statusLine.attachToEditor(editor, getComposerStyle(shape));
+ * ```
+ */
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Model } from "@oh-my-pi/pi-catalog/types";
+import { isRecord } from "@oh-my-pi/pi-utils/type-guards";
+import { parseThinkingLevel } from "../thinking";
+import { StatusLineComponent } from "./component";
+import type { CompactionBoundaries } from "./context-usage";
+import type { StatusLineHost, StatusLineSession } from "./host";
+import {
+	CONTEXT_LINE_MODE_VALUES,
+	STATUS_LINE_PRESET_VALUES,
+	STATUS_LINE_SEGMENT_IDS,
+	STATUS_LINE_SEPARATOR_VALUES,
+} from "./schema";
+import type { StatusLineSettings } from "./types";
+
+/** Session-independent inputs that reproduce a fresh session's status bar on the next launch. */
+export interface StatusLineStartupData {
+	readonly settings: StatusLineSettings;
+	readonly gitEnabled: boolean;
+	/** Model of the last session; the next fresh session usually starts on it too. */
+	readonly model?: Model;
+	readonly thinkingLevel?: ThinkingLevel;
+	readonly autoThinking: boolean;
+	readonly fastMode: boolean;
+	/** Whether `model` bills through a subscription (drives the cost segment's prefix). */
+	readonly usingSubscription: boolean;
+	readonly autoCompactEnabled: boolean;
+	readonly compactionBoundaries: CompactionBoundaries | null;
+}
+
+const NO_MESSAGES: readonly never[] = [];
+const NO_USAGE = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	orchestrationInput: 0,
+	orchestrationOutput: 0,
+	orchestrationCacheRead: 0,
+	premiumRequests: 0,
+	cost: 0,
+};
+
+/** Build the prepaint status line; the caller disposes it once the session-bound bar mounts. */
+export function createStartupStatusLine(data: StatusLineStartupData): StatusLineComponent {
+	const session: StatusLineSession = {
+		state: { model: data.model, thinkingLevel: data.thinkingLevel, messages: NO_MESSAGES },
+		model: data.model,
+		messages: NO_MESSAGES,
+		isStreaming: false,
+		isAutoThinking: data.autoThinking,
+		sessionManager: {
+			getSessionName: () => undefined,
+			getSessionId: () => "",
+			getUsageStatistics: () => NO_USAGE,
+		},
+		modelRegistry: { isUsingOAuth: () => data.usingSubscription },
+		getContextUsage: () =>
+			data.model?.contextWindow ? { tokens: 0, contextWindow: data.model.contextWindow, percent: null } : undefined,
+		autoResolvedThinkingLevel: () => undefined,
+		isFastModeActive: () => data.fastMode,
+		getAsyncJobSnapshot: () => null,
+		getGoalModeState: () => undefined,
+	};
+	const host: StatusLineHost = {
+		getSettings: () => data.settings,
+		gitEnabled: () => data.gitEnabled,
+		codexResetFireworksEnabled: () => false,
+		getSettingsRevision: () => 0,
+		getSessionSettingsIdentity: () => undefined,
+		getSessionSettingsRevision: () => 0,
+		goalStatusInFooter: () => false,
+		activeAccount: () => undefined,
+		canFetchUsageReports: () => false,
+		fetchUsageReports: async () => null,
+		resolveActiveRepo: () => null,
+		lookupPullRequest: async () => ({ stdout: "", exitCode: 1 }),
+		calculateTokensPerSecond: () => null,
+		limitMatchesActiveAccount: () => false,
+		computeCompactionBoundaries: () => data.compactionBoundaries,
+	};
+	const statusLine = new StatusLineComponent(session, host);
+	statusLine.setAutoCompactEnabled(data.autoCompactEnabled);
+	return statusLine;
+}
+
+function isOneOf<T extends string>(values: readonly T[], value: unknown): value is T {
+	return typeof value === "string" && values.some(candidate => candidate === value);
+}
+
+function isOptionalBoolean(value: unknown): boolean {
+	return value === undefined || typeof value === "boolean";
+}
+
+function isSegmentList(value: unknown): boolean {
+	return value === undefined || (Array.isArray(value) && value.every(id => isOneOf(STATUS_LINE_SEGMENT_IDS, id)));
+}
+
+/** Shallow check of persisted settings; nested segment options are trusted as written by this version. */
+function isStatusLineSettings(value: unknown): value is StatusLineSettings {
+	return (
+		isRecord(value) &&
+		(value.preset === undefined || isOneOf(STATUS_LINE_PRESET_VALUES, value.preset)) &&
+		isSegmentList(value.leftSegments) &&
+		isSegmentList(value.rightSegments) &&
+		(value.separator === undefined || isOneOf(STATUS_LINE_SEPARATOR_VALUES, value.separator)) &&
+		(value.segmentOptions === undefined || isRecord(value.segmentOptions)) &&
+		(value.contextLine === undefined || isOneOf(CONTEXT_LINE_MODE_VALUES, value.contextLine)) &&
+		isOptionalBoolean(value.showHookStatus) &&
+		isOptionalBoolean(value.sessionAccent) &&
+		isOptionalBoolean(value.transparent) &&
+		isOptionalBoolean(value.compactThinkingLevel)
+	);
+}
+
+/** Check the model fields the status line reads; the rest is trusted as serialized by this version. */
+function isPersistedModel(value: unknown): value is Model {
+	return (
+		isRecord(value) &&
+		typeof value.id === "string" &&
+		typeof value.name === "string" &&
+		typeof value.provider === "string" &&
+		typeof value.api === "string" &&
+		typeof value.contextWindow === "number"
+	);
+}
+
+function readCompactionBoundaries(value: unknown): CompactionBoundaries | null | undefined {
+	if (value === null) return null;
+	if (!isRecord(value) || typeof value.thresholdPercent !== "number") return undefined;
+	const speculationPercent = value.speculationPercent;
+	if (speculationPercent !== null && typeof speculationPercent !== "number") return undefined;
+	return { thresholdPercent: value.thresholdPercent, speculationPercent };
+}
+
+/** Validate persisted {@link StatusLineStartupData}; `undefined` for anything malformed. */
+export function readStatusLineStartupData(value: unknown): StatusLineStartupData | undefined {
+	if (!isRecord(value) || !isStatusLineSettings(value.settings)) return undefined;
+	const model = value.model;
+	if (model !== undefined && !isPersistedModel(model)) return undefined;
+	const thinkingLevel = typeof value.thinkingLevel === "string" ? parseThinkingLevel(value.thinkingLevel) : undefined;
+	if (value.thinkingLevel !== undefined && thinkingLevel === undefined) return undefined;
+	const compactionBoundaries = readCompactionBoundaries(value.compactionBoundaries);
+	if (
+		typeof value.gitEnabled !== "boolean" ||
+		typeof value.autoThinking !== "boolean" ||
+		typeof value.fastMode !== "boolean" ||
+		typeof value.usingSubscription !== "boolean" ||
+		typeof value.autoCompactEnabled !== "boolean" ||
+		compactionBoundaries === undefined
+	) {
+		return undefined;
+	}
+	return {
+		settings: value.settings,
+		gitEnabled: value.gitEnabled,
+		model,
+		thinkingLevel,
+		autoThinking: value.autoThinking,
+		fastMode: value.fastMode,
+		usingSubscription: value.usingSubscription,
+		autoCompactEnabled: value.autoCompactEnabled,
+		compactionBoundaries,
+	};
+}

package/src/status-line/types.ts

@@ -84,8 +84,6 @@ export interface SegmentContext {
 	sessionAccent?: boolean;
 	/** Stand-in session title for previews; `session_name` renders it when the session is unnamed. */
 	previewTitle?: string;
-	/** Replace dynamic values with ellipses while preserving each segment's icon, color, and static text. */
-	startupPlaceholder?: boolean;
 	activeRepo: ActiveRepoContext | null;
 	width: number;
 	options: StatusLineSegmentOptions;