@selesai/code 0.13.12 → 0.13.13

package/dist/extensions/pi-zentui/test/config.test.ts

@@ -1,3119 +0,0 @@
-import {
-	chmodSync,
-	existsSync,
-	lstatSync,
-	mkdirSync,
-	mkdtempSync,
-	readdirSync,
-	readFileSync,
-	readlinkSync,
-	rmSync,
-	statSync,
-	symlinkSync,
-	writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { visibleWidth } from "@earendil-works/pi-tui";
-import { describe, expect, it } from "vitest";
-import {
-	DEFAULT_COMPACT_FOOTER_FORMAT,
-	DEFAULT_EDITOR_METADATA_FORMAT,
-	defaultConfig,
-	ensureConfigExists,
-	FOOTER_FORMAT_VARIABLES,
-	getExtensionStatusColorMode,
-	getExtensionStatusPlacement,
-	hasUnsupportedComponentStyle,
-	mergeConfig,
-	saveAccentRailEditorStylePatch,
-	saveColorSourcesPatch,
-	saveContextStylePatch,
-	saveContextThresholdsPatch,
-	saveEditorBorderColorMode,
-	saveEditorComponentPatch,
-	saveEditorModelLabel,
-	saveEditorStyle,
-	saveExtensionStatusColorMode,
-	saveExtensionStatusDefaultPlacement,
-	saveExtensionStatusPlacement,
-	saveFooterComponentPatch,
-	saveFooterFormatPatch,
-	saveFooterSegmentsPatch,
-	saveGitBranchPatch,
-	saveGitCommitPatch,
-	saveGitMetricsPatch,
-	saveMinimalistEditorStylePatch,
-	saveMinimalistPatch,
-	savePathDisplayPatch,
-	savePolishedCopyFriendlyEditorStylePatch,
-	savePolishedEditorStylePatch,
-	saveResponsiveFooterPatch,
-	saveSelectorBordersComponentPatch,
-	saveSeparatorPatch,
-	saveStarshipFooterStylePatch,
-	saveUiFeaturesPatch,
-	saveUserMessagesComponentPatch,
-	saveWorkingLineComponentPatch,
-} from "../extensions/zentui/config";
-import {
-	colorize,
-	renderChromeBorder,
-	renderStyle,
-	renderStyleForSource,
-	renderTerminalStyle,
-} from "../extensions/zentui/style";
-
-function configTempFiles(dir: string, filename = "zentui.json"): string[] {
-	return readdirSync(dir).filter(
-		(name) => name.startsWith(`.${filename}.`) && name.endsWith(".tmp"),
-	);
-}
-
-function withConfig(
-	initial: Record<string, unknown> | undefined,
-	assertions: (path: string, dir: string) => void,
-): void {
-	const dir = mkdtempSync(join(tmpdir(), "zentui-config-"));
-	const path = join(dir, "zentui.json");
-	try {
-		if (initial !== undefined) writeFileSync(path, `${JSON.stringify(initial, null, 2)}\n`);
-		assertions(path, dir);
-	} finally {
-		rmSync(dir, { recursive: true, force: true });
-	}
-}
-
-// biome-ignore lint/suspicious/noExplicitAny: Tests intentionally inspect arbitrary JSON fixture shapes.
-function readRaw(path: string): Record<string, any> {
-	return JSON.parse(readFileSync(path, "utf8"));
-}
-
-describe("canonical config resolution", () => {
-	it("provides complete canonical defaults and the established palette defaults", () => {
-		const config = mergeConfig({});
-		expect(config.components).toEqual({
-			editor: {
-				enabled: false,
-				style: "opencode",
-				colorSource: "theme",
-				borderColorMode: "adaptive",
-				modelLabel: "name",
-				viewportIndicators: false,
-				styles: {
-					opencode: {
-						metadataFormat: DEFAULT_EDITOR_METADATA_FORMAT,
-						completionMenu: "native",
-					},
-					"opencode-copy-friendly": {
-						metadataFormat: DEFAULT_EDITOR_METADATA_FORMAT,
-						completionMenu: "native",
-					},
-					"accent-rail": {
-						rail: "▎",
-						asciiRail: "|",
-						transparent: false,
-					},
-					minimalist: {
-						pathDisplay: "compact",
-						contextFormat: "percent",
-						contextGauge: true,
-						showSessionName: true,
-						showTimer: true,
-						showCost: true,
-						showGit: true,
-						contextThresholds: { warning: 70, error: 90 },
-					},
-				},
-			},
-			userMessages: {
-				enabled: true,
-				style: "labeled",
-				colorSource: "theme",
-				styles: { framed: {}, "framed-copy-friendly": {}, compact: {}, labeled: {} },
-			},
-			workingLine: {
-				enabled: true,
-				turnSummary: true,
-				spinner: "star-bloom",
-				spinnerIntervalMs: 100,
-				animateSpinnerColor: false,
-				textIntervalMs: 60,
-				textAnimation: "classic",
-				colorSource: "theme",
-				messages: {
-					custom: true,
-					values: [...defaultConfig.components.workingLine.messages.values],
-				},
-				segments: { tool: true, elapsed: true, thought: true, tokens: true },
-			},
-			selectorBorders: { enabled: true, style: "zentui", colorSource: "theme" },
-			footer: {
-				style: "native",
-				colorSource: "theme",
-				modelLabel: "name",
-				styles: {
-					starship: {
-						format: "",
-						responsive: true,
-						compactFormat: DEFAULT_COMPACT_FOOTER_FORMAT,
-						compactMaxLines: "unlimited",
-						separator: "none",
-						contextStyle: "text",
-						contextThresholds: { warning: 70, error: 90 },
-						pathDisplay: { mode: "basename", depth: 2 },
-						segments: defaultConfig.footerSegments,
-						gitBranch: { maxLength: "full" },
-						gitCommit: { hashLength: 7, onlyDetached: true, showTag: true },
-						gitMetrics: { onlyNonzero: true, ignoreSubmodules: false },
-						extensionStatuses: {
-							defaultPlacement: "right",
-							placements: {},
-							colorModes: {},
-						},
-					},
-				},
-			},
-		});
-		expect(config.projectRefreshIntervalMs).toBe(30_000);
-		expect(config.icons.cacheHit).toBe("c");
-		expect(config.colors).toEqual(defaultConfig.colors);
-		expect(defaultConfig.components).toEqual(config.components);
-	});
-
-	it("normalizes Opencode completion menus independently", () => {
-		const config = mergeConfig({
-			components: {
-				editor: {
-					styles: {
-						opencode: { completionMenu: "native" },
-						"opencode-copy-friendly": { completionMenu: "invalid" },
-					},
-				},
-			},
-		});
-		expect(config.components.editor.styles.opencode.completionMenu).toBe("native");
-		expect(config.components.editor.styles["opencode-copy-friendly"].completionMenu).toBe(
-			"native",
-		);
-	});
-
-	it("normalizes the canonical accent-rail style and its editor-owned roles", () => {
-		const config = mergeConfig({
-			colors: { editorRail: "bright-green", editorAccent: "error" },
-			components: {
-				editor: {
-					style: "accent-rail",
-					styles: { "accent-rail": { rail: "!", asciiRail: ":", transparent: true } },
-				},
-			},
-		});
-		expect(config.components.editor.style).toBe("accent-rail");
-		expect(config.components.editor.styles["accent-rail"]).toEqual({
-			rail: "!",
-			asciiRail: ":",
-			transparent: true,
-		});
-		expect(config.colors.editorRail).toBe("bright-green");
-		expect(config.colors.editorAccent).toBe("error");
-
-		const invalid = mergeConfig({
-			components: {
-				editor: {
-					styles: { "accent-rail": { rail: "", asciiRail: 1, transparent: "yes" } },
-				},
-			},
-		});
-		expect(invalid.components.editor.styles["accent-rail"]).toEqual({
-			rail: "▎",
-			asciiRail: "|",
-			transparent: false,
-		});
-	});
-
-	it("bridges explicit legacy branch colors into the independent Editor branch role", () => {
-		expect(mergeConfig({}).colors.editorGitBranch).toBeUndefined();
-
-		const legacyDefault = mergeConfig({ colors: { gitBranch: "bold purple" } }).colors;
-		expect(legacyDefault.gitBranch).toBe("bold purple");
-		expect(legacyDefault.editorGitBranch).toBe("bold purple");
-
-		const legacyCustom = mergeConfig({ colors: { gitBranch: "success" } }).colors;
-		expect(legacyCustom.gitBranch).toBe("success");
-		expect(legacyCustom.editorGitBranch).toBe("success");
-
-		const independent = mergeConfig({
-			colors: { gitBranch: "success", editorGitBranch: "accent" },
-		}).colors;
-		expect(independent.gitBranch).toBe("success");
-		expect(independent.editorGitBranch).toBe("accent");
-	});
-
-	it("ignores stale fixed-editor config forms without exposing runtime fields", () => {
-		const config = mergeConfig({
-			fixedEditor: { enabled: true, mouseScroll: false },
-			layout: { fixedEditor: { enabled: "yes", copyNotice: false }, futureLayout: true },
-		});
-		expect(config).not.toHaveProperty("fixedEditor");
-		expect(config).not.toHaveProperty("layout");
-	});
-
-	it("migrates every released legacy field leaf-by-leaf", () => {
-		const config = mergeConfig({
-			features: {
-				editor: false,
-				statusLine: false,
-				viewportIndicators: false,
-				copyFriendly: true,
-			},
-			colorSources: { editor: "terminal", userMessages: "terminal", starship: "terminal" },
-			editorBorderColorMode: "adaptive",
-			editorModelLabel: "name",
-			editorMetadataFormat: "$model",
-			contextThresholds: { warning: 55, error: 88 },
-			footerFormat: "$cwd",
-			responsiveFooter: false,
-			compactFooterFormat: "$context",
-			compactFooterMaxLines: 3,
-			separator: "dot",
-			contextStyle: "gauge",
-			pathDisplay: { mode: "full", depth: 2 },
-			footerSegments: { cwd: false, modelInfo: true },
-			gitBranch: { maxLength: 18 },
-			gitCommit: { hashLength: 12, onlyDetached: false, showTag: false },
-			gitMetrics: { onlyNonzero: false, ignoreSubmodules: true },
-			extensionStatuses: {
-				defaultPlacement: "middle",
-				placements: { alpha: "left" },
-				colorModes: { alpha: "original" },
-			},
-		});
-		const { editor, userMessages, selectorBorders, footer } = config.components;
-		const starship = footer.styles.starship;
-		expect([editor.enabled, userMessages.enabled, selectorBorders.enabled]).toEqual([
-			false,
-			false,
-			false,
-		]);
-		expect(editor.viewportIndicators).toBe(false);
-		expect(editor.style).toBe("opencode-copy-friendly");
-		expect(userMessages).toMatchObject({ enabled: false, style: "framed-copy-friendly" });
-		expect([editor.colorSource, selectorBorders.colorSource]).toEqual(["terminal", "terminal"]);
-		expect(userMessages.colorSource).toBe("terminal");
-		expect(footer.colorSource).toBe("terminal");
-		expect(editor.borderColorMode).toBe("adaptive");
-		expect([editor.modelLabel, footer.modelLabel]).toEqual(["name", "name"]);
-		expect(editor.styles.opencode.metadataFormat).toBe("$model");
-		expect(editor.styles.minimalist.contextThresholds).toEqual({ warning: 55, error: 88 });
-		expect(starship).toMatchObject({
-			format: "$cwd",
-			responsive: false,
-			compactFormat: "$context",
-			compactMaxLines: 3,
-			separator: "dot",
-			contextStyle: "gauge",
-			contextThresholds: { warning: 55, error: 88 },
-			pathDisplay: { mode: "full", depth: 2 },
-			gitBranch: { maxLength: 18 },
-			gitCommit: { hashLength: 12, onlyDetached: false, showTag: false },
-			gitMetrics: { onlyNonzero: false, ignoreSubmodules: true },
-			extensionStatuses: {
-				defaultPlacement: "middle",
-				placements: { alpha: "left" },
-				colorModes: { alpha: "original" },
-			},
-		});
-		expect(starship.segments).toMatchObject({ cwd: false, modelInfo: true });
-	});
-
-	it("gives canonical leaves precedence, including false and invalid-but-present values", () => {
-		const config = mergeConfig({
-			features: { editor: true, copyFriendly: true, viewportIndicators: false },
-			colorSources: { editor: "terminal" },
-			editorBorderColorMode: "adaptive",
-			editorMetadataFormat: "$legacy",
-			components: {
-				editor: {
-					enabled: false,
-					style: "unknown",
-					colorSource: "unknown",
-					styles: {
-						polished: { copyFriendly: "yes" },
-					},
-				},
-			},
-		});
-		expect(config.components.editor.enabled).toBe(false);
-		expect(config.components.editor.style).toBe("opencode");
-		expect(config.components.editor.colorSource).toBe("theme");
-		// Missing canonical siblings still migrate independently.
-		expect(config.components.editor.viewportIndicators).toBe(false);
-		expect(config.components.editor.borderColorMode).toBe("adaptive");
-		expect(config.components.editor.styles.opencode.metadataFormat).toBe("$legacy");
-	});
-
-	it("normalizes every canonical minimalist leaf without reviving branch-only inputs", () => {
-		for (const pathDisplay of ["compact", "project", "full"]) {
-			expect(
-				mergeConfig({
-					components: { editor: { styles: { minimalist: { pathDisplay } } } },
-				}).components.editor.styles.minimalist.pathDisplay,
-			).toBe(pathDisplay);
-		}
-		for (const pathDisplay of ["basename", "", 1, null, true]) {
-			expect(
-				mergeConfig({
-					editorStyles: { minimalist: { pathDisplay: "full" } },
-					components: { editor: { styles: { minimalist: { pathDisplay } } } },
-				}).components.editor.styles.minimalist.pathDisplay,
-			).toBe("compact");
-		}
-
-		for (const contextFormat of ["percent", "percent-total"]) {
-			expect(
-				mergeConfig({
-					components: { editor: { styles: { minimalist: { contextFormat } } } },
-				}).components.editor.styles.minimalist.contextFormat,
-			).toBe(contextFormat);
-		}
-		for (const contextFormat of ["tokens", "", 1, null, true]) {
-			expect(
-				mergeConfig({
-					editorStyles: { minimalist: { contextFormat: "percent-total" } },
-					components: { editor: { styles: { minimalist: { contextFormat } } } },
-				}).components.editor.styles.minimalist.contextFormat,
-			).toBe("percent");
-		}
-
-		const valid = mergeConfig({
-			components: {
-				editor: {
-					styles: {
-						minimalist: {
-							contextGauge: true,
-							showSessionName: false,
-							showTimer: false,
-							showCost: false,
-							showGit: false,
-						},
-					},
-				},
-			},
-		}).components.editor.styles.minimalist;
-		expect(valid).toMatchObject({
-			contextGauge: true,
-			showSessionName: false,
-			showTimer: false,
-			showCost: false,
-			showGit: false,
-		});
-
-		const invalid = mergeConfig({
-			editorStyles: {
-				minimalist: {
-					contextGauge: true,
-					showSessionName: false,
-					showTimer: false,
-					showCost: false,
-					showGit: false,
-				},
-			},
-			components: {
-				editor: {
-					styles: {
-						minimalist: {
-							contextGauge: "yes",
-							showSessionName: "yes",
-							showTimer: null,
-							showCost: 0,
-							showGit: "no",
-						},
-					},
-				},
-			},
-		}).components.editor.styles.minimalist;
-		expect(invalid).toEqual(defaultConfig.components.editor.styles.minimalist);
-	});
-
-	it("ignores branch-only editorStyle/editorStyles and safely defaults closed style IDs", () => {
-		const config = mergeConfig({
-			editorStyle: "minimalist",
-			editorStyles: { minimalist: { showGit: false } },
-			components: {
-				editor: { style: "future" },
-				userMessages: { style: "future" },
-				selectorBorders: { style: "future" },
-				footer: { style: "future" },
-			},
-		});
-		expect(config.components.editor.style).toBe("opencode");
-		expect(config.components.editor.styles.minimalist.showGit).toBe(true);
-		expect(config.components.userMessages.style).toBe("labeled");
-		expect(config.components.selectorBorders.style).toBe("zentui");
-		expect(config.components.footer.style).toBe("native");
-	});
-
-	it("does not treat native as a User-message style", () => {
-		expect(
-			mergeConfig({ components: { userMessages: { style: "native" } } }).components.userMessages
-				.style,
-		).toBe("labeled");
-	});
-
-	it("normalizes nested canonical leaves without falling through to contradictory legacy leaves", () => {
-		const config = mergeConfig({
-			contextThresholds: { warning: 20, error: 80 },
-			pathDisplay: { mode: "full", depth: 4 },
-			components: {
-				editor: {
-					styles: { minimalist: { contextThresholds: { warning: "bad" } } },
-				},
-				footer: {
-					styles: {
-						starship: {
-							contextThresholds: { warning: "bad" },
-							pathDisplay: { mode: "bad" },
-						},
-					},
-				},
-			},
-		});
-		expect(config.components.editor.styles.minimalist.contextThresholds).toEqual({
-			warning: 70,
-			error: 80,
-		});
-		expect(config.components.footer.styles.starship.contextThresholds).toEqual({
-			warning: 70,
-			error: 80,
-		});
-		expect(config.components.footer.styles.starship.pathDisplay).toEqual({
-			mode: "basename",
-			depth: 4,
-		});
-	});
-
-	it("projects the intentionally lossy flat compatibility view from canonical sources", () => {
-		const config = mergeConfig({
-			components: {
-				editor: {
-					enabled: false,
-					style: "minimalist",
-					colorSource: "terminal",
-					modelLabel: "name",
-					styles: { opencode: { copyFriendly: true, metadataFormat: "$model" } },
-				},
-				userMessages: {
-					enabled: true,
-					colorSource: "theme",
-					styles: { framed: { copyFriendly: false } },
-				},
-				selectorBorders: { enabled: true, colorSource: "theme" },
-				footer: {
-					modelLabel: "id",
-					colorSource: "terminal",
-					styles: { starship: { contextThresholds: { warning: 40, error: 60 } } },
-				},
-			},
-		});
-		const starship = config.components.footer.styles.starship;
-		expect(config.footerFormat).toBe(starship.format);
-		expect(config.responsiveFooter).toBe(starship.responsive);
-		expect(config.compactFooterFormat).toBe(starship.compactFormat);
-		expect(config.compactFooterMaxLines).toBe(starship.compactMaxLines);
-		expect(config.separator).toBe(starship.separator);
-		expect(config.contextStyle).toBe(starship.contextStyle);
-		expect(config.contextThresholds).toBe(starship.contextThresholds);
-		expect(config.pathDisplay).toBe(starship.pathDisplay);
-		expect(config.footerSegments).toBe(starship.segments);
-		expect(config.gitBranch).toBe(starship.gitBranch);
-		expect(config.gitCommit).toBe(starship.gitCommit);
-		expect(config.gitMetrics).toBe(starship.gitMetrics);
-		expect(config.extensionStatuses).toBe(starship.extensionStatuses);
-		expect(config.features).toEqual({
-			editor: false,
-			statusLine: false,
-			viewportIndicators: false,
-		});
-		expect(config.colorSources).toEqual({
-			starship: "terminal",
-			editor: "terminal",
-			userMessages: "theme",
-		});
-		expect(config.editorModelLabel).toBe("name");
-		expect(config.contextThresholds).toEqual({ warning: 40, error: 60 });
-	});
-
-	it("does not mutate the parsed record", () => {
-		const parsed = {
-			features: { editor: false },
-			components: { editor: { styles: { opencode: { copyFriendly: true } } } },
-		};
-		const before = structuredClone(parsed);
-		mergeConfig(parsed);
-		expect(parsed).toEqual(before);
-	});
-
-	it("retains root parsing behavior for intervals, icons, colors, and telemetry variables", () => {
-		const config = mergeConfig({
-			projectRefreshIntervalMs: 100,
-			icons: { mode: "ascii", cwd: "DIR" },
-			colors: { gitBranch: "syntaxKeyword", editorAccent: "accent" },
-		});
-		expect(config.projectRefreshIntervalMs).toBe(5_000);
-		expect(config.icons.cwd).toBe("DIR");
-		expect(config.colors.gitBranch).toBe("syntaxKeyword");
-		expect(config.colors.editorAccent).toBe("accent");
-		expect(FOOTER_FORMAT_VARIABLES).toEqual(
-			expect.arrayContaining(["cache_read", "cache_write", "subscription", "auto_compaction"]),
-		);
-	});
-});
-
-describe("working-line config", () => {
-	it("defaults to cloned custom presets and migrates legacy modes without losing values", () => {
-		const first = mergeConfig({}).components.workingLine.messages;
-		const second = mergeConfig({}).components.workingLine.messages;
-		expect(first).toEqual({
-			custom: true,
-			values: defaultConfig.components.workingLine.messages.values,
-		});
-		expect(first.values).not.toBe(second.values);
-		expect(first.values).not.toBe(defaultConfig.components.workingLine.messages.values);
-		expect(
-			mergeConfig({ components: { workingLine: { messages: { mode: "native", values: [] } } } })
-				.components.workingLine.messages,
-		).toEqual({ custom: false, values: defaultConfig.components.workingLine.messages.values });
-		expect(
-			mergeConfig({ components: { workingLine: { messages: { mode: "replace", values: [] } } } })
-				.components.workingLine.messages,
-		).toEqual({ custom: true, values: defaultConfig.components.workingLine.messages.values });
-		expect(
-			mergeConfig({
-				components: { workingLine: { messages: { mode: "replace", values: [" Custom "] } } },
-			}).components.workingLine.messages,
-		).toEqual({ custom: true, values: ["Custom"] });
-		const appendValues = Array.from({ length: 32 }, (_, index) => `legacy-${index}`);
-		const append = mergeConfig({
-			components: { workingLine: { messages: { mode: "append", values: appendValues } } },
-		}).components.workingLine.messages;
-		expect(append.custom).toBe(true);
-		expect(append.values).toEqual([
-			...defaultConfig.components.workingLine.messages.values,
-			...appendValues,
-		]);
-		expect(append.values).toHaveLength(48);
-	});
-
-	it("gives canonical custom presence precedence and preserves explicit empty values", () => {
-		expect(
-			mergeConfig({
-				components: {
-					workingLine: { messages: { custom: false, mode: "append", values: [] } },
-				},
-			}).components.workingLine.messages,
-		).toEqual({ custom: false, values: [] });
-		expect(
-			mergeConfig({
-				components: { workingLine: { messages: { custom: "bad", mode: "native" } } },
-			}).components.workingLine.messages,
-		).toEqual({ custom: true, values: defaultConfig.components.workingLine.messages.values });
-		expect(
-			mergeConfig({ components: { workingLine: { messages: { values: [] } } } }).components
-				.workingLine.messages,
-		).toEqual({ custom: true, values: [] });
-	});
-
-	it.each([
-		[30, 30],
-		[1000, 1000],
-		[29, 100],
-		[1001, 100],
-		[60.5, 100],
-		["60", 100],
-		[Number.NaN, 100],
-		[Number.MAX_SAFE_INTEGER, 100],
-	] as const)(
-		"migrates legacy Working-line interval %s to spinner speed %s ms",
-		(intervalMs, expected) => {
-			expect(
-				mergeConfig({ components: { workingLine: { intervalMs } } }).components.workingLine
-					.spinnerIntervalMs,
-			).toBe(expected);
-			expect(
-				mergeConfig({ components: { workingLine: { intervalMs } } }).components.workingLine
-					.textIntervalMs,
-			).toBe(60);
-		},
-	);
-
-	it.each([
-		[30, 30],
-		[1000, 1000],
-		[29, 60],
-		[1001, 60],
-		[60.5, 60],
-		["60", 60],
-	] as const)("normalizes canonical text speed %s to %s ms", (textIntervalMs, expected) => {
-		expect(
-			mergeConfig({ components: { workingLine: { textIntervalMs } } }).components.workingLine
-				.textIntervalMs,
-		).toBe(expected);
-	});
-
-	it("gives canonical spinner speed presence precedence over legacy input", () => {
-		expect(
-			mergeConfig({
-				components: { workingLine: { intervalMs: 180, spinnerIntervalMs: 160 } },
-			}).components.workingLine.spinnerIntervalMs,
-		).toBe(160);
-		expect(
-			mergeConfig({
-				components: { workingLine: { intervalMs: 180, spinnerIntervalMs: "bad" } },
-			}).components.workingLine.spinnerIntervalMs,
-		).toBe(100);
-	});
-
-	it("defaults malformed or missing Turn summary to true and preserves explicit false", () => {
-		expect(mergeConfig({}).components.workingLine.turnSummary).toBe(true);
-		expect(
-			mergeConfig({ components: { workingLine: { turnSummary: "bad" } } }).components.workingLine
-				.turnSummary,
-		).toBe(true);
-		expect(
-			mergeConfig({ components: { workingLine: { turnSummary: false } } }).components.workingLine
-				.turnSummary,
-		).toBe(false);
-	});
-
-	it("saves Turn summary while preserving unknown config", () => {
-		withConfig(
-			{ components: { workingLine: { unknown: { keep: true } } }, topLevel: "keep" },
-			(path) => {
-				const config = saveWorkingLineComponentPatch({ turnSummary: false }, path);
-				const raw = JSON.parse(readFileSync(path, "utf8"));
-				expect(config.components.workingLine.turnSummary).toBe(false);
-				expect(raw.components.workingLine.turnSummary).toBe(false);
-				expect(raw.components.workingLine.unknown).toEqual({ keep: true });
-				expect(raw.topLevel).toBe("keep");
-			},
-		);
-	});
-
-	it("parses Pulse without changing established Working-line defaults", () => {
-		expect(mergeConfig({}).components.workingLine.spinner).toBe("star-bloom");
-		expect(
-			mergeConfig({
-				components: { workingLine: { spinner: "pulse", spinnerIntervalMs: 180 } },
-			}).components.workingLine,
-		).toMatchObject({ spinner: "pulse", spinnerIntervalMs: 180, textIntervalMs: 60 });
-	});
-
-	it("normalizes each independent field, messages, and palette override", () => {
-		const config = mergeConfig({
-			components: {
-				workingLine: {
-					enabled: true,
-					spinner: "pinwheel",
-					spinnerIntervalMs: 160,
-					animateSpinnerColor: true,
-					textIntervalMs: 40,
-					textAnimation: "kitt",
-					colorSource: "terminal",
-					messages: {
-						mode: "replace",
-						values: [" One ", "One", "\x1b[31mTwo\x1b[0m", "\n"],
-					},
-					segments: { tool: false, elapsed: true, thought: true, tokens: false },
-				},
-			},
-			colors: {
-				workingLineLow: "fg:240",
-				workingLineMid: "cyan",
-				workingLineHigh: "bold cyan",
-				editorAccent: "red",
-			},
-		});
-		expect(config.components.workingLine).toEqual({
-			enabled: true,
-			turnSummary: true,
-			spinner: "pinwheel",
-			spinnerIntervalMs: 160,
-			animateSpinnerColor: true,
-			textIntervalMs: 40,
-			textAnimation: "kitt",
-			colorSource: "terminal",
-			messages: { custom: true, values: ["One", "Two"] },
-			segments: { tool: false, elapsed: true, thought: true, tokens: false },
-		});
-		expect(config.colors).toMatchObject({
-			workingLineLow: "fg:240",
-			workingLineMid: "cyan",
-			workingLineHigh: "bold cyan",
-			editorAccent: "red",
-		});
-	});
-
-	it("falls back malformed leaves independently and enforces message caps", () => {
-		const values = Array.from({ length: 40 }, (_, index) => `${index}:${"界".repeat(30)}`);
-		const component = mergeConfig({
-			components: {
-				workingLine: {
-					enabled: "yes",
-					spinner: "future",
-					intervalMs: 29,
-					animateSpinnerColor: "yes",
-					textAnimation: "pulse",
-					colorSource: "editor",
-					messages: { mode: "rotate", values },
-				},
-			},
-			colors: { workingLineLow: "not-a-color" },
-		}).components.workingLine;
-		expect(component).toMatchObject({
-			enabled: true,
-			spinner: "star-bloom",
-			spinnerIntervalMs: 100,
-			animateSpinnerColor: false,
-			textIntervalMs: 60,
-			textAnimation: "classic",
-			colorSource: "theme",
-			messages: { custom: true },
-			segments: { tool: true, elapsed: true, thought: true, tokens: true },
-		});
-		expect(component.messages.values).toHaveLength(40);
-		expect(component.messages.values.every((value) => value.length > 0)).toBe(true);
-		expect(component.messages.values.every((value) => visibleWidth(value) <= 43)).toBe(true);
-	});
-
-	it("saves nested patches, copies arrays, and preserves unknown fields", () => {
-		withConfig(
-			{
-				unknownTop: true,
-				components: {
-					workingLine: {
-						future: { keep: true },
-						intervalMs: 180,
-						messages: { mode: "append", futureMessages: true, values: ["Old"] },
-					},
-				},
-			},
-			(path) => {
-				const values = [" New ", "New", "Other"];
-				const saved = saveWorkingLineComponentPatch(
-					{
-						spinner: "braille",
-						spinnerIntervalMs: 60,
-						animateSpinnerColor: true,
-						messages: { custom: true, values },
-						segments: { elapsed: false },
-					},
-					path,
-				);
-				values[0] = "mutated";
-				const raw = readRaw(path);
-				expect(saved.components.workingLine).toMatchObject({
-					spinner: "braille",
-					spinnerIntervalMs: 60,
-					animateSpinnerColor: true,
-					textIntervalMs: 60,
-					messages: { custom: true, values: ["New", "Other"] },
-					segments: { tool: true, elapsed: false, thought: true, tokens: true },
-				});
-				expect(raw.unknownTop).toBe(true);
-				expect(raw.components.workingLine.future).toEqual({ keep: true });
-				expect(raw.components.workingLine.messages.futureMessages).toBe(true);
-				expect(raw.components.workingLine.messages.values).toEqual(["New", "Other"]);
-				expect(raw.components.workingLine.messages.custom).toBe(true);
-				expect(raw.components.workingLine.messages).not.toHaveProperty("mode");
-				expect(raw.components.workingLine).not.toHaveProperty("intervalMs");
-			},
-		);
-	});
-});
-
-describe("Phase 4 style migration", () => {
-	it.each([
-		[true, "opencode-copy-friendly"],
-		[false, "opencode"],
-		["invalid", "opencode"],
-	] as const)("maps a present nested Editor flag %s deterministically", (copyFriendly, style) => {
-		const config = mergeConfig({
-			features: { copyFriendly: true },
-			components: {
-				editor: { style: "polished", styles: { polished: { copyFriendly } } },
-			},
-		});
-		expect(config.components.editor.style).toBe(style);
-	});
-
-	it.each([
-		[true, "framed-copy-friendly"],
-		[false, "framed"],
-		["invalid", "framed"],
-	] as const)("maps a present nested message flag %s deterministically", (copyFriendly, style) => {
-		const config = mergeConfig({
-			features: { editor: true, copyFriendly: true },
-			components: {
-				userMessages: {
-					enabled: true,
-					style: "framed",
-					styles: { framed: { copyFriendly } },
-				},
-			},
-		});
-		expect(config.components.userMessages).toMatchObject({ style, enabled: true });
-	});
-
-	it("maps the released feature flag to copy-friendly Editor and messages", () => {
-		const migrated = mergeConfig({ features: { copyFriendly: true } });
-		expect(migrated.components.editor.style).toBe("opencode-copy-friendly");
-		expect(migrated.components.userMessages).toMatchObject({
-			style: "framed-copy-friendly",
-			enabled: true,
-		});
-
-		const regular = mergeConfig({ features: { copyFriendly: false } });
-		expect(regular.components.editor.style).toBe("opencode");
-		expect(regular.components.userMessages).toMatchObject({ style: "labeled", enabled: true });
-		expect(migrated.features).not.toHaveProperty("copyFriendly");
-	});
-
-	it.each([
-		[undefined, true, "opencode-copy-friendly"],
-		[undefined, false, "opencode"],
-		[undefined, "invalid", "opencode"],
-		["future", true, "opencode-copy-friendly"],
-		["future", false, "opencode"],
-		["future", "invalid", "opencode"],
-	] as const)(
-		"resolves absent or invalid Editor style %s from nested flag %s",
-		(rawStyle, copyFriendly, expected) => {
-			const config = mergeConfig({
-				features: { copyFriendly: copyFriendly !== true },
-				components: {
-					editor: {
-						...(rawStyle === undefined ? {} : { style: rawStyle }),
-						styles: { polished: { copyFriendly } },
-					},
-				},
-			});
-			expect(config.components.editor.style).toBe(expected);
-		},
-	);
-
-	it.each([
-		[undefined, true, "framed-copy-friendly"],
-		[undefined, false, "framed"],
-		[undefined, "invalid", "framed"],
-		["future", true, "framed-copy-friendly"],
-		["future", false, "framed"],
-		["future", "invalid", "framed"],
-	] as const)(
-		"resolves absent or invalid message style %s from nested flag %s",
-		(rawStyle, copyFriendly, expectedStyle) => {
-			const config = mergeConfig({
-				features: { editor: true, copyFriendly: copyFriendly !== true },
-				components: {
-					userMessages: {
-						enabled: true,
-						...(rawStyle === undefined ? {} : { style: rawStyle }),
-						styles: { framed: { copyFriendly } },
-					},
-				},
-			});
-			expect(config.components.userMessages).toMatchObject({
-				style: expectedStyle,
-				enabled: true,
-			});
-		},
-	);
-
-	it("treats ambiguous explicit styles without nested flags as authoritative", () => {
-		const config = mergeConfig({
-			features: { editor: true, copyFriendly: true },
-			components: {
-				editor: { style: "opencode" },
-				userMessages: { enabled: true, style: "framed" },
-			},
-		});
-		expect(config.components.editor.style).toBe("opencode");
-		expect(config.components.userMessages).toMatchObject({ style: "framed", enabled: true });
-	});
-
-	it("uses released flags for absent or invalid styles without nested flags", () => {
-		for (const style of [undefined, "future"] as const) {
-			const config = mergeConfig({
-				features: { editor: true, copyFriendly: true },
-				components: {
-					editor: style === undefined ? {} : { style },
-					userMessages: style === undefined ? { enabled: true } : { enabled: true, style },
-				},
-			});
-			expect(config.components.editor.style).toBe("opencode-copy-friendly");
-			expect(config.components.userMessages).toMatchObject({
-				style: "framed-copy-friendly",
-				enabled: true,
-			});
-		}
-	});
-
-	it.each([
-		["minimalist", "compact"],
-		["opencode-copy-friendly", "labeled"],
-		["opencode", "framed-copy-friendly"],
-	] as const)("preserves unambiguous explicit styles %s and %s", (editorStyle, messageStyle) => {
-		const config = mergeConfig({
-			features: { copyFriendly: true },
-			components: {
-				editor: {
-					style: editorStyle,
-					styles: { opencode: { copyFriendly: true } },
-				},
-				userMessages: {
-					enabled: true,
-					style: messageStyle,
-					styles: { framed: { copyFriendly: true } },
-				},
-			},
-		});
-		expect(config.components.editor.style).toBe(editorStyle);
-		expect(config.components.userMessages).toMatchObject({ style: messageStyle, enabled: true });
-	});
-
-	it("seeds and parses polished metadata independently", () => {
-		const seeded = mergeConfig({ editorMetadataFormat: "$legacy" });
-		expect(seeded.components.editor.styles.opencode.metadataFormat).toBe("$legacy");
-		expect(seeded.components.editor.styles["opencode-copy-friendly"].metadataFormat).toBe(
-			"$legacy",
-		);
-		const independent = mergeConfig({
-			editorMetadataFormat: "$flat",
-			components: {
-				editor: {
-					styles: {
-						polished: { metadataFormat: "$regular" },
-						"opencode-copy-friendly": { metadataFormat: "$low" },
-					},
-				},
-			},
-		});
-		expect(independent.components.editor.styles.opencode.metadataFormat).toBe("$regular");
-		expect(independent.components.editor.styles["opencode-copy-friendly"].metadataFormat).toBe(
-			"$low",
-		);
-	});
-
-	it("deletes only obsolete owning leaves on explicit style saves", () => {
-		withConfig(
-			{
-				features: { copyFriendly: true },
-				components: {
-					editor: {
-						styles: {
-							polished: { copyFriendly: true, sibling: "keep" },
-							future: { keep: true },
-						},
-					},
-					userMessages: {
-						styles: { framed: { copyFriendly: true, sibling: "keep" }, future: { keep: true } },
-					},
-				},
-			},
-			(path) => {
-				saveEditorComponentPatch({ style: "opencode" }, path);
-				const afterEditor = readRaw(path);
-				expect(afterEditor.components.editor.styles.polished).toMatchObject({ sibling: "keep" });
-				expect(afterEditor.components.editor.styles.polished).not.toHaveProperty("copyFriendly");
-				expect(afterEditor.components.editor.styles.opencode).toHaveProperty("metadataFormat");
-				expect(afterEditor.components.userMessages.styles.framed).toMatchObject({
-					copyFriendly: true,
-					sibling: "keep",
-				});
-
-				saveUserMessagesComponentPatch({ style: "framed" }, path);
-				const raw = readRaw(path);
-				expect(raw.components.editor.styles.polished).toMatchObject({ sibling: "keep" });
-				expect(raw.components.editor.styles.polished).not.toHaveProperty("copyFriendly");
-				expect(raw.components.userMessages.styles.framed).toMatchObject({ sibling: "keep" });
-				expect(raw.components.userMessages.styles.framed).not.toHaveProperty("copyFriendly");
-				expect(raw.components.editor.styles.future).toEqual({ keep: true });
-				expect(raw.components.userMessages.styles.future).toEqual({ keep: true });
-				expect(raw.features.copyFriendly).toBe(true);
-				const reloaded = mergeConfig(raw);
-				expect(reloaded.components.editor.style).toBe("opencode");
-				expect(reloaded.components.userMessages).toMatchObject({ style: "framed", enabled: true });
-			},
-		);
-	});
-
-	it.each(["framed", "framed-copy-friendly"] as const)(
-		"cleans only the obsolete nested flag when explicitly saving %s",
-		(style) => {
-			withConfig(
-				{
-					features: { copyFriendly: true },
-					components: {
-						userMessages: {
-							styles: {
-								framed: { copyFriendly: true, sibling: "keep" },
-								future: { keep: true },
-							},
-							futureComponent: "keep",
-						},
-					},
-				},
-				(path) => {
-					saveUserMessagesComponentPatch({ style }, path);
-					const raw = readRaw(path);
-					expect(raw.components.userMessages.style).toBe(style);
-					expect(raw.components.userMessages.styles.framed).toEqual({ sibling: "keep" });
-					expect(raw.components.userMessages.styles.future).toEqual({ keep: true });
-					expect(raw.components.userMessages.futureComponent).toBe("keep");
-					expect(raw.features.copyFriendly).toBe(true);
-					expect(mergeConfig(raw).components.userMessages.style).toBe(style);
-				},
-			);
-		},
-	);
-
-	it.each([
-		[
-			"Editor",
-			"editor",
-			(path: string) => saveEditorComponentPatch({ enabled: false }, path),
-			(path: string) => saveEditorComponentPatch({ style: "opencode" }, path),
-			"opencode",
-		],
-		[
-			"User messages",
-			"userMessages",
-			(path: string) => saveUserMessagesComponentPatch({ enabled: false }, path),
-			(path: string) => saveUserMessagesComponentPatch({ style: "framed" }, path),
-			"framed",
-		],
-		[
-			"Selector borders",
-			"selectorBorders",
-			(path: string) => saveSelectorBordersComponentPatch({ enabled: false }, path),
-			(path: string) => saveSelectorBordersComponentPatch({ style: "zentui" }, path),
-			"zentui",
-		],
-		[
-			"Footer",
-			"footer",
-			(path: string) => saveFooterComponentPatch({ colorSource: "terminal" }, path),
-			(path: string) => saveFooterComponentPatch({ style: "starship" }, path),
-			"starship",
-		],
-	] as const)(
-		"preserves an unknown raw %s style until its owning style is explicitly selected",
-		(_label, owner, saveUnrelated, saveStyle, expectedStyle) => {
-			withConfig(
-				{
-					components: {
-						[owner]: {
-							style: `future-${owner}`,
-							futureOption: "keep",
-							styles: { future: { keep: true } },
-						},
-					},
-				},
-				(path) => {
-					const unrelatedConfig = saveUnrelated(path);
-					expect(hasUnsupportedComponentStyle(unrelatedConfig, owner)).toBe(true);
-					const preserved = readRaw(path);
-					expect(preserved.components[owner].style).toBe(`future-${owner}`);
-					expect(preserved.components[owner].futureOption).toBe("keep");
-					expect(preserved.components[owner].styles.future).toEqual({ keep: true });
-
-					const replacedConfig = saveStyle(path);
-					expect(hasUnsupportedComponentStyle(replacedConfig, owner)).toBe(false);
-					const replaced = readRaw(path);
-					expect(replaced.components[owner].style).toBe(expectedStyle);
-					expect(replaced.components[owner].futureOption).toBe("keep");
-					expect(replaced.components[owner].styles.future).toEqual({ keep: true });
-				},
-			);
-		},
-	);
-});
-
-describe("canonical snapshot persistence", () => {
-	it("materializes every component from legacy inputs and preserves unknown data", () => {
-		withConfig(
-			{
-				unknownTop: { keep: true },
-				features: { editor: false, copyFriendly: true },
-				colorSources: { editor: "terminal" },
-				components: {
-					futureDomain: { keep: true },
-					editor: {
-						futureComponent: true,
-						styles: {
-							futureStyle: { keep: true },
-							polished: { futurePolished: true },
-						},
-					},
-					footer: {
-						styles: {
-							starship: {
-								futureStarship: true,
-								pathDisplay: { futurePath: true },
-								extensionStatuses: { futureStatuses: true },
-							},
-						},
-					},
-				},
-			},
-			(path) => {
-				const config = saveEditorComponentPatch({ enabled: true }, path);
-				const raw = readRaw(path);
-				expect(Object.keys(raw.components)).toEqual(
-					expect.arrayContaining([
-						"editor",
-						"userMessages",
-						"workingLine",
-						"selectorBorders",
-						"footer",
-						"futureDomain",
-					]),
-				);
-				expect(raw.components.editor.enabled).toBe(true);
-				expect(raw.components.userMessages.enabled).toBe(false);
-				expect(raw.components.selectorBorders.enabled).toBe(false);
-				expect(raw.components.editor.style).toBe("opencode-copy-friendly");
-				expect(raw.components.userMessages.enabled).toBe(false);
-				expect(raw.components.editor.colorSource).toBe("terminal");
-				expect(raw.components.selectorBorders.colorSource).toBe("terminal");
-				expect(raw.features).toEqual({ editor: false, copyFriendly: true });
-				expect(raw.unknownTop).toEqual({ keep: true });
-				expect(raw.components.futureDomain).toEqual({ keep: true });
-				expect(raw.components.editor.futureComponent).toBe(true);
-				expect(raw.components.editor.styles.futureStyle).toEqual({ keep: true });
-				expect(raw.components.editor.styles.polished.futurePolished).toBe(true);
-				expect(raw.components.footer.styles.starship.futureStarship).toBe(true);
-				expect(raw.components.footer.styles.starship.pathDisplay.futurePath).toBe(true);
-				expect(raw.components.footer.styles.starship.extensionStatuses.futureStatuses).toBe(true);
-				expect(config).toEqual(mergeConfig(raw));
-			},
-		);
-	});
-
-	it("prevents legacy edits from recoupling surfaces after the first save", () => {
-		withConfig({ features: { editor: false, copyFriendly: true } }, (path) => {
-			saveEditorComponentPatch({ enabled: true }, path);
-			const raw = readRaw(path);
-			expect(raw.components.editor.enabled).toBe(true);
-			expect(raw.components.userMessages.enabled).toBe(false);
-			expect(raw.components.selectorBorders.enabled).toBe(false);
-			expect(raw.components.editor.style).toBe("opencode-copy-friendly");
-			expect(raw.components.userMessages.enabled).toBe(false);
-			raw.features.editor = true;
-			raw.features.copyFriendly = false;
-			writeFileSync(path, `${JSON.stringify(raw, null, 2)}\n`);
-			const reloaded = mergeConfig(readRaw(path));
-			expect(reloaded.components.editor.enabled).toBe(true);
-			expect(reloaded.components.userMessages.enabled).toBe(false);
-			expect(reloaded.components.selectorBorders.enabled).toBe(false);
-			expect(reloaded.components.editor.style).toBe("opencode-copy-friendly");
-			expect(reloaded.components.userMessages.enabled).toBe(false);
-		});
-	});
-
-	it("supports every typed component saver without discarding inactive styles", () => {
-		withConfig(undefined, (path) => {
-			savePolishedEditorStylePatch({ metadataFormat: "$provider", completionMenu: "native" }, path);
-			savePolishedCopyFriendlyEditorStylePatch(
-				{ metadataFormat: "$model", completionMenu: "palette" },
-				path,
-			);
-			saveAccentRailEditorStylePatch({ transparent: true }, path);
-			saveMinimalistEditorStylePatch({ showGit: false, contextGauge: true }, path);
-			saveUserMessagesComponentPatch({ enabled: false, colorSource: "terminal" }, path);
-			saveSelectorBordersComponentPatch({ enabled: false, colorSource: "terminal" }, path);
-			saveFooterComponentPatch({ style: "native", modelLabel: "name" }, path);
-			saveStarshipFooterStylePatch(
-				{ separator: "chevron", pathDisplay: { mode: "full", depth: 2 } },
-				path,
-			);
-			const config = mergeConfig(readRaw(path));
-			expect(config.components.editor.styles.opencode).toEqual({
-				metadataFormat: "$provider",
-				completionMenu: "native",
-			});
-			expect(config.components.editor.styles["opencode-copy-friendly"]).toEqual({
-				metadataFormat: "$model",
-				completionMenu: "palette",
-			});
-			expect(config.components.editor.styles["accent-rail"]).toMatchObject({
-				transparent: true,
-			});
-			expect(config.components.editor.styles.minimalist).toMatchObject({
-				showGit: false,
-				contextGauge: true,
-			});
-			expect(config.components.userMessages).toMatchObject({
-				enabled: false,
-				colorSource: "terminal",
-			});
-			expect(config.components.selectorBorders).toMatchObject({
-				enabled: false,
-				colorSource: "terminal",
-			});
-			expect(config.components.footer).toMatchObject({ style: "native", modelLabel: "name" });
-			expect(config.components.footer.styles.starship).toMatchObject({
-				separator: "chevron",
-				pathDisplay: { mode: "full", depth: 2 },
-			});
-		});
-	});
-
-	it("preserves stale fixed-editor keys during an unrelated explicit save", () => {
-		const stale = {
-			fixedEditor: { enabled: true, legacyUnknown: true },
-			layout: { fixedEditor: { mouseScroll: false }, futureLayout: true },
-		};
-		withConfig(stale, (path) => {
-			saveFooterComponentPatch({ style: "hidden" }, path);
-			const raw = readRaw(path);
-			expect(raw.fixedEditor).toEqual(stale.fixedEditor);
-			expect(raw.layout).toEqual(stale.layout);
-			expect(raw.components.footer.style).toBe("hidden");
-		});
-	});
-});
-
-describe("compatibility saver recipes", () => {
-	it("writes canonical paths only and updates all historically coupled destinations", () => {
-		withConfig(
-			{
-				features: { editor: true, statusLine: true, copyFriendly: false },
-				colorSources: { editor: "theme", starship: "theme", userMessages: "theme" },
-				editorModelLabel: "id",
-				footerFormat: "$legacy",
-				unknown: true,
-			},
-			(path) => {
-				const legacyBefore = structuredClone(readRaw(path));
-				saveColorSourcesPatch(
-					{ editor: "terminal", starship: "terminal", userMessages: "terminal" },
-					path,
-				);
-				saveUiFeaturesPatch({ editor: false, statusLine: false, viewportIndicators: false }, path);
-				saveEditorModelLabel("name", path);
-				saveEditorStyle("minimalist", path);
-				saveMinimalistPatch({ showTimer: false, showGit: false }, path);
-				saveEditorBorderColorMode("adaptive", path);
-				saveFooterFormatPatch("$cwd", path);
-				saveResponsiveFooterPatch(
-					{ responsiveFooter: false, compactFooterFormat: "$context", compactFooterMaxLines: 3 },
-					path,
-				);
-				saveSeparatorPatch("dot", path);
-				saveContextStylePatch("text+gauge", path);
-				saveContextThresholdsPatch({ warning: 45, error: 75 }, path);
-				savePathDisplayPatch({ mode: "full", depth: 3 }, path);
-				saveFooterSegmentsPatch({ modelInfo: true, tokens: false }, path);
-				saveGitBranchPatch({ maxLength: 24 }, path);
-				saveGitCommitPatch({ onlyDetached: false, showTag: false }, path);
-				saveGitMetricsPatch({ onlyNonzero: false, ignoreSubmodules: true }, path);
-				saveExtensionStatusDefaultPlacement("middle", path);
-				saveExtensionStatusPlacement("alpha", "left", path);
-				saveExtensionStatusColorMode("alpha", "original", path);
-				const raw = readRaw(path);
-				const config = mergeConfig(raw);
-				expect(raw.features).toEqual(legacyBefore.features);
-				expect(raw.colorSources).toEqual(legacyBefore.colorSources);
-				expect(raw.editorModelLabel).toBe("id");
-				expect(raw.footerFormat).toBe("$legacy");
-				expect(raw.unknown).toBe(true);
-				expect(raw).not.toHaveProperty("editorStyle");
-				expect(raw).not.toHaveProperty("editorStyles");
-				expect(config.components.editor).toMatchObject({
-					enabled: false,
-					style: "minimalist",
-					colorSource: "terminal",
-					borderColorMode: "adaptive",
-					modelLabel: "name",
-					viewportIndicators: false,
-				});
-				expect(config.components.userMessages).toMatchObject({
-					enabled: false,
-					colorSource: "terminal",
-				});
-				expect(config.components.selectorBorders).toMatchObject({
-					enabled: false,
-					colorSource: "terminal",
-				});
-				expect(config.components.editor.styles.minimalist).toMatchObject({
-					showTimer: false,
-					showGit: false,
-					contextThresholds: { warning: 45, error: 75 },
-				});
-				expect(config.components.footer).toMatchObject({
-					style: "native",
-					colorSource: "terminal",
-					modelLabel: "name",
-				});
-				expect(config.components.footer.styles.starship).toMatchObject({
-					format: "$cwd",
-					responsive: false,
-					compactFormat: "$context",
-					compactMaxLines: 3,
-					separator: "dot",
-					contextStyle: "text+gauge",
-					contextThresholds: { warning: 45, error: 75 },
-					pathDisplay: { mode: "full", depth: 3 },
-					segments: { modelInfo: true, tokens: false },
-					gitBranch: { maxLength: 24 },
-					gitCommit: { onlyDetached: false, showTag: false },
-					gitMetrics: { onlyNonzero: false, ignoreSubmodules: true },
-					extensionStatuses: {
-						defaultPlacement: "middle",
-						placements: { alpha: "left" },
-						colorModes: { alpha: "original" },
-					},
-				});
-			},
-		);
-	});
-
-	it("materializes a complete snapshot when a compatibility saver creates the file", () => {
-		withConfig(undefined, (path) => {
-			saveUiFeaturesPatch({ editor: false }, path);
-			const raw = readRaw(path);
-			expect(Object.keys(raw)).toEqual(["components"]);
-			expect(Object.keys(raw.components).sort()).toEqual([
-				"editor",
-				"footer",
-				"selectorBorders",
-				"userMessages",
-				"workingLine",
-			]);
-			expect(raw.components.editor.enabled).toBe(false);
-			expect(raw.components.userMessages.enabled).toBe(false);
-			expect(raw.components.selectorBorders.enabled).toBe(false);
-			expect(raw).not.toHaveProperty("features");
-		});
-	});
-});
-
-describe("mergeConfig", () => {
-	it("defaults project refresh polling to 30 seconds and Starship styles", () => {
-		const config = mergeConfig({});
-		expect(config.projectRefreshIntervalMs).toBe(30_000);
-		expect(config.icons.cacheHit).toBe("c");
-		expect(config.icons.editorPrompt).toBe("");
-		expect(config.colors.gitBranch).toBe("bold purple");
-		expect(config.colors.packageVersion).toBe("208");
-		expect(config.colors.gitCommit).toBe("bold green");
-		expect(config.colors.gitMetricsAdded).toBe("bold green");
-		expect(config.colors.gitMetricsDeleted).toBe("bold red");
-		expect(config.colors.sessionName).toBe("bold green");
-		expect(config.colors.contextNormal).toBe("bright-black");
-		expect(config.colors.tokens).toBe("bright-black");
-		expect(config.colors.extensionStatus).toBe("bright-black");
-		expect(config.colors.editorAccent).toBeUndefined();
-		expect(config.colors.editorRail).toBeUndefined();
-		expect(config.colors.editorPrompt).toBeUndefined();
-		expect(config.colors.editorBorder).toBeUndefined();
-		expect(config.colorSources).toEqual({
-			starship: "theme",
-			editor: "theme",
-			userMessages: "theme",
-		});
-		expect(config.features).toEqual({
-			editor: false,
-			statusLine: false,
-			viewportIndicators: false,
-		});
-		expect(config.footerSegments).toEqual({
-			cwd: true,
-			sessionName: true,
-			gitBranch: true,
-			gitStatus: true,
-			runtime: true,
-			modelInfo: false,
-			context: true,
-			gitCounts: false,
-			sessionDuration: false,
-			username: false,
-			time: false,
-			os: false,
-			packageVersion: false,
-			gitCommit: false,
-			gitMetrics: true,
-			tokens: true,
-			cost: true,
-		});
-		expect(config.extensionStatuses).toEqual({
-			defaultPlacement: "right",
-			placements: {},
-			colorModes: {},
-		});
-	});
-
-	it("registers the canonical telemetry variables without aliases", () => {
-		expect(FOOTER_FORMAT_VARIABLES).toEqual(
-			expect.arrayContaining(["cache_read", "cache_write", "subscription", "auto_compaction"]),
-		);
-		expect(FOOTER_FORMAT_VARIABLES).not.toContain("experimental");
-	});
-
-	it("defaults footerFormat to empty string", () => {
-		expect(mergeConfig({}).footerFormat).toBe("");
-		expect(defaultConfig.footerFormat).toBe("");
-	});
-
-	it("accepts a custom footerFormat string", () => {
-		expect(mergeConfig({ footerFormat: "$cwd on $git_branch $fill $cost" }).footerFormat).toBe(
-			"$cwd on $git_branch $fill $cost",
-		);
-	});
-
-	it("defaults and normalizes responsive footer settings", () => {
-		expect(DEFAULT_COMPACT_FOOTER_FORMAT).toBe(
-			"$cwd$wrap(in $session_name)$wrap(on $git_branch) $git_status$wrap$context$wrap_sep$tokens",
-		);
-		expect(mergeConfig({})).toMatchObject({
-			responsiveFooter: true,
-			compactFooterFormat: DEFAULT_COMPACT_FOOTER_FORMAT,
-			compactFooterMaxLines: "unlimited",
-		});
-		expect(
-			mergeConfig({
-				responsiveFooter: false,
-				compactFooterFormat: "$cwd$wrap$context",
-				compactFooterMaxLines: "unlimited",
-			}),
-		).toMatchObject({
-			responsiveFooter: false,
-			compactFooterFormat: "$cwd$wrap$context",
-			compactFooterMaxLines: "unlimited",
-		});
-		for (const compactFooterMaxLines of [1, 2, 3, "unlimited"] as const) {
-			expect(mergeConfig({ compactFooterMaxLines }).compactFooterMaxLines).toBe(
-				compactFooterMaxLines,
-			);
-		}
-		for (const value of [0, 4, "2", null, false]) {
-			expect(mergeConfig({ compactFooterMaxLines: value }).compactFooterMaxLines).toBe("unlimited");
-		}
-		expect(mergeConfig({ responsiveFooter: "false" }).responsiveFooter).toBe(true);
-		expect(mergeConfig({ compactFooterFormat: "" }).compactFooterFormat).toBe(
-			DEFAULT_COMPACT_FOOTER_FORMAT,
-		);
-	});
-
-	it("persists responsive footer patches without replacing unrelated keys", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-responsive-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			writeFileSync(path, JSON.stringify({ unknown: { keep: true }, footerFormat: "$cwd" }));
-			const config = saveResponsiveFooterPatch(
-				{ responsiveFooter: false, compactFooterMaxLines: 3 },
-				path,
-			);
-			const raw = JSON.parse(readFileSync(path, "utf8"));
-			expect(raw.unknown).toEqual({ keep: true });
-			expect(raw.footerFormat).toBe("$cwd");
-			expect(raw.components.footer.styles.starship).toMatchObject({
-				format: "$cwd",
-				responsive: false,
-				compactMaxLines: 3,
-			});
-			expect(config.responsiveFooter).toBe(false);
-			expect(config.compactFooterMaxLines).toBe(3);
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("defaults editorMetadataFormat and preserves non-empty strings", () => {
-		expect(defaultConfig.editorMetadataFormat).toBe(DEFAULT_EDITOR_METADATA_FORMAT);
-		for (const value of [undefined, null, 123, true, ""]) {
-			expect(mergeConfig({ editorMetadataFormat: value }).editorMetadataFormat).toBe(
-				DEFAULT_EDITOR_METADATA_FORMAT,
-			);
-		}
-		expect(mergeConfig({ editorMetadataFormat: "$model · $provider" }).editorMetadataFormat).toBe(
-			"$model · $provider",
-		);
-		expect(mergeConfig({ editorMetadataFormat: "   " }).editorMetadataFormat).toBe("   ");
-	});
-
-	it("ignores non-string footerFormat values", () => {
-		expect(mergeConfig({ footerFormat: 123 }).footerFormat).toBe("");
-		expect(mergeConfig({ footerFormat: null }).footerFormat).toBe("");
-		expect(mergeConfig({ footerFormat: true }).footerFormat).toBe("");
-	});
-
-	it("accepts custom project refresh intervals and 0 to disable polling", () => {
-		expect(mergeConfig({ projectRefreshIntervalMs: 60_000 }).projectRefreshIntervalMs).toBe(60_000);
-		expect(mergeConfig({ projectRefreshIntervalMs: 0 }).projectRefreshIntervalMs).toBe(0);
-	});
-
-	it("clamps short project refresh intervals up to 5 seconds", () => {
-		expect(mergeConfig({ projectRefreshIntervalMs: 100 }).projectRefreshIntervalMs).toBe(5_000);
-		expect(mergeConfig({ projectRefreshIntervalMs: 4_999 }).projectRefreshIntervalMs).toBe(5_000);
-		expect(mergeConfig({ projectRefreshIntervalMs: 5_000 }).projectRefreshIntervalMs).toBe(5_000);
-	});
-
-	it("ignores invalid project refresh intervals", () => {
-		expect(mergeConfig({ projectRefreshIntervalMs: "30000" }).projectRefreshIntervalMs).toBe(
-			30_000,
-		);
-		expect(
-			mergeConfig({ projectRefreshIntervalMs: Number.POSITIVE_INFINITY }).projectRefreshIntervalMs,
-		).toBe(30_000);
-	});
-
-	it("defaults separator style to none and accepts supported values", () => {
-		expect(mergeConfig({}).separator).toBe("none");
-		expect(defaultConfig.separator).toBe("none");
-		for (const separator of ["pipe", "dot", "chevron", "none"] as const) {
-			expect(mergeConfig({ separator }).separator).toBe(separator);
-		}
-	});
-
-	it("falls back to none for invalid separator styles", () => {
-		for (const separator of ["arrow", "", 123, null, true]) {
-			expect(mergeConfig({ separator }).separator).toBe("none");
-		}
-	});
-
-	it("saves separator style without erasing unknown config", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			writeFileSync(path, `${JSON.stringify({ unknown: true, contextStyle: "gauge" }, null, 2)}\n`);
-
-			const config = saveSeparatorPatch("chevron", path);
-			const raw = JSON.parse(readFileSync(path, "utf8"));
-
-			expect(config.separator).toBe("chevron");
-			expect(raw.unknown).toBe(true);
-			expect(raw.contextStyle).toBe("gauge");
-			expect(raw.separator).toBeUndefined();
-			expect(raw.components.footer.styles.starship).toMatchObject({
-				contextStyle: "gauge",
-				separator: "chevron",
-			});
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("defaults context style/thresholds and accepts valid overrides", () => {
-		expect(mergeConfig({}).contextStyle).toBe("text");
-		expect(mergeConfig({}).contextThresholds).toEqual({ warning: 70, error: 90 });
-		expect(mergeConfig({ contextStyle: "gauge" }).contextStyle).toBe("gauge");
-		expect(mergeConfig({ contextStyle: "text+gauge" }).contextStyle).toBe("text+gauge");
-		expect(mergeConfig({ contextStyle: "bars" }).contextStyle).toBe("text");
-		expect(
-			mergeConfig({ contextThresholds: { warning: 50, error: 80 } }).contextThresholds,
-		).toEqual({ warning: 50, error: 80 });
-		expect(
-			mergeConfig({ contextThresholds: { warning: 90, error: 70 } }).contextThresholds,
-		).toEqual({ warning: 70, error: 90 });
-	});
-
-	it("defaults editorModelLabel to name and accepts valid overrides", () => {
-		expect(mergeConfig({}).editorModelLabel).toBe("name");
-		expect(mergeConfig({ editorModelLabel: "name" }).editorModelLabel).toBe("name");
-		expect(mergeConfig({ editorModelLabel: "id" }).editorModelLabel).toBe("id");
-		expect(mergeConfig({ editorModelLabel: "title" }).editorModelLabel).toBe("name");
-	});
-
-	it("saves minimalist patches while preserving unknown nested config", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			writeFileSync(
-				path,
-				JSON.stringify({
-					unknownTop: true,
-					editorStyles: {
-						unknownStyle: { keep: true },
-						minimalist: { unknownNested: "keep", showGit: true },
-					},
-				}),
-			);
-			const config = saveMinimalistPatch(
-				{
-					pathDisplay: "full",
-					contextFormat: "percent-total",
-					showSessionName: false,
-					showGit: false,
-				},
-				path,
-			);
-			expect(config.editorStyles.minimalist.pathDisplay).toBe("full");
-			expect(config.editorStyles.minimalist.contextFormat).toBe("percent-total");
-			expect(config.editorStyles.minimalist.showSessionName).toBe(false);
-			expect(config.editorStyles.minimalist.showGit).toBe(false);
-			const raw = JSON.parse(readFileSync(path, "utf8"));
-			expect(raw).toMatchObject({
-				unknownTop: true,
-				editorStyles: {
-					unknownStyle: { keep: true },
-					minimalist: { unknownNested: "keep", showGit: true },
-				},
-			});
-			expect(raw.components.editor.styles.minimalist).toMatchObject({
-				pathDisplay: "full",
-				contextFormat: "percent-total",
-				showSessionName: false,
-				showGit: false,
-			});
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("saves editor style without erasing sibling config", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			writeFileSync(path, JSON.stringify({ unknown: { keep: true }, editorModelLabel: "name" }));
-			const minimalist = saveEditorStyle("minimalist", path);
-			let raw = JSON.parse(readFileSync(path, "utf8"));
-			expect(raw.unknown).toEqual({ keep: true });
-			expect(raw.editorModelLabel).toBe("name");
-			expect(raw.editorStyle).toBeUndefined();
-			expect(raw.components.editor.style).toBe("minimalist");
-			expect(minimalist.editorStyle).toBe("minimalist");
-
-			const accentRail = saveEditorStyle("accent-rail", path);
-			raw = JSON.parse(readFileSync(path, "utf8"));
-			expect(accentRail.editorStyle).toBe("accent-rail");
-			expect(raw.components.editor.style).toBe("accent-rail");
-			expect(raw.components.editor.styles["accent-rail"]).toEqual({
-				rail: "▎",
-				asciiRail: "|",
-				transparent: false,
-			});
-
-			const polished = saveEditorStyle("opencode", path);
-			raw = JSON.parse(readFileSync(path, "utf8"));
-			expect(polished.editorStyle).toBe("opencode");
-			expect(raw.unknown).toEqual({ keep: true });
-			expect(raw.editorModelLabel).toBe("name");
-			expect(raw.components.editor.style).toBe("opencode");
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("defaults and normalizes editor border color mode", () => {
-		expect(defaultConfig.editorBorderColorMode).toBe("adaptive");
-		expect(mergeConfig({}).editorBorderColorMode).toBe("adaptive");
-		expect(mergeConfig({ editorBorderColorMode: "static" }).editorBorderColorMode).toBe("static");
-		expect(mergeConfig({ editorBorderColorMode: "adaptive" }).editorBorderColorMode).toBe(
-			"adaptive",
-		);
-		for (const value of ["dynamic", "", 1, null, true]) {
-			expect(mergeConfig({ editorBorderColorMode: value }).editorBorderColorMode).toBe("adaptive");
-		}
-	});
-
-	it("saves editor border color mode without erasing sibling config", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			writeFileSync(
-				path,
-				`${JSON.stringify({ unknown: { keep: true }, editorModelLabel: "name" }, null, 2)}\n`,
-			);
-
-			const config = saveEditorBorderColorMode("adaptive", path);
-			const raw = JSON.parse(readFileSync(path, "utf8"));
-			expect(raw.unknown).toEqual({ keep: true });
-			expect(raw.editorModelLabel).toBe("name");
-			expect(raw.editorBorderColorMode).toBeUndefined();
-			expect(raw.components.editor.borderColorMode).toBe("adaptive");
-			expect(config.editorBorderColorMode).toBe("adaptive");
-			expect(config.editorModelLabel).toBe("name");
-			expect(configTempFiles(dir)).toEqual([]);
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("defaults pathDisplay and accepts mode/depth overrides", () => {
-		expect(mergeConfig({}).pathDisplay).toEqual({ mode: "basename", depth: 2 });
-		expect(mergeConfig({ pathDisplay: { mode: "full" } }).pathDisplay).toEqual({
-			mode: "full",
-			depth: 2,
-		});
-		expect(mergeConfig({ pathDisplay: { mode: "full", depth: 3 } }).pathDisplay).toEqual({
-			mode: "full",
-			depth: 3,
-		});
-		expect(mergeConfig({ pathDisplay: { mode: "repository", depth: 2 } }).pathDisplay).toEqual({
-			mode: "repository",
-			depth: 2,
-		});
-		expect(
-			mergeConfig({
-				components: { footer: { styles: { starship: { pathDisplay: { mode: "repository" } } } } },
-			}).components.footer.styles.starship.pathDisplay,
-		).toEqual({ mode: "repository", depth: 2 });
-		expect(mergeConfig({ pathDisplay: { mode: "fish", depth: -3 } }).pathDisplay).toEqual({
-			mode: "basename",
-			depth: 2,
-		});
-		expect(mergeConfig({ pathDisplay: { depth: 12.8 } }).pathDisplay).toEqual({
-			mode: "basename",
-			depth: 5,
-		});
-		expect(mergeConfig({ pathDisplay: "full" }).pathDisplay).toEqual({
-			mode: "basename",
-			depth: 2,
-		});
-		expect(
-			mergeConfig({ pathDisplay: { mode: "full", depth: Number.POSITIVE_INFINITY } }).pathDisplay,
-		).toEqual({ mode: "full", depth: 2 });
-	});
-
-	it("saves pathDisplay patches and keeps unknown keys", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			writeFileSync(
-				path,
-				`${JSON.stringify(
-					{
-						unknown: true,
-						pathDisplay: {
-							mode: "basename",
-							depth: 3,
-							futureKey: "future",
-						},
-					},
-					null,
-					2,
-				)}
-`,
-			);
-
-			const config = savePathDisplayPatch({ mode: "full" }, path);
-			const raw = JSON.parse(readFileSync(path, "utf8"));
-
-			expect(config.pathDisplay).toEqual({ mode: "full", depth: 3 });
-			expect(raw.unknown).toBe(true);
-			expect(raw.pathDisplay).toEqual({
-				mode: "basename",
-				depth: 3,
-				futureKey: "future",
-			});
-			expect(raw.components.footer.styles.starship.pathDisplay).toEqual({
-				mode: "full",
-				depth: 3,
-			});
-
-			const depthConfig = savePathDisplayPatch({ depth: 1 }, path);
-			expect(depthConfig.pathDisplay).toEqual({ mode: "full", depth: 1 });
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("defaults git branch length to full and accepts positive integer values", () => {
-		expect(mergeConfig({}).gitBranch).toEqual({ maxLength: "full" });
-		expect(defaultConfig.gitBranch).toEqual({ maxLength: "full" });
-		for (const maxLength of [1, 10, 17, 20, 30, 40, 50, 10_000]) {
-			expect(mergeConfig({ gitBranch: { maxLength } }).gitBranch).toEqual({ maxLength });
-		}
-		expect(mergeConfig({ gitBranch: { maxLength: "full" } }).gitBranch).toEqual({
-			maxLength: "full",
-		});
-	});
-
-	it("falls back to full for invalid git branch lengths", () => {
-		for (const maxLength of [0, -1, 1.5, "10", "short", null, true]) {
-			expect(mergeConfig({ gitBranch: { maxLength } }).gitBranch).toEqual({
-				maxLength: "full",
-			});
-		}
-		expect(mergeConfig({ gitBranch: 20 }).gitBranch).toEqual({ maxLength: "full" });
-	});
-
-	it("saves git branch length without erasing unknown config", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			writeFileSync(
-				path,
-				`${JSON.stringify({ unknown: true, gitBranch: { maxLength: 17, future: true } }, null, 2)}\n`,
-			);
-
-			const config = saveGitBranchPatch({ maxLength: 30 }, path);
-			const raw = JSON.parse(readFileSync(path, "utf8"));
-			expect(config.gitBranch).toEqual({ maxLength: 30 });
-			expect(raw.unknown).toBe(true);
-			expect(raw.gitBranch).toEqual({ maxLength: 17, future: true });
-			expect(raw.components.footer.styles.starship.gitBranch).toEqual({ maxLength: 30 });
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("defaults icon mode to ascii and accepts nerd/ascii", () => {
-		expect(mergeConfig({}).icons.mode).toBe("ascii");
-		expect(mergeConfig({ icons: { mode: "ascii" } }).icons.mode).toBe("ascii");
-		expect(mergeConfig({ icons: { mode: "nerd" } }).icons.mode).toBe("nerd");
-		expect(mergeConfig({ icons: { mode: "emoji" } }).icons.mode).toBe("ascii");
-		expect(mergeConfig({ icons: { mode: "ascii" } }).icons.cwd).toBe("");
-		expect(mergeConfig({ icons: { mode: "ascii", cwd: "DIR" } }).icons.cwd).toBe("DIR");
-	});
-
-	it("accepts Starship colors and old color key aliases", () => {
-		expect(mergeConfig({ colors: { gitBranch: "bold purple" } }).colors.gitBranch).toBe(
-			"bold purple",
-		);
-		expect(mergeConfig({ colors: { packageVersion: "bold green" } }).colors.packageVersion).toBe(
-			"bold green",
-		);
-		expect(mergeConfig({ colors: { gitCommit: "bold yellow" } }).colors.gitCommit).toBe(
-			"bold yellow",
-		);
-		expect(mergeConfig({ colors: { gitMetricsAdded: "green" } }).colors.gitMetricsAdded).toBe(
-			"green",
-		);
-		expect(mergeConfig({ colors: { gitMetricsDeleted: "red" } }).colors.gitMetricsDeleted).toBe(
-			"red",
-		);
-		expect(mergeConfig({ colors: { git: "syntaxKeyword" } }).colors.gitBranch).toBe(
-			"syntaxKeyword",
-		);
-		expect(mergeConfig({ colors: { extensionStatus: "warning" } }).colors.extensionStatus).toBe(
-			"warning",
-		);
-		expect(mergeConfig({ colors: { extensionStatus: "neon" } }).colors.extensionStatus).toBe(
-			defaultConfig.colors.extensionStatus,
-		);
-	});
-
-	it("accepts extension status placement and color mode config", () => {
-		const config = mergeConfig({
-			extensionStatuses: {
-				defaultPlacement: "middle",
-				placements: {
-					alpha: "left",
-					beta: "off",
-					gamma: "right",
-				},
-				colorModes: {
-					alpha: "original",
-					beta: "zentui",
-				},
-			},
-		});
-
-		expect(config.extensionStatuses).toEqual({
-			defaultPlacement: "middle",
-			placements: {
-				alpha: "left",
-				beta: "off",
-				gamma: "right",
-			},
-			colorModes: {
-				alpha: "original",
-				beta: "zentui",
-			},
-		});
-	});
-
-	it("normalizes invalid extension status placement config", () => {
-		expect(
-			mergeConfig({
-				extensionStatuses: {
-					defaultPlacement: "center",
-					placements: {
-						alpha: "left",
-						beta: "center",
-						gamma: 1,
-					},
-					colorModes: {
-						alpha: "original",
-						beta: "muted",
-						gamma: 1,
-					},
-				},
-			}).extensionStatuses,
-		).toEqual({
-			defaultPlacement: "right",
-			placements: { alpha: "left" },
-			colorModes: { alpha: "original" },
-		});
-		expect(mergeConfig({ extensionStatuses: { placements: "none" } }).extensionStatuses).toEqual({
-			defaultPlacement: "right",
-			placements: {},
-			colorModes: {},
-		});
-	});
-
-	it("accepts optional editor and user-message chrome color overrides", () => {
-		const config = mergeConfig({
-			colors: {
-				editorAccent: "bold purple",
-				editorBorder: "#89b4fa",
-				editorModel: "accent",
-				editorProvider: "text",
-				editorThinking: "muted",
-				editorThinkingMinimal: "thinkingMinimal",
-				editorThinkingLow: "thinkingLow",
-				editorThinkingMedium: "thinkingMedium",
-				editorThinkingHigh: "thinkingHigh",
-				editorThinkingXhigh: "thinkingXhigh",
-				editorThinkingMax: "thinkingMax",
-			},
-		});
-
-		expect(config.colors.editorAccent).toBe("bold purple");
-		expect(config.colors.editorBorder).toBe("#89b4fa");
-		expect(config.colors.editorModel).toBe("accent");
-		expect(config.colors.editorProvider).toBe("text");
-		expect(config.colors.editorThinking).toBe("muted");
-		expect(config.colors.editorThinkingMinimal).toBe("thinkingMinimal");
-		expect(config.colors.editorThinkingLow).toBe("thinkingLow");
-		expect(config.colors.editorThinkingMedium).toBe("thinkingMedium");
-		expect(config.colors.editorThinkingHigh).toBe("thinkingHigh");
-		expect(config.colors.editorThinkingXhigh).toBe("thinkingXhigh");
-		expect(config.colors.editorThinkingMax).toBe("thinkingMax");
-	});
-
-	it("ignores invalid known values at runtime instead of trusting zentui.json", () => {
-		const config = mergeConfig({
-			projectRefreshIntervalMs: "fast",
-			icons: {
-				cwd: 42,
-				git: "git",
-				cacheHit: "CH",
-				editorPrompt: ">",
-			},
-			colors: {
-				cwd: 123,
-				gitStatus: "not-a-color",
-				separator: "dimmed",
-				editorAccent: "neon",
-				editorPrompt: "accent",
-				editorBorder: "also-neon",
-				editorThinkingHigh: "thinkingHigh",
-			},
-			colorSources: {
-				starship: "neon",
-				editor: "terminal",
-			},
-		});
-
-		expect(config.projectRefreshIntervalMs).toBe(defaultConfig.projectRefreshIntervalMs);
-		expect(config.icons.cwd).toBe(defaultConfig.icons.cwd);
-		expect(config.icons.git).toBe("git");
-		expect(config.icons.cacheHit).toBe("CH");
-		expect(config.icons.editorPrompt).toBe(">");
-		expect(config.colors.cwd).toBe(defaultConfig.colors.cwd);
-		expect(config.colors.gitStatus).toBe(defaultConfig.colors.gitStatus);
-		expect(config.colors.separator).toBe("dimmed");
-		expect(config.colors.editorAccent).toBeUndefined();
-		expect(config.colors.editorPrompt).toBe("accent");
-		expect(config.colors.editorBorder).toBeUndefined();
-		expect(config.colors.editorThinkingHigh).toBe("thinkingHigh");
-		expect(config.colorSources).toEqual({
-			starship: "theme",
-			editor: "terminal",
-			userMessages: "theme",
-		});
-	});
-
-	it("accepts valid color source preferences and ignores invalid values", () => {
-		expect(
-			mergeConfig({ colorSources: { starship: "terminal", editor: "theme" } }).colorSources,
-		).toEqual({ starship: "terminal", editor: "theme", userMessages: "theme" });
-		expect(
-			mergeConfig({ colorSources: { starship: "neon", userMessages: "terminal" } }).colorSources,
-		).toEqual({ starship: "theme", editor: "theme", userMessages: "terminal" });
-	});
-
-	it("accepts valid UI feature preferences and ignores invalid values", () => {
-		expect(mergeConfig({ features: { editor: false } }).features).toEqual({
-			editor: false,
-			statusLine: false,
-			viewportIndicators: false,
-		});
-		expect(
-			mergeConfig({
-				features: {
-					editor: "off",
-					statusLine: false,
-					copyFriendly: true,
-					viewportIndicators: false,
-				},
-			}).features,
-		).toEqual({
-			editor: false,
-			statusLine: false,
-			viewportIndicators: false,
-		});
-		expect(
-			mergeConfig({ features: { copyFriendly: "on", viewportIndicators: "off" } }).features,
-		).toEqual({ editor: false, statusLine: false, viewportIndicators: false });
-	});
-
-	it("accepts valid footer segment preferences and ignores invalid values", () => {
-		expect(
-			mergeConfig({ footerSegments: { cwd: false, modelInfo: true, tokens: false } })
-				.footerSegments,
-		).toEqual({
-			cwd: false,
-			sessionName: true,
-			gitBranch: true,
-			gitStatus: true,
-			runtime: true,
-			modelInfo: true,
-			context: true,
-			gitCounts: false,
-			sessionDuration: false,
-			username: false,
-			time: false,
-			os: false,
-			packageVersion: false,
-			gitCommit: false,
-			gitMetrics: true,
-			tokens: false,
-			cost: true,
-		});
-		expect(
-			mergeConfig({
-				footerSegments: { cost: "off", gitBranch: false, gitStatus: false, modelInfo: "on" },
-			}).footerSegments,
-		).toEqual({
-			cwd: true,
-			sessionName: true,
-			gitBranch: false,
-			gitStatus: false,
-			runtime: true,
-			modelInfo: false,
-			context: true,
-			gitCounts: false,
-			sessionDuration: false,
-			username: false,
-			time: false,
-			os: false,
-			packageVersion: false,
-			gitCommit: false,
-			gitMetrics: true,
-			tokens: true,
-			cost: true,
-		});
-	});
-
-	it("normalizes session-name preferences", () => {
-		expect(mergeConfig({ colors: { sessionName: "success" } }).colors.sessionName).toBe("success");
-		expect(mergeConfig({ footerSegments: { sessionName: false } }).footerSegments.sessionName).toBe(
-			false,
-		);
-		expect(mergeConfig({ colors: { sessionName: "not-a-color" } }).colors.sessionName).toBe(
-			"bold green",
-		);
-		expect(mergeConfig({ footerSegments: { sessionName: "on" } }).footerSegments.sessionName).toBe(
-			true,
-		);
-	});
-
-	it("saves color source patches without erasing unknown user config", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			writeFileSync(
-				path,
-				`${JSON.stringify(
-					{
-						unknown: true,
-						icons: { git: "git" },
-						colors: {
-							futureKey: "future",
-							cwd: "bold cyan",
-							gitBranch: "syntaxKeyword",
-							cost: "success",
-						},
-						colorSources: { editor: "terminal" },
-					},
-					null,
-					2,
-				)}\n`,
-			);
-
-			const config = saveColorSourcesPatch({ starship: "terminal" }, path);
-			const raw = JSON.parse(readFileSync(path, "utf8"));
-
-			expect(config.colorSources).toEqual({
-				starship: "terminal",
-				editor: "terminal",
-				userMessages: "theme",
-			});
-			expect(raw.unknown).toBe(true);
-			expect(raw.icons.git).toBe("git");
-			expect(raw.colors.cwd).toBe("bold cyan");
-			expect(raw.colors.futureKey).toBe("future");
-			expect(raw.colors.gitBranch).toBe("syntaxKeyword");
-			expect(raw.colors.cost).toBe("success");
-			expect(raw.colorSources).toEqual({ editor: "terminal" });
-			expect(raw.components.footer.colorSource).toBe("terminal");
-			expect(raw.components.editor.colorSource).toBe("terminal");
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("preserves invalid and unknown color source data on disk while normalizing runtime", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			writeFileSync(
-				path,
-				`${JSON.stringify(
-					{
-						colorSources: {
-							starship: "neon",
-							editor: "terminal",
-							userMessages: "invalid",
-							extra: "terminal",
-						},
-					},
-					null,
-					2,
-				)}\n`,
-			);
-
-			const config = saveColorSourcesPatch({ userMessages: "terminal" }, path);
-			const raw = JSON.parse(readFileSync(path, "utf8"));
-
-			expect(config.colorSources).toEqual({
-				starship: "theme",
-				editor: "terminal",
-				userMessages: "terminal",
-			});
-			expect(raw.colorSources).toEqual({
-				starship: "neon",
-				editor: "terminal",
-				userMessages: "invalid",
-				extra: "terminal",
-			});
-			expect(raw.components.userMessages.colorSource).toBe("terminal");
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("writes only the requested settings when creating zentui.json", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			const config = saveColorSourcesPatch({ starship: "terminal" }, path);
-			const raw = JSON.parse(readFileSync(path, "utf8"));
-
-			expect(config.colorSources).toEqual({
-				starship: "terminal",
-				editor: "theme",
-				userMessages: "theme",
-			});
-			expect(Object.keys(raw)).toEqual(["components"]);
-			expect(raw.components.footer.colorSource).toBe("terminal");
-			expect(raw.components.editor.colorSource).toBe("theme");
-			expect(raw.components.userMessages.colorSource).toBe("theme");
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("saves UI feature patches without erasing unknown user config", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			writeFileSync(
-				path,
-				`${JSON.stringify(
-					{
-						unknown: true,
-						features: {
-							editor: true,
-							futureKey: "future",
-						},
-					},
-					null,
-					2,
-				)}\n`,
-			);
-
-			const config = saveUiFeaturesPatch({ statusLine: false, viewportIndicators: false }, path);
-			const raw = JSON.parse(readFileSync(path, "utf8"));
-
-			expect(config.features).toEqual({
-				editor: true,
-				statusLine: false,
-				viewportIndicators: false,
-			});
-			expect(raw.unknown).toBe(true);
-			expect(raw.features).toEqual({ editor: true, futureKey: "future" });
-			expect(raw.components.editor.enabled).toBe(true);
-			expect(raw.components.editor.viewportIndicators).toBe(false);
-			expect(raw.components.footer.style).toBe("native");
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("writes only the requested UI feature setting when creating zentui.json", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			const config = saveUiFeaturesPatch({ editor: false }, path);
-			const raw = JSON.parse(readFileSync(path, "utf8"));
-
-			expect(config.features).toEqual({
-				editor: false,
-				statusLine: false,
-				viewportIndicators: false,
-			});
-			expect(Object.keys(raw)).toEqual(["components"]);
-			expect(raw.components.editor.enabled).toBe(false);
-			expect(raw.components.userMessages.enabled).toBe(false);
-			expect(raw.components.selectorBorders.enabled).toBe(false);
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("saves footer segment patches without erasing unknown user config", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			writeFileSync(
-				path,
-				`${JSON.stringify(
-					{
-						unknown: true,
-						footerSegments: {
-							cwd: true,
-							futureKey: "future",
-						},
-					},
-					null,
-					2,
-				)}\n`,
-			);
-
-			const config = saveFooterSegmentsPatch({ modelInfo: true, tokens: false, cost: false }, path);
-			const raw = JSON.parse(readFileSync(path, "utf8"));
-
-			expect(config.footerSegments).toEqual({
-				cwd: true,
-				sessionName: true,
-				gitBranch: true,
-				gitStatus: true,
-				runtime: true,
-				modelInfo: true,
-				context: true,
-				gitCounts: false,
-				sessionDuration: false,
-				username: false,
-				time: false,
-				os: false,
-				packageVersion: false,
-				gitCommit: false,
-				gitMetrics: true,
-				tokens: false,
-				cost: false,
-			});
-			expect(raw.unknown).toBe(true);
-			expect(raw.footerSegments).toEqual({ cwd: true, futureKey: "future" });
-			expect(raw.components.footer.styles.starship.segments).toMatchObject({
-				cwd: true,
-				modelInfo: true,
-				tokens: false,
-				cost: false,
-			});
-			expect(mergeConfig(raw).footerSegments.modelInfo).toBe(true);
-
-			const disabled = saveFooterSegmentsPatch({ modelInfo: false }, path);
-			const disabledRaw = JSON.parse(readFileSync(path, "utf8"));
-			expect(disabled.footerSegments.modelInfo).toBe(false);
-			expect(mergeConfig(disabledRaw).footerSegments.modelInfo).toBe(false);
-			expect(disabledRaw.unknown).toBe(true);
-			expect(disabledRaw.footerSegments).toEqual({ cwd: true, futureKey: "future" });
-			expect(disabledRaw.components.footer.styles.starship.segments).toMatchObject({
-				modelInfo: false,
-				tokens: false,
-				cost: false,
-			});
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("writes only the requested footer segment setting when creating zentui.json", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			const config = saveFooterSegmentsPatch({ runtime: false }, path);
-			const raw = JSON.parse(readFileSync(path, "utf8"));
-
-			expect(config.footerSegments).toEqual({
-				cwd: true,
-				sessionName: true,
-				gitBranch: true,
-				gitStatus: true,
-				runtime: false,
-				modelInfo: false,
-				context: true,
-				gitCounts: false,
-				sessionDuration: false,
-				username: false,
-				time: false,
-				os: false,
-				packageVersion: false,
-				gitCommit: false,
-				gitMetrics: true,
-				tokens: true,
-				cost: true,
-			});
-			expect(Object.keys(raw)).toEqual(["components"]);
-			expect(raw.components.footer.styles.starship.segments.runtime).toBe(false);
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("toggles and persists the packageVersion footer segment", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			const config = saveFooterSegmentsPatch({ packageVersion: true }, path);
-			expect(config.footerSegments.packageVersion).toBe(true);
-
-			const raw = JSON.parse(readFileSync(path, "utf8"));
-			expect(raw.components.footer.styles.starship.segments.packageVersion).toBe(true);
-
-			const reloaded = mergeConfig(raw);
-			expect(reloaded.footerSegments.packageVersion).toBe(true);
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("toggles and persists gitCommit and gitMetrics footer segments", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			const config = saveFooterSegmentsPatch({ gitCommit: true, gitMetrics: true }, path);
-			expect(config.footerSegments.gitCommit).toBe(true);
-			expect(config.footerSegments.gitMetrics).toBe(true);
-
-			const raw = JSON.parse(readFileSync(path, "utf8"));
-			expect(raw.components.footer.styles.starship.segments).toMatchObject({
-				gitCommit: true,
-				gitMetrics: true,
-			});
-
-			const reloaded = mergeConfig(raw);
-			expect(reloaded.footerSegments.gitCommit).toBe(true);
-			expect(reloaded.footerSegments.gitMetrics).toBe(true);
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("gitCommit config defaults and normalizes hashLength", () => {
-		expect(defaultConfig.gitCommit).toEqual({ hashLength: 7, onlyDetached: true, showTag: true });
-		expect(mergeConfig({ gitCommit: { hashLength: 3 } }).gitCommit.hashLength).toBe(4);
-		expect(mergeConfig({ gitCommit: { hashLength: 100 } }).gitCommit.hashLength).toBe(40);
-		expect(mergeConfig({ gitCommit: { hashLength: 10 } }).gitCommit.hashLength).toBe(10);
-		expect(mergeConfig({ gitCommit: { onlyDetached: false } }).gitCommit.onlyDetached).toBe(false);
-		expect(mergeConfig({ gitCommit: { showTag: false } }).gitCommit.showTag).toBe(false);
-		// Missing fields fall back to defaults.
-		expect(mergeConfig({ gitCommit: {} }).gitCommit).toEqual({
-			hashLength: 7,
-			onlyDetached: true,
-			showTag: true,
-		});
-	});
-
-	it("gitMetrics config defaults", () => {
-		expect(defaultConfig.gitMetrics).toEqual({ onlyNonzero: true, ignoreSubmodules: false });
-		expect(mergeConfig({ gitMetrics: { onlyNonzero: false } }).gitMetrics.onlyNonzero).toBe(false);
-		expect(
-			mergeConfig({ gitMetrics: { ignoreSubmodules: true } }).gitMetrics.ignoreSubmodules,
-		).toBe(true);
-	});
-
-	it("writes and reads back footerFormat", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			const config = saveFooterFormatPatch("$cwd on $git_branch $fill $cost", path);
-			const raw = JSON.parse(readFileSync(path, "utf8"));
-
-			expect(config.footerFormat).toBe("$cwd on $git_branch $fill $cost");
-			expect(Object.keys(raw)).toEqual(["components"]);
-			expect(raw.components.footer.styles.starship.format).toBe("$cwd on $git_branch $fill $cost");
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("clears footerFormat when saving empty string", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			const config = saveFooterFormatPatch("", path);
-			expect(config.footerFormat).toBe("");
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("saves extension status placement when creating zentui.json", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			const config = saveExtensionStatusPlacement("plugin.key", "middle", path);
-			const raw = JSON.parse(readFileSync(path, "utf8"));
-
-			expect(config.extensionStatuses.placements).toEqual({ "plugin.key": "middle" });
-			expect(Object.keys(raw)).toEqual(["components"]);
-			expect(raw.components.footer.styles.starship.extensionStatuses.placements).toEqual({
-				"plugin.key": "middle",
-			});
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("saves extension status color mode when creating zentui.json", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			const config = saveExtensionStatusColorMode("plugin.key", "original", path);
-			const raw = JSON.parse(readFileSync(path, "utf8"));
-
-			expect(config.extensionStatuses.colorModes).toEqual({ "plugin.key": "original" });
-			expect(Object.keys(raw)).toEqual(["components"]);
-			expect(raw.components.footer.styles.starship.extensionStatuses.colorModes).toEqual({
-				"plugin.key": "original",
-			});
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("saves extension status color mode without erasing placement config", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			writeFileSync(
-				path,
-				`${JSON.stringify(
-					{
-						unknown: true,
-						colors: { futureKey: "future" },
-						extensionStatuses: {
-							defaultPlacement: "left",
-							futureKey: "future",
-							placements: {
-								alpha: "right",
-								invalid: "center",
-							},
-							colorModes: {
-								alpha: "zentui",
-								invalid: "muted",
-							},
-						},
-					},
-					null,
-					2,
-				)}\n`,
-			);
-
-			const config = saveExtensionStatusColorMode("beta", "original", path);
-			const raw = JSON.parse(readFileSync(path, "utf8"));
-
-			expect(config.extensionStatuses).toEqual({
-				defaultPlacement: "left",
-				placements: { alpha: "right" },
-				colorModes: { alpha: "zentui", beta: "original" },
-			});
-			expect(raw.unknown).toBe(true);
-			expect(raw.colors.futureKey).toBe("future");
-			expect(raw.extensionStatuses.futureKey).toBe("future");
-			expect(raw.extensionStatuses.placements).toEqual({
-				alpha: "right",
-				invalid: "center",
-			});
-			expect(raw.extensionStatuses.colorModes).toEqual({
-				alpha: "zentui",
-				invalid: "muted",
-			});
-			expect(raw.components.footer.styles.starship.extensionStatuses.colorModes).toEqual({
-				alpha: "zentui",
-				beta: "original",
-			});
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("saves extension status placement without erasing unknown user config", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			writeFileSync(
-				path,
-				`${JSON.stringify(
-					{
-						unknown: true,
-						colors: { futureKey: "future" },
-						extensionStatuses: {
-							defaultPlacement: "left",
-							futureKey: "future",
-							placements: {
-								alpha: "right",
-								invalid: "center",
-							},
-						},
-					},
-					null,
-					2,
-				)}\n`,
-			);
-
-			const config = saveExtensionStatusPlacement("beta", "off", path);
-			const raw = JSON.parse(readFileSync(path, "utf8"));
-
-			expect(config.extensionStatuses).toEqual({
-				defaultPlacement: "left",
-				placements: { alpha: "right", beta: "off" },
-				colorModes: {},
-			});
-			expect(raw.unknown).toBe(true);
-			expect(raw.colors.futureKey).toBe("future");
-			expect(raw.extensionStatuses.futureKey).toBe("future");
-			expect(raw.extensionStatuses.placements).toEqual({
-				alpha: "right",
-				invalid: "center",
-			});
-			expect(raw.components.footer.styles.starship.extensionStatuses.placements).toEqual({
-				alpha: "right",
-				beta: "off",
-			});
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-});
-
-describe("renderTerminalStyle", () => {
-	it("renders Starship bold green with terminal palette ANSI codes", () => {
-		expect(renderTerminalStyle("bold green", " v22.0.0")).toBe("\u001b[1;32m v22.0.0\u001b[0m");
-	});
-
-	it("supports 256-color, fg/bg aliases, dimmed, and Starship hex styles", () => {
-		expect(renderTerminalStyle("bold 149", "C")).toBe("\u001b[1;38;5;149mC\u001b[0m");
-		expect(renderTerminalStyle("bold fg:202", "Haxe")).toBe("\u001b[1;38;5;202mHaxe\u001b[0m");
-		expect(renderTerminalStyle("red dimmed", "Java")).toBe("\u001b[31;2mJava\u001b[0m");
-		expect(renderTerminalStyle("bg:blue fg:bright-green", "ok")).toBe("\u001b[44;92mok\u001b[0m");
-		expect(renderTerminalStyle("bold #FFAFF3", "Gleam")).toBe(
-			"\u001b[1;38;2;255;175;243mGleam\u001b[0m",
-		);
-	});
-});
-
-describe("style rendering", () => {
-	const theme = {
-		fg(token: string, text: string) {
-			return `<${token}>${text}</${token}>`;
-		},
-	};
-
-	it("uses theme tokens when provided to colorize", () => {
-		expect(colorize(theme, "accent", "hello")).toBe("<accent>hello</accent>");
-	});
-
-	it("falls back to plain text for invalid theme tokens", () => {
-		const throwingTheme = {
-			fg(token: string, text: string) {
-				if (token === "text") return `<text>${text}</text>`;
-				throw new Error(`Unknown color: ${token}`);
-			},
-		};
-
-		expect(colorize(throwingTheme, "doesNotExist", "hello")).toBe("hello");
-		expect(renderStyle(throwingTheme, "doesNotExist", "hello")).toBe("hello");
-		expect(renderStyleForSource(throwingTheme, "theme", "doesNotExist", "hello")).toBe("hello");
-	});
-
-	it("maps Starship modifiers to safe theme colors when the theme rejects unknown tokens", () => {
-		const strictTheme = {
-			fg(token: string, text: string) {
-				if (!["muted", "syntaxKeyword", "text"].includes(token)) {
-					throw new Error(`Unknown theme color: ${token}`);
-				}
-				return `<${token}>${text}</${token}>`;
-			},
-			bold(text: string) {
-				return `<bold>${text}</bold>`;
-			},
-		};
-
-		expect(renderStyleForSource(strictTheme, "theme", "dimmed", "tokens")).toBe(
-			"<muted>tokens</muted>",
-		);
-		expect(renderStyleForSource(strictTheme, "theme", "bold purple", "git")).toBe(
-			"<syntaxKeyword><bold>git</bold></syntaxKeyword>",
-		);
-		expect(renderStyleForSource(strictTheme, "theme", "unknownColor", "text")).toBe("text");
-	});
-
-	it("supports hex colors", () => {
-		expect(colorize(theme, "#89b4fa", "hello")).toBe("\u001b[38;2;137;180;250mhello\u001b[39m");
-	});
-
-	it("supports short #rgb hex colors by expanding to rrggbb", () => {
-		expect(colorize(theme, "#89b", "hello")).toBe("\u001b[38;2;136;153;187mhello\u001b[39m");
-		expect(renderTerminalStyle("bold #89b", "x")).toBe("\u001b[1;38;2;136;153;187mx\u001b[0m");
-	});
-
-	it("renders Starship styles before falling back to theme tokens", () => {
-		expect(renderStyle(theme, "bold purple", "git")).toBe("\u001b[1;35mgit\u001b[0m");
-		expect(renderStyle(theme, "syntaxKeyword", "git")).toBe("<syntaxKeyword>git</syntaxKeyword>");
-	});
-
-	it("renders theme-source Starship colors through Pi theme tokens", () => {
-		expect(renderStyleForSource(theme, "theme", "bold cyan", "cwd")).toBe(
-			"<syntaxFunction>cwd</syntaxFunction>",
-		);
-		expect(renderStyleForSource(theme, "theme", "bold purple", "git")).toBe(
-			"<syntaxKeyword>git</syntaxKeyword>",
-		);
-		expect(renderStyleForSource(theme, "theme", "bold red", "!")).toBe("<error>!</error>");
-		expect(renderStyleForSource(theme, "theme", "dimmed", "tokens")).toBe("<muted>tokens</muted>");
-		expect(renderStyleForSource(theme, "theme", "bold green", "cost")).toBe(
-			"<success>cost</success>",
-		);
-		expect(renderStyleForSource(theme, "theme", "syntaxKeyword", "git")).toBe(
-			"<syntaxKeyword>git</syntaxKeyword>",
-		);
-	});
-
-	it("keeps explicit terminal styles available for terminal source", () => {
-		expect(renderStyleForSource(theme, "terminal", "bold purple", "git")).toBe(
-			"\u001b[1;35mgit\u001b[0m",
-		);
-		expect(renderStyleForSource(theme, "theme", "fg:202", "git")).toBe(
-			"\u001b[38;5;202mgit\u001b[0m",
-		);
-	});
-
-	it("renders theme borders with borderMuted and terminal borders with bright black", () => {
-		const thinkingTheme = {
-			fg(token: string, text: string) {
-				return `<${token}>${text}</${token}>`;
-			},
-		};
-
-		expect(renderChromeBorder(thinkingTheme, "theme", "bright-black", "────")).toBe(
-			"<borderMuted>────</borderMuted>",
-		);
-		expect(renderChromeBorder(thinkingTheme, "terminal", "bright-black", "────")).toBe(
-			"\u001b[90m────\u001b[0m",
-		);
-	});
-});
-
-describe("bounded settings persistence", () => {
-	function withConfig(initial: Record<string, unknown>, assertions: (path: string) => void): void {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-bounded-config-"));
-		const path = join(dir, "zentui.json");
-		try {
-			writeFileSync(path, `${JSON.stringify(initial, null, 2)}\n`);
-			assertions(path);
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	}
-
-	it("saves editorModelLabel while preserving unrelated root config", () => {
-		withConfig({ editorModelLabel: "id", unknown: { keep: true } }, (path) => {
-			const config = saveEditorModelLabel("name", path);
-			const raw = JSON.parse(readFileSync(path, "utf8"));
-			expect(config.editorModelLabel).toBe("name");
-			expect(raw.editorModelLabel).toBe("id");
-			expect(raw.unknown).toEqual({ keep: true });
-			expect(raw.components.editor.modelLabel).toBe("name");
-			expect(raw.components.footer.modelLabel).toBe("name");
-		});
-	});
-
-	it("saves git commit booleans while preserving hashLength and unknown siblings", () => {
-		withConfig(
-			{
-				unknown: true,
-				gitCommit: { hashLength: 12, onlyDetached: true, showTag: true, future: "keep" },
-			},
-			(path) => {
-				const config = saveGitCommitPatch({ onlyDetached: false, showTag: false }, path);
-				const raw = JSON.parse(readFileSync(path, "utf8"));
-				expect(config.gitCommit).toEqual({ hashLength: 12, onlyDetached: false, showTag: false });
-				expect(raw.gitCommit).toEqual({
-					hashLength: 12,
-					onlyDetached: true,
-					showTag: true,
-					future: "keep",
-				});
-				expect(raw.components.footer.styles.starship.gitCommit).toEqual({
-					hashLength: 12,
-					onlyDetached: false,
-					showTag: false,
-				});
-				expect(raw.unknown).toBe(true);
-			},
-		);
-	});
-
-	it("saves git metrics booleans while preserving unknown siblings", () => {
-		withConfig(
-			{ unknown: true, gitMetrics: { onlyNonzero: true, ignoreSubmodules: false, future: 1 } },
-			(path) => {
-				const config = saveGitMetricsPatch({ onlyNonzero: false, ignoreSubmodules: true }, path);
-				const raw = JSON.parse(readFileSync(path, "utf8"));
-				expect(config.gitMetrics).toEqual({ onlyNonzero: false, ignoreSubmodules: true });
-				expect(raw.gitMetrics).toEqual({
-					onlyNonzero: true,
-					ignoreSubmodules: false,
-					future: 1,
-				});
-				expect(raw.components.footer.styles.starship.gitMetrics).toEqual({
-					onlyNonzero: false,
-					ignoreSubmodules: true,
-				});
-				expect(raw.unknown).toBe(true);
-			},
-		);
-	});
-
-	it("saves default extension placement while preserving keyed and unknown config", () => {
-		withConfig(
-			{
-				unknown: true,
-				extensionStatuses: {
-					defaultPlacement: "right",
-					placements: { alpha: "left" },
-					colorModes: { alpha: "original" },
-					future: "keep",
-				},
-			},
-			(path) => {
-				const config = saveExtensionStatusDefaultPlacement("middle", path);
-				const raw = JSON.parse(readFileSync(path, "utf8"));
-				expect(config.extensionStatuses).toEqual({
-					defaultPlacement: "middle",
-					placements: { alpha: "left" },
-					colorModes: { alpha: "original" },
-				});
-				expect(raw.extensionStatuses.future).toBe("keep");
-				expect(raw.extensionStatuses.placements).toEqual({ alpha: "left" });
-				expect(raw.extensionStatuses.colorModes).toEqual({ alpha: "original" });
-				expect(raw.components.footer.styles.starship.extensionStatuses.defaultPlacement).toBe(
-					"middle",
-				);
-				expect(raw.unknown).toBe(true);
-			},
-		);
-	});
-});
-
-describe("startup and file safety", () => {
-	it("does not create, rewrite, or materialize config at startup", () => {
-		withConfig(undefined, (path) => {
-			ensureConfigExists(path);
-			expect(existsSync(path)).toBe(false);
-		});
-		withConfig({ features: { editor: false }, unknown: true }, (path) => {
-			const before = readFileSync(path, "utf8");
-			ensureConfigExists(path);
-			expect(readFileSync(path, "utf8")).toBe(before);
-			expect(readRaw(path)).not.toHaveProperty("components");
-		});
-	});
-
-	it("refuses corrupt config without changing bytes or leaving a temporary file", () => {
-		withConfig(undefined, (path, dir) => {
-			const original = "{ invalid json\n";
-			writeFileSync(path, original);
-			expect(() => saveSeparatorPatch("dot", path)).toThrow(
-				/Refusing to save Zentui config.*corrupt/,
-			);
-			expect(readFileSync(path, "utf8")).toBe(original);
-			expect(configTempFiles(dir)).toEqual([]);
-		});
-	});
-
-	it("creates a missing config atomically and returns the re-merged file", () => {
-		withConfig(undefined, (path, dir) => {
-			const config = saveFooterFormatPatch("$cwd", path);
-			const raw = readRaw(path);
-			expect(raw.components.footer.styles.starship.format).toBe("$cwd");
-			expect(raw).not.toHaveProperty("fixedEditor");
-			expect(raw).not.toHaveProperty("layout.fixedEditor");
-			expect(config).toEqual(mergeConfig(raw));
-			expect(configTempFiles(dir)).toEqual([]);
-		});
-	});
-
-	it("preserves destination mode during atomic replacement", () => {
-		withConfig({ separator: "pipe" }, (path, dir) => {
-			chmodSync(path, 0o600);
-			saveSeparatorPatch("dot", path);
-			expect(statSync(path).mode & 0o777).toBe(0o600);
-			expect(readRaw(path).components.footer.styles.starship.separator).toBe("dot");
-			expect(configTempFiles(dir)).toEqual([]);
-		});
-	});
-
-	it("updates a symlink target atomically without replacing the symlink", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-symlink-config-"));
-		const targetDir = join(dir, "target");
-		const targetPath = join(targetDir, "actual.json");
-		const linkPath = join(dir, "zentui.json");
-		try {
-			mkdirSync(targetDir);
-			writeFileSync(targetPath, `${JSON.stringify({ unknown: true }, null, 2)}\n`);
-			chmodSync(targetPath, 0o600);
-			symlinkSync(targetPath, linkPath);
-			const originalLink = readlinkSync(linkPath);
-			const config = saveSeparatorPatch("chevron", linkPath);
-			const raw = readRaw(targetPath);
-			expect(lstatSync(linkPath).isSymbolicLink()).toBe(true);
-			expect(readlinkSync(linkPath)).toBe(originalLink);
-			expect(raw.unknown).toBe(true);
-			expect(raw.components.footer.styles.starship.separator).toBe("chevron");
-			expect(config).toEqual(mergeConfig(raw));
-			expect(statSync(targetPath).mode & 0o777).toBe(0o600);
-			expect(configTempFiles(targetDir, "actual.json")).toEqual([]);
-			expect(configTempFiles(dir)).toEqual([]);
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("refuses a dangling symlink without changing it", () => {
-		const dir = mkdtempSync(join(tmpdir(), "zentui-dangling-config-"));
-		const targetDir = join(dir, "target");
-		const missingTarget = join(targetDir, "missing.json");
-		const linkPath = join(dir, "zentui.json");
-		try {
-			mkdirSync(targetDir);
-			symlinkSync(missingTarget, linkPath);
-			const originalLink = readlinkSync(linkPath);
-			expect(() => saveSeparatorPatch("dot", linkPath)).toThrow(/Refusing to save Zentui config/);
-			expect(lstatSync(linkPath).isSymbolicLink()).toBe(true);
-			expect(readlinkSync(linkPath)).toBe(originalLink);
-			expect(existsSync(missingTarget)).toBe(false);
-			expect(configTempFiles(targetDir, "missing.json")).toEqual([]);
-			expect(configTempFiles(dir)).toEqual([]);
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("keeps the destination and leaves no temp file when serialization input is invalid", () => {
-		withConfig({ unknown: true }, (path, dir) => {
-			const original = readFileSync(path, "utf8");
-			expect(() => saveContextThresholdsPatch({ warning: 1n as never }, path)).toThrow();
-			expect(readFileSync(path, "utf8")).toBe(original);
-			expect(configTempFiles(dir)).toEqual([]);
-		});
-	});
-});
-
-describe("Opencode and Footer follow-up migration", () => {
-	it("resolves canonical and alias editor metadata in documented precedence", () => {
-		const config = mergeConfig({
-			editorMetadataFormat: "$flat",
-			components: {
-				editor: {
-					styles: {
-						opencode: { metadataFormat: "$canonical" },
-						polished: { metadataFormat: "$alias" },
-						"polished-copy-friendly": { metadataFormat: "$alias-copy" },
-					},
-				},
-			},
-		});
-		expect(config.components.editor.styles.opencode.metadataFormat).toBe("$canonical");
-		expect(config.components.editor.styles["opencode-copy-friendly"].metadataFormat).toBe(
-			"$alias-copy",
-		);
-		expect(
-			mergeConfig({
-				editorMetadataFormat: "$flat",
-				components: { editor: { styles: { polished: { metadataFormat: "$alias" } } } },
-			}).components.editor.styles.opencode.metadataFormat,
-		).toBe("$alias");
-	});
-
-	it("resolves Footer style from valid style, enabled, released statusLine, then default", () => {
-		expect(
-			mergeConfig({
-				features: { statusLine: false },
-				components: { footer: { style: "hidden", enabled: true } },
-			}).components.footer.style,
-		).toBe("hidden");
-		expect(
-			mergeConfig({
-				features: { statusLine: true },
-				components: { footer: { style: "future", enabled: false } },
-			}).components.footer.style,
-		).toBe("native");
-		expect(mergeConfig({ features: { statusLine: false } }).components.footer.style).toBe("native");
-		expect(mergeConfig({}).components.footer.style).toBe("native");
-		expect(mergeConfig({ components: { footer: { style: "hidden" } } }).features.statusLine).toBe(
-			false,
-		);
-	});
-
-	it("saves Footer styles canonically and removes only obsolete enabled", () => {
-		withConfig(
-			{
-				features: { statusLine: true, future: "keep" },
-				components: {
-					footer: {
-						enabled: true,
-						future: "keep",
-						styles: { starship: { format: "$cwd", future: "keep" }, future: { keep: true } },
-					},
-				},
-			},
-			(path) => {
-				saveFooterComponentPatch({ style: "hidden" }, path);
-				const raw = readRaw(path);
-				expect(raw.components.footer.style).toBe("hidden");
-				expect(raw.components.footer).not.toHaveProperty("enabled");
-				expect(raw.components.footer.future).toBe("keep");
-				expect(raw.components.footer.styles.starship).toMatchObject({
-					format: "$cwd",
-					future: "keep",
-				});
-				expect(raw.components.footer.styles.future).toEqual({ keep: true });
-				expect(raw.features).toEqual({ statusLine: true, future: "keep" });
-			},
-		);
-	});
-
-	it("keeps saveUiFeaturesPatch as a Starship/Native compatibility API", () => {
-		withConfig({ components: { footer: { style: "hidden" } } }, (path) => {
-			expect(saveUiFeaturesPatch({ statusLine: true }, path).components.footer.style).toBe(
-				"starship",
-			);
-			expect(saveUiFeaturesPatch({ statusLine: false }, path).components.footer.style).toBe(
-				"native",
-			);
-		});
-	});
-
-	it("ignores inherited extension-status overrides and validates runtime mutations", () => {
-		const config = structuredClone(defaultConfig);
-		const statuses = config.components.footer.styles.starship.extensionStatuses;
-		statuses.placements = Object.create({ constructor: "left" }) as Record<
-			string,
-			(typeof statuses.placements)[string]
-		>;
-		statuses.colorModes = Object.create({ constructor: "original" }) as Record<
-			string,
-			(typeof statuses.colorModes)[string]
-		>;
-		expect(getExtensionStatusPlacement(config, "constructor")).toBe("right");
-		expect(getExtensionStatusColorMode(config, "constructor")).toBe("zentui");
-
-		Object.defineProperty(statuses.placements, "constructor", {
-			value: "left",
-			enumerable: true,
-			configurable: true,
-		});
-		Object.defineProperty(statuses.colorModes, "constructor", {
-			value: "original",
-			enumerable: true,
-			configurable: true,
-		});
-		expect(getExtensionStatusPlacement(config, "constructor")).toBe("left");
-		expect(getExtensionStatusColorMode(config, "constructor")).toBe("original");
-
-		(statuses as unknown as { defaultPlacement: string }).defaultPlacement = "center";
-		(statuses.placements as unknown as Record<string, string>).alpha = "explode";
-		(statuses.colorModes as unknown as Record<string, string>).alpha = "rainbow";
-		expect(getExtensionStatusPlacement(config, "missing")).toBe("right");
-		expect(getExtensionStatusPlacement(config, "alpha")).toBe("right");
-		expect(getExtensionStatusColorMode(config, "alpha")).toBe("zentui");
-	});
-
-	it("marks only explicit non-empty unknown canonical component styles", () => {
-		const future = mergeConfig({
-			components: {
-				editor: { style: "future-editor" },
-				userMessages: { style: "future-messages" },
-				selectorBorders: { style: "future-selectors" },
-				footer: { style: "future-footer" },
-			},
-		});
-		for (const owner of ["editor", "userMessages", "selectorBorders", "footer"] as const) {
-			expect(hasUnsupportedComponentStyle(future, owner)).toBe(true);
-		}
-
-		for (const style of [undefined, "", "   ", null, false, {}, []]) {
-			const ordinary = mergeConfig({ components: { editor: { style } } });
-			expect(hasUnsupportedComponentStyle(ordinary, "editor")).toBe(false);
-		}
-		expect(
-			hasUnsupportedComponentStyle(
-				mergeConfig({ components: { editor: { style: "polished" } } }),
-				"editor",
-			),
-		).toBe(false);
-	});
-
-	it.each([
-		[true, "starship"],
-		[false, "native"],
-	] as const)(
-		"makes compatibility statusLine=%s authoritative over unknown Footer state",
-		(statusLine, expectedStyle) => {
-			withConfig(
-				{
-					features: { statusLine: !statusLine, future: "keep" },
-					components: {
-						footer: {
-							style: "future-footer",
-							enabled: true,
-							future: "keep",
-							styles: {
-								starship: { format: "$cwd" },
-								future: { keep: true },
-							},
-						},
-					},
-				},
-				(path) => {
-					const config = saveUiFeaturesPatch({ statusLine }, path);
-					const raw = readRaw(path);
-					expect(config.components.footer.style).toBe(expectedStyle);
-					expect(raw.components.footer.style).toBe(expectedStyle);
-					expect(raw.components.footer).not.toHaveProperty("enabled");
-					expect(raw.components.footer.future).toBe("keep");
-					expect(raw.components.footer.styles.future).toEqual({ keep: true });
-					expect(raw.features).toEqual({ statusLine: !statusLine, future: "keep" });
-				},
-			);
-		},
-	);
-});