@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-zentui/test/settings-command.test.ts

@@ -1,9 +1,17 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import { visibleWidth } from "@earendil-works/pi-tui";
+import {
+	getKeybindings,
+	KeybindingsManager,
+	setKeybindings,
+	TUI_KEYBINDINGS,
+	visibleWidth,
+} from "@earendil-works/pi-tui";
 import { afterEach, describe, expect, it, vi } from "vitest";
+import { renderAccentRailEditorFrame } from "../extensions/zentui/accent-rail-editor";
 import {
 	defaultConfig,
 	type EditorComponentConfig,
+	type ExtensionStatusColorMode,
 	type ExtensionStatusPlacement,
 	type FooterComponentConfig,
 	type PolishedTuiConfig,
@@ -20,7 +28,7 @@ import { registerZentuiSettingsCommand } from "../extensions/zentui/settings-com
 type Component = { render(width: number): string[]; handleInput(data: string): void };
 type Command = {
 	handler(args: string, ctx: unknown): Promise<void>;
-	getArgumentCompletions(prefix: string): Array<{ value: string }> | null;
+	getArgumentCompletions(prefix: string): Array<{ value: string; label: string }> | null;
 };
 const sectionNames = [
 	"Appearance",
@@ -29,11 +37,10 @@ const sectionNames = [
 	"Thinking",
 	"Working line",
 	"Footer",
-	"Segments",
-	"Git",
-	"Extensions",
+	"Extension statuses",
 ] as const;
-type SectionName = (typeof sectionNames)[number];
+const footerPageNames = ["Segments", "Git"] as const;
+type SectionName = (typeof sectionNames)[number] | (typeof footerPageNames)[number];
 
 function theme(): Theme {
 	return {
@@ -66,22 +73,35 @@ function cloneConfig(): PolishedTuiConfig {
 	return config;
 }
 function goToSection(component: Component, section: SectionName): void {
-	for (let index = 0; index < sectionNames.indexOf(section); index += 1)
+	if (footerPageNames.some((name) => name === section)) {
+		goToSection(component, "Footer");
+		openFooterPage(component, section as (typeof footerPageNames)[number]);
+		return;
+	}
+	for (
+		let index = 0;
+		index < sectionNames.indexOf(section as (typeof sectionNames)[number]);
+		index += 1
+	)
 		component.handleInput("\t");
 }
+function openFooterPage(component: Component, page: (typeof footerPageNames)[number]): void {
+	selectLabel(component, page);
+	component.handleInput("\r");
+}
 function selectLabel(component: Component, label: string): void {
 	for (let index = 0; index < 40; index += 1) {
-		if (component.render(160).some((line) => line.includes(`> ${label}`))) return;
+		if (component.render(160).some((line) => line.startsWith(`> ${label}`))) return;
 		component.handleInput("\x1b[B");
 	}
 	throw new Error(`Could not select ${label}`);
 }
 function row(component: Component, label: string): string {
 	selectLabel(component, label);
-	return component.render(160).find((line) => line.includes(`> ${label}`)) ?? "";
+	return component.render(160).find((line) => line.startsWith(`> ${label}`)) ?? "";
 }
 function focusedRow(component: Component): string {
-	return component.render(200).find((line) => line.includes("> ")) ?? "";
+	return component.render(200).find((line) => line.startsWith("> ")) ?? "";
 }
 function previewRow(rows: string[], text: string): number {
 	const index = rows.findIndex((line) => line.includes(text));
@@ -91,7 +111,7 @@ function previewRow(rows: string[], text: string): number {
 function expectStackedPreview(rows: string[], previewText: string): void {
 	const previewIndex = previewRow(rows, previewText);
 	const settingsIndex = rows.findIndex(
-		(line, index) => index > previewIndex && line.includes("> "),
+		(line, index) => index > previewIndex && line.startsWith("> "),
 	);
 	if (settingsIndex < 0) throw new Error("Could not find settings below preview");
 	expect(rows[3]).toBe("");
@@ -128,6 +148,7 @@ function createHarness(
 	const notificationEvents: Array<{ message: string; severity: string }> = [];
 	let doneCalls = 0;
 	const sessionLifecycle = new SessionLifecycle();
+	sessionLifecycle.start();
 	const calls = {
 		presets: [] as PresetId[],
 		editor: [] as Partial<EditorComponentConfig>[],
@@ -149,6 +170,8 @@ function createHarness(
 		recipe: [] as boolean[],
 	};
 	const deps = {
+		migrateSelections: () => {},
+		setComponentColor: () => {},
 		sessionLifecycle,
 		getConfig: () => config,
 		applyPreset(id: PresetId) {
@@ -230,12 +253,60 @@ function createHarness(
 			Object.assign(config.components.footer.styles.starship.gitMetrics, patch);
 		},
 		getActiveExtensionStatuses: () => new Map(),
-		setExtensionStatusDefaultPlacement(placement: ExtensionStatusPlacement) {
+		setExtensionStatusDefaultChoice(placement: ExtensionStatusPlacement) {
 			calls.extensionDefaultPlacement.push(placement);
-			config.components.footer.styles.starship.extensionStatuses.defaultPlacement = placement;
+			config.components.extensionStatuses.defaultVisibility = placement === "off" ? "hide" : "show";
+			if (placement !== "off") {
+				if (config.components.footer.style === "hidden") {
+					config.components.extensionStatuses.hidden ??= {};
+					config.components.extensionStatuses.hidden.defaultPlacement = placement;
+				} else
+					config.components.footer.styles.starship.extensionStatuses.defaultPlacement = placement;
+			}
+		},
+		setExtensionStatusChoice(key: string, choice: "default" | ExtensionStatusPlacement) {
+			const owner = config.components.extensionStatuses;
+			let placements = config.components.footer.styles.starship.extensionStatuses.placements;
+			if (config.components.footer.style === "hidden") {
+				owner.hidden ??= {};
+				owner.hidden.placements ??= {};
+				placements = owner.hidden.placements;
+			}
+			if (choice === "default") {
+				delete owner.visibility[key];
+				delete placements[key];
+			} else {
+				Object.defineProperty(owner.visibility, key, {
+					value: choice === "off" ? "hide" : "show",
+					enumerable: true,
+					configurable: true,
+					writable: true,
+				});
+				if (choice !== "off")
+					Object.defineProperty(placements, key, {
+						value: choice,
+						enumerable: true,
+						configurable: true,
+						writable: true,
+					});
+			}
+		},
+		setHiddenExtensionStatusColorMode(key: string, colorMode: ExtensionStatusColorMode) {
+			config.components.extensionStatuses.hidden ??= {};
+			const hidden = config.components.extensionStatuses.hidden;
+			hidden.colorModes ??= {};
+			if (colorMode === "original") delete hidden.colorModes[key];
+			else
+				Object.defineProperty(hidden.colorModes, key, {
+					value: colorMode,
+					enumerable: true,
+					configurable: true,
+					writable: true,
+				});
+		},
+		setExtensionStatusColorMode(key: string, colorMode: ExtensionStatusColorMode) {
+			config.components.footer.styles.starship.extensionStatuses.colorModes[key] = colorMode;
 		},
-		setExtensionStatusPlacement() {},
-		setExtensionStatusColorMode() {},
 		requestRender() {
 			calls.renders.shared += 1;
 		},
@@ -288,6 +359,7 @@ function createHarness(
 	};
 	return {
 		config,
+		deps,
 		command: () => {
 			if (!command) throw new Error("Command was not registered");
 			return command;
@@ -309,12 +381,77 @@ afterEach(() => {
 	vi.useRealTimers();
 });
 
+describe("focused OMP skin settings", () => {
+	it("defaults to Editor and cycles only the three supported owners", async () => {
+		const h = createHarness(cloneConfig(), { skinOnly: true });
+		await h.command().handler("", h.ctx);
+		const component = h.component();
+		expect(component.render(160)[1]).toContain("[Editor] / User messages / Statusline");
+		component.handleInput("\t");
+		expect(component.render(160)[1]).toContain("Editor / [User messages] / Statusline");
+		component.handleInput("\t");
+		expect(component.render(160)[1]).toContain("Editor / User messages / [Statusline]");
+		component.handleInput("\t");
+		expect(component.render(160)[1]).toContain("[Editor] / User messages / Statusline");
+		component.handleInput("\x1b[Z");
+		expect(component.render(160)[1]).toContain("Editor / User messages / [Statusline]");
+	});
+
+	it("rejects unsupported pages and migration without changing saved owners", async () => {
+		const h = createHarness(cloneConfig(), { skinOnly: true });
+		const before = structuredClone(h.config);
+		for (const route of [
+			"appearance",
+			"thinking",
+			"thinking-steps",
+			"working-line",
+			"extensions",
+			"migrate",
+		]) {
+			await h.command().handler(route, h.ctx);
+			expect(h.notifications.at(-1)).toContain("host-owned");
+		}
+		expect(h.config).toEqual(before);
+		expect(h.calls.thinkingSteps).toEqual([]);
+		expect(h.calls.workingLine).toEqual([]);
+		expect(h.calls.selectors).toEqual([]);
+		const completions = h
+			.command()
+			.getArgumentCompletions("")
+			?.map(({ value }) => value);
+		for (const route of ["appearance", "thinking", "working-line", "extensions", "migrate"]) {
+			expect(completions).not.toContain(route);
+		}
+		expect(completions).toContain("statusline");
+	});
+
+	it("retains supported shared presets without saving unsupported owners", async () => {
+		const h = createHarness(cloneConfig(), { skinOnly: true });
+		const unsupported = structuredClone({
+			working: h.config.components.workingLine,
+			thinking: h.config.components.thinkingSteps,
+			selectors: h.config.components.selectorBorders,
+		});
+		await h.command().handler("preset rail", h.ctx);
+		expect(h.calls.presets).toEqual(["rail"]);
+		expect(h.config.components.editor.style).toBe("accent-rail");
+		expect(h.config.components.userMessages.style).toBe("compact");
+		expect(h.config.components.footer.style).toBe("starship");
+		expect({
+			working: h.config.components.workingLine,
+			thinking: h.config.components.thinkingSteps,
+			selectors: h.config.components.selectorBorders,
+		}).toEqual(unsupported);
+	});
+});
+
 describe("component-oriented /zentui settings", () => {
-	it("uses the exact nine-section order in wide and narrow navigation", async () => {
+	it("uses the exact seven-section order in wide and narrow navigation", async () => {
 		const harness = createHarness();
 		await harness.command().handler("", harness.ctx);
 		const component = harness.component();
 		const wide = component.render(200).join("\n");
+		for (const child of footerPageNames) expect(component.render(200)[1]).not.toContain(child);
 		let previous = -1;
 		for (const name of sectionNames) {
 			const index = wide.indexOf(name);
@@ -324,7 +461,7 @@ describe("component-oriented /zentui settings", () => {
 		for (const [index, name] of sectionNames.entries()) {
 			const lines = component.render(40);
 			expect(lines[1]).toContain(name);
-			expect(lines[1]).toContain(`(${index + 1}/9)`);
+			expect(lines[1]).toContain(`(${index + 1}/7)`);
 			expect(lines.every((line) => visibleWidth(line) <= 40)).toBe(true);
 			component.handleInput("\t");
 		}
@@ -343,6 +480,40 @@ describe("component-oriented /zentui settings", () => {
 		expect(tokenRows).toContain("reconciles.");
 	});
 
+	it("saves quota toggles independently, including dormant editor preferences", async () => {
+		const config = cloneConfig();
+		config.components.editor.enabled = false;
+		const harness = createHarness(config);
+		await harness.command().handler("", harness.ctx);
+		const component = harness.component();
+		goToSection(component, "Editor");
+		selectLabel(component, "Codex quota");
+		component.handleInput(" ");
+		expect(harness.calls.editor).toEqual([{ codexQuota: true }]);
+		expect(config.components.editor.enabled).toBe(false);
+		expect(config.components.footer.codexQuota).toBe(false);
+		for (let index = 0; index < 4; index++) component.handleInput("\t");
+		selectLabel(component, "Codex quota");
+		component.handleInput(" ");
+		expect(harness.calls.footer).toEqual([{ codexQuota: true }]);
+		expect(config.components.editor.codexQuota).toBe(true);
+	});
+
+	it("restores quota settings after a failed save", async () => {
+		const harness = createHarness(cloneConfig(), {
+			setEditorComponent() {
+				throw new Error("read-only quota");
+			},
+		});
+		await harness.command().handler("", harness.ctx);
+		const component = harness.component();
+		goToSection(component, "Editor");
+		selectLabel(component, "Codex quota");
+		component.handleInput(" ");
+		expect(row(component, "Codex quota")).toContain("disabled");
+		expect(harness.notifications).toContain("Could not update Zentui settings: read-only quota");
+	});
+
 	it("uses exact component-owned row sets and ordering", async () => {
 		const harness = createHarness();
 		await harness.command().handler("", harness.ctx);
@@ -353,6 +524,9 @@ describe("component-oriented /zentui settings", () => {
 			"Selector border style",
 			"Selector border colors",
 			"Icon mode",
+
+			"Color overrides",
+			"Migrate component selections",
 		]);
 
 		goToSection(component, "Editor");
@@ -360,20 +534,31 @@ describe("component-oriented /zentui settings", () => {
 			"Editor",
 			"Editor style",
 			"Editor colors",
+			"Codex quota",
 			"Editor model label",
 			"Editor border color",
 			"Editor viewport indicators",
 			"Completion menu",
+
+			"Color overrides",
+			"Individual custom value colors",
 		]);
 
 		component.handleInput("\t");
-		expectFocusOrder(component, ["User messages", "Message style", "Message colors"]);
+		expectFocusOrder(component, [
+			"User messages",
+			"Message style",
+			"Message colors",
+			"Color overrides",
+		]);
 		component.handleInput("\t");
 		expectFocusOrder(component, ["Enabled", "Mode"]);
 		component.handleInput("\t");
 		expectFocusOrder(component, [
 			"Enabled",
+			"Placement",
 			"Turn summary",
+			"Turn summary format",
 			"Spinner",
 			"Spinner speed",
 			"Animate spinner color",
@@ -384,13 +569,17 @@ describe("component-oriented /zentui settings", () => {
 			"Tool",
 			"Elapsed",
 			"Thinking time",
+			"Token rate",
 			"Tokens",
 			"Message list",
+
+			"Color overrides",
 		]);
 		component.handleInput("\t");
 		expectFocusOrder(component, [
 			"Footer style",
 			"Footer colors",
+			"Codex quota",
 			"Footer model label",
 			"Responsive footer",
 			"Compact footer rows",
@@ -398,8 +587,12 @@ describe("component-oriented /zentui settings", () => {
 			"Separator",
 			"Path display",
 			"Path depth",
+			"Segments",
+			"Git",
+			"Color overrides",
+			"Individual custom value colors",
 		]);
-		component.handleInput("\t");
+		openFooterPage(component, "Segments");
 		expectFocusOrder(component, [
 			"Current directory",
 			"Session name",
@@ -414,7 +607,8 @@ describe("component-oriented /zentui settings", () => {
 			"OS icon",
 			"Package version",
 		]);
-		component.handleInput("\t");
+		component.handleInput("\x1b");
+		openFooterPage(component, "Git");
 		expectFocusOrder(component, [
 			"Git branch",
 			"Branch length",
@@ -427,12 +621,13 @@ describe("component-oriented /zentui settings", () => {
 			"Hide zero metrics",
 			"Ignore submodules",
 		]);
+		component.handleInput("\x1b");
 		component.handleInput("\t");
-		expectFocusOrder(component, ["Default placement", "No active statuses"]);
+		expectFocusOrder(component, ["Default placement", "No observed statuses"]);
 	});
 
 	it.each(["native", "hidden"] as const)(
-		"shows only Footer style for %s while retaining Starship preconfiguration sections",
+		"shows Footer style and color preconfiguration for %s",
 		async (style) => {
 			const config = cloneConfig();
 			config.components.footer.style = style;
@@ -440,26 +635,14 @@ describe("component-oriented /zentui settings", () => {
 			await harness.command().handler("", harness.ctx);
 			const component = harness.component();
 			goToSection(component, "Footer");
-			expectFocusOrder(component, ["Footer style"]);
-			component.handleInput("\t");
-			expectFocusOrder(component, [
-				"Current directory",
-				"Session name",
-				"Runtime",
-				"Model info",
-				"Context usage",
-				"Token counts",
-				"Session cost",
-				"Session duration",
-				"Username@host",
-				"Current time",
-				"OS icon",
-				"Package version",
-			]);
-			component.handleInput("\t");
-			expect(row(component, "Git branch")).toContain("enabled");
+			expectFocusOrder(component, ["Footer style", "Color overrides"]);
+
+			const before = structuredClone(config);
+			for (const page of footerPageNames)
+				expect(component.render(200).join("\n")).not.toContain(page);
 			component.handleInput("\t");
-			expect(row(component, "Default placement")).toContain("right");
+			expect(component.render(40)[1]).toContain("Extension statuses");
+			expect(config).toEqual(before);
 		},
 	);
 
@@ -496,7 +679,7 @@ describe("component-oriented /zentui settings", () => {
 		component.handleInput(" ");
 		expect(focusedRow(component)).toContain("> Footer style");
 		expect(focusedRow(component)).toContain("Native");
-		expectFocusOrder(component, ["Footer style"]);
+		expectFocusOrder(component, ["Footer style", "Color overrides"]);
 		expect(harness.notifications).toEqual(["Could not update Zentui settings: read-only footer"]);
 	});
 
@@ -513,6 +696,7 @@ describe("component-oriented /zentui settings", () => {
 			"Editor",
 			"Editor style",
 			"Editor colors",
+			"Codex quota",
 			"Editor model label",
 			"Editor border color",
 			"Editor viewport indicators",
@@ -522,10 +706,22 @@ describe("component-oriented /zentui settings", () => {
 			"Session name",
 			"Timer",
 			"Cost",
+			"Cache hit rate",
 			"Git",
+			"Separator",
+			"Custom value colors",
+			"Metadata templates",
+			"Custom variable aliases",
+			"Color overrides",
+			"Individual custom value colors",
 		]);
 		component.handleInput("\t");
-		expectFocusOrder(component, ["User messages", "Message style", "Message colors"]);
+		expectFocusOrder(component, [
+			"User messages",
+			"Message style",
+			"Message colors",
+			"Color overrides",
+		]);
 	});
 
 	it("routes every minimalist, Git option, and default-placement action", async () => {
@@ -543,7 +739,9 @@ describe("component-oriented /zentui settings", () => {
 			["Session name", "disabled"],
 			["Timer", "disabled"],
 			["Cost", "disabled"],
+			["Cache hit rate", "enabled"],
 			["Git", "disabled"],
+			["Separator", "dot"],
 		] as const) {
 			selectLabel(component, label);
 			component.handleInput(" ");
@@ -557,10 +755,13 @@ describe("component-oriented /zentui settings", () => {
 			{ showSessionName: false },
 			{ showTimer: false },
 			{ showCost: false },
+			{ showCacheHit: true },
 			{ showGit: false },
+			{ separator: "dot" },
 		]);
 
-		for (let index = 0; index < 6; index += 1) component.handleInput("\t");
+		for (let index = 0; index < 4; index += 1) component.handleInput("\t");
+		openFooterPage(component, "Git");
 		for (const [label, value] of [
 			["Commit only on detached HEAD", "disabled"],
 			["Show exact-match tag", "disabled"],
@@ -575,13 +776,14 @@ describe("component-oriented /zentui settings", () => {
 		expect(harness.calls.gitCommit).toEqual([{ onlyDetached: false }, { showTag: false }]);
 		expect(harness.calls.gitMetrics).toEqual([{ onlyNonzero: false }, { ignoreSubmodules: true }]);
 
+		component.handleInput("\x1b");
 		component.handleInput("\t");
 		selectLabel(component, "Default placement");
 		component.handleInput(" ");
 		expect(focusedRow(component)).toContain("> Default placement");
-		expect(focusedRow(component)).toContain("off");
+		expect(focusedRow(component)).toContain("Off");
 		expect(harness.calls.extensionDefaultPlacement).toEqual(["off"]);
-		expect(config.components.footer.styles.starship.extensionStatuses.defaultPlacement).toBe("off");
+		expect(config.components.extensionStatuses.defaultVisibility).toBe("hide");
 	});
 
 	it("restores editor-style focus by ID after dynamic rebuild", async () => {
@@ -635,27 +837,36 @@ describe("component-oriented /zentui settings", () => {
 		expect(component.render(100).join("\n")).not.toContain("Completion menu");
 	});
 
-	it("shows and persists the Accent Rail surface control only for that style", async () => {
+	it("changes the rail background in OMP settings without changing another component or style", async () => {
 		const current = cloneConfig();
 		current.components.editor.style = "accent-rail";
-		const harness = createHarness(current);
-		await harness.command().handler("", harness.ctx);
+		const before = structuredClone(current);
+		const harness = createHarness(current, { skinOnly: true });
+		await harness.command().handler("editor", harness.ctx);
 		const component = harness.component();
-		goToSection(component, "Editor");
-		selectLabel(component, "Accent Rail surface");
-		expect(focusedRow(component)).toContain("filled");
+		const surfaceTheme = theme();
+		surfaceTheme.getBgAnsi = () => "\x1b[48;5;234m";
+		const render = () =>
+			renderAccentRailEditorFrame({
+				width: 30,
+				editorLines: ["draft"],
+				uiTheme: surfaceTheme,
+				config: current,
+			});
+		expect(render()[0]).toContain("\x1b[48;5;234m");
+		selectLabel(component, "Editor background");
 		component.handleInput(" ");
-		expect(focusedRow(component)).toContain("transparent");
-		expect(harness.calls.accentRail).toEqual([{ transparent: true }]);
-		expect(harness.calls.editor).toEqual([]);
-		expect(current.components.editor.styles.minimalist).toEqual({
-			...defaultConfig.components.editor.styles.minimalist,
-			contextGauge: false,
-		});
-
-		selectLabel(component, "Editor style");
+		expect(render()[0]).not.toContain("\x1b[48;5;234m");
+		expect(current.components.editor.styles["accent-rail"].transparent).toBe(true);
+		expect(current.components.editor.style).toBe("accent-rail");
+		expect(current.components.footer).toEqual(before.components.footer);
+		expect(current.components.userMessages).toEqual(before.components.userMessages);
+		expect(current.components.editor.styles.minimalist).toEqual(
+			before.components.editor.styles.minimalist,
+		);
 		component.handleInput(" ");
-		expect(component.render(80).join("\n")).not.toContain("Accent Rail surface");
+		expect(render()[0]).toContain("\x1b[48;5;234m");
+		expect(current.components.editor.styles["accent-rail"].transparent).toBe(false);
 	});
 
 	it("shows friendly message style labels and restores focus after rebuild", async () => {
@@ -803,14 +1014,15 @@ describe("component-oriented /zentui settings", () => {
 		component.handleInput("\t");
 		component.handleInput("\t");
 		component.handleInput("\t");
-		component.handleInput("\t");
-		component.handleInput("\t");
+		openFooterPage(component, "Git");
 		selectLabel(component, "Ignore submodules");
 		component.handleInput(" ");
-		component.handleInput("\x1b[Z");
+		component.handleInput("\x1b");
+		openFooterPage(component, "Segments");
 		selectLabel(component, "Model info");
 		component.handleInput(" ");
 		component.handleInput("\x1b");
+		component.handleInput("\x1b");
 		expect(harness.doneCalls()).toBe(1);
 
 		await harness.command().handler("", harness.ctx);
@@ -822,15 +1034,16 @@ describe("component-oriented /zentui settings", () => {
 		component.handleInput("\t");
 		component.handleInput("\t");
 		component.handleInput("\t");
-		component.handleInput("\t");
-		component.handleInput("\t");
+		openFooterPage(component, "Git");
 		expect(row(component, "Ignore submodules")).toContain("enabled");
-		component.handleInput("\x1b[Z");
+		component.handleInput("\x1b");
+		openFooterPage(component, "Segments");
 		expect(row(component, "Model info")).toContain("enabled");
 		expect(harness.calls.editor).toEqual([{ borderColorMode: "adaptive" }, { modelLabel: "name" }]);
 		expect(harness.calls.gitMetrics).toEqual([{ ignoreSubmodules: true }]);
 		expect(harness.calls.segments).toEqual([{ modelInfo: true }]);
 		component.handleInput("\x1b");
+		component.handleInput("\x1b");
 		expect(harness.doneCalls()).toBe(2);
 	});
 
@@ -855,7 +1068,7 @@ describe("component-oriented /zentui settings", () => {
 		component.handleInput("\t");
 		component.handleInput("\t");
 		component.handleInput("\t");
-		component.handleInput("\t");
+		openFooterPage(component, "Segments");
 		selectLabel(component, "Model info");
 		component.handleInput(" ");
 		expect(focusedRow(component)).toContain("> Model info");
@@ -1105,7 +1318,7 @@ describe("component-oriented /zentui settings", () => {
 		});
 	});
 
-	it("restores Thinking-step rows after persistence failure and exposes no direct route", async () => {
+	it("restores Thinking-step rows after persistence failure and accepts its section route", async () => {
 		const harness = createHarness(cloneConfig(), {
 			setThinkingStepsComponent() {
 				throw new Error("read-only thinking");
@@ -1119,23 +1332,68 @@ describe("component-oriented /zentui settings", () => {
 		expect(focusedRow(component)).toContain("disabled");
 		expect(harness.notifications).toContain("Could not update Zentui settings: read-only thinking");
 		await harness.command().handler("thinking-steps", harness.ctx);
-		expect(harness.notifications.at(-1)).toMatch(/^Usage:/);
+		expect(harness.component().render(40)[1]).toContain("Thinking");
 		expect(
 			harness
 				.command()
 				.getArgumentCompletions("")
 				?.map((item) => item.value)
 				.join("\n"),
-		).not.toMatch(/thinking.steps/i);
+		).toMatch(/thinking.steps/i);
 	});
 
+	it.each(["minimalist", "opencode", "opencode-copy-friendly"] as const)(
+		"offers only Above/Border for %s without changing Editor",
+		async (style) => {
+			const config = cloneConfig();
+			config.components.editor.style = style;
+			config.components.editor.enabled = true;
+			const editor = structuredClone(config.components.editor);
+			const h = createHarness(config);
+			await h.command().handler("working-line", h.ctx);
+			const panel = h.component();
+			selectLabel(panel, "Placement");
+			expect(focusedRow(panel)).toMatch(/Above$/);
+			panel.handleInput(" ");
+			expect(focusedRow(panel)).toMatch(/Border$/);
+			panel.handleInput(" ");
+			expect(focusedRow(panel)).toMatch(/Above$/);
+			expect(h.calls.workingLine).toEqual([{ placement: "border" }, { placement: "above" }]);
+			expect(config.components.editor).toEqual(editor);
+			expect(h.calls.editor).toEqual([]);
+		},
+	);
+
+	it.each(["accent-rail", "disabled"] as const)(
+		"hides Placement for %s and guards stale selection without changing saved Border",
+		async (mode) => {
+			const config = cloneConfig();
+			config.components.editor.enabled = true;
+			config.components.editor.style = "minimalist";
+			const h = createHarness(config);
+			await h.command().handler("working-line", h.ctx);
+			selectLabel(h.component(), "Placement");
+			if (mode === "accent-rail") config.components.editor.style = "accent-rail";
+			else config.components.editor.enabled = false;
+			h.component().handleInput(" ");
+			expect(h.calls.workingLine).toEqual([]);
+			config.components.workingLine.placement = "border";
+			h.component().handleInput("\x1b");
+			await h.command().handler("working-line", h.ctx);
+			expect(h.component().render(160).join("\n")).not.toContain("Placement");
+			expect(config.components.workingLine.placement).toBe("border");
+		},
+	);
+
 	it("routes all Working-line rows independently", async () => {
 		const harness = createHarness();
 		await harness.command().handler("working-line", harness.ctx);
 		const component = harness.component();
 		expectFocusOrder(component, [
 			"Enabled",
+			"Placement",
 			"Turn summary",
+			"Turn summary format",
 			"Spinner",
 			"Spinner speed",
 			"Animate spinner color",
@@ -1146,11 +1404,15 @@ describe("component-oriented /zentui settings", () => {
 			"Tool",
 			"Elapsed",
 			"Thinking time",
+			"Token rate",
 			"Tokens",
 			"Message list",
+
+			"Color overrides",
 		]);
 		for (const [label, expected] of [
 			["Enabled", "enabled"],
+			["Placement", "Border"],
 			["Turn summary", "disabled"],
 			["Spinner", "ASCII Pinwheel"],
 			["Spinner speed", "Slow 160 ms"],
@@ -1170,6 +1432,7 @@ describe("component-oriented /zentui settings", () => {
 		}
 		expect(harness.calls.workingLine).toEqual([
 			{ enabled: true },
+			{ placement: "border" },
 			{ turnSummary: false },
 			{ spinner: "pinwheel" },
 			{ spinnerIntervalMs: 160 },
@@ -1183,7 +1446,8 @@ describe("component-oriented /zentui settings", () => {
 			{ segments: { thought: false } },
 			{ segments: { tokens: false } },
 		]);
-		expect(harness.calls.renders).toEqual({ shared: 0, local: 13 });
+		expect(harness.calls.renders.shared).toBe(0);
+		expect(harness.calls.renders.local).toBeGreaterThanOrEqual(14);
 	});
 
 	it("displays, previews, and stores all named spinner presets with canonical IDs", async () => {
@@ -1338,7 +1602,8 @@ describe("component-oriented /zentui settings", () => {
 		await harness.command().handler("", harness.ctx);
 		selectLabel(harness.component(), "Selector borders");
 		harness.component().handleInput(" ");
-		expect(harness.calls.renders).toEqual({ shared: 1, local: 1 });
+		expect(harness.calls.renders.shared).toBe(1);
+		expect(harness.calls.renders.local).toBeGreaterThanOrEqual(1);
 	});
 
 	it.each([
@@ -1354,9 +1619,7 @@ describe("component-oriented /zentui settings", () => {
 			await harness.command().handler("", harness.ctx);
 			const component = harness.component();
 			goToSection(component, section);
-			const zeroWidthRows = component.render(0);
-			const oneCellRows = component.render(1);
-			expect(zeroWidthRows).toHaveLength(oneCellRows.length);
+			expect(component.render(0)).toEqual([]);
 			for (const width of [0, 1, 4]) {
 				const rows = component.render(width);
 				expect(rows.every((line) => visibleWidth(line) <= width)).toBe(true);
@@ -1366,14 +1629,14 @@ describe("component-oriented /zentui settings", () => {
 				const rows = component.render(width);
 				expect(rows.every((line) => visibleWidth(line) <= width)).toBe(true);
 				expectStackedPreview(rows, previewText);
-				expect(rows.some((line) => line.includes("> "))).toBe(true);
+				expect(rows.some((line) => line.startsWith("> "))).toBe(true);
 			}
 			component.handleInput("\x1b");
 			expect(vi.getTimerCount()).toBe(0);
 		},
 	);
 
-	it.each(["Appearance", "Footer", "Segments", "Git", "Extensions"] as const)(
+	it.each(["Appearance", "Footer", "Segments", "Git", "Extension statuses"] as const)(
 		"does not add preview spacer rows in %s",
 		async (section) => {
 			const harness = createHarness();
@@ -1448,14 +1711,26 @@ describe("component-oriented /zentui settings", () => {
 		]);
 		expect(vi.getTimerCount()).toBe(0);
 		component.handleInput("\t");
-		expect(component.render(100).join("\n")).toContain("Thinking");
+		expectStackedPreview(component.render(100), "Verify compatibility");
 		component.handleInput("\t");
 		const workingRows = component.render(100);
 		expectStackedPreview(workingRows, "Sautéing…");
 		component.handleInput("\t");
-		for (const section of ["Footer", "Segments", "Git", "Extensions"] as const) {
+		expect(harness.config.components.footer.style).toBe("starship");
+		for (const width of [40, 60, 80, 120, 160]) {
+			const rows = component.render(width);
+			expect(rows[3]).toContain("> Footer style");
+			expect(rows.join("\n")).not.toMatch(/samples?|synthetic|sonnet-long-context-preview/i);
+		}
+		expect(row(component, "Footer colors")).toContain("theme");
+		component.handleInput(" ");
+		expect(harness.calls.footer).toEqual([{ colorSource: "terminal" }]);
+		for (const label of ["Footer model label", "Responsive footer", "Color overrides"])
+			expect(row(component, label)).toContain(`> ${label}`);
+		for (const section of footerPageNames) {
+			openFooterPage(component, section);
 			expect(leadingEmptyRowCount(component.render(100)), section).toBe(0);
-			if (section !== "Extensions") component.handleInput("\t");
+			component.handleInput("\x1b");
 		}
 		expect(vi.getTimerCount()).toBe(0);
 	});
@@ -1865,3 +2140,976 @@ describe("preset commands and Appearance selection", () => {
 		},
 	);
 });
+
+describe("Footer layout authority disclosure", () => {
+	it("explains built-in segment toggles versus independent wide and compact templates", async () => {
+		const cfg = cloneConfig();
+		const starship = cfg.components.footer.styles.starship;
+		starship.segments.cwd = false;
+		starship.segments.cost = true;
+		starship.format = "$cwd";
+		const templates = [starship.format, starship.compactFormat];
+		const harness = createHarness(cfg);
+		await harness.command().handler("", harness.ctx);
+		const component = harness.component();
+		goToSection(component, "Footer");
+		selectLabel(component, "Responsive footer");
+		expect(component.render(200).join("\n")).toContain("Reflow the wide layout");
+		expect(component.render(200).join("\n")).toContain("independently of segment toggles");
+		openFooterPage(component, "Segments");
+		for (const label of ["Current directory", "Session cost"]) {
+			selectLabel(component, label);
+			const help = component.render(200).join("\n");
+			expect(help).toContain("Built-in layout:");
+			expect(help).toContain(
+				"Explicit wide format and compactFormat templates choose their own segments",
+			);
+			component.handleInput(" ");
+		}
+		expect([starship.format, starship.compactFormat]).toEqual(templates);
+		expect(harness.calls.segments).toEqual([{ cwd: true }, { cost: false }]);
+		component.handleInput("\x1b");
+		openFooterPage(component, "Git");
+		selectLabel(component, "Git counts");
+		expect(component.render(200).join("\n")).toContain(
+			"built-in segments and template git-status variables",
+		);
+	});
+
+	it("clarifies that clearing format leaves compactFormat unchanged", async () => {
+		const harness = createHarness();
+		await harness.command().handler("format clear", harness.ctx);
+		expect(harness.notifications).toContain(
+			"Footer wide format cleared (using built-in segments; compactFormat unchanged)",
+		);
+	});
+});
+
+describe("component independence settings actions", () => {
+	it.each([
+		["Appearance", "selectorBorders", "border"],
+		["Editor", "editor", "accent"],
+		["User messages", "userMessages", "border"],
+		["Working line", "workingLine", "high"],
+		["Footer", "footer", "cwd"],
+	] as const)(
+		"edits %s colors outside the disposed panel and restores focus",
+		async (section, owner, role) => {
+			let opens = 0;
+			let disposed = false;
+			const save = vi.fn();
+			const select = vi
+				.fn()
+				.mockResolvedValueOnce(role)
+				.mockResolvedValueOnce("Edit override")
+				.mockResolvedValue(undefined);
+			const harness = createHarness(
+				cloneConfig(),
+				{ setComponentColor: save },
+				{
+					select,
+					async editor() {
+						expect(disposed).toBe(true);
+						return "";
+					},
+					async custom(factory: (...args: unknown[]) => unknown) {
+						let outcome: unknown;
+						const component = factory({ requestRender() {} }, theme(), {}, (value: unknown) => {
+							outcome = value;
+						}) as Component & { dispose(): void };
+						if (opens++ === 0) {
+							goToSection(component, section);
+							selectLabel(component, "Color overrides");
+							component.handleInput(" ");
+						} else {
+							expect(focusedRow(component)).toContain("Color overrides");
+							component.handleInput("\x1b");
+						}
+						component.dispose();
+						disposed = true;
+						return outcome;
+					},
+				},
+			);
+			await harness.command().handler("", harness.ctx);
+			expect(opens).toBe(2);
+			expect(save).toHaveBeenCalledExactlyOnceWith(owner, role, "", harness.ctx);
+		},
+	);
+	it.each([true, false])(
+		"confirms migration=%s from Appearance and reopens its action",
+		async (confirmed) => {
+			let opens = 0;
+			const migrate = vi.fn();
+			const confirm = vi.fn(async () => confirmed);
+			const harness = createHarness(
+				cloneConfig(),
+				{ migrateSelections: migrate },
+				{
+					confirm,
+					async custom(factory: (...args: unknown[]) => unknown) {
+						let outcome: unknown;
+						const component = factory({ requestRender() {} }, theme(), {}, (value: unknown) => {
+							outcome = value;
+						}) as Component;
+						if (opens++ === 0) {
+							selectLabel(component, "Migrate component selections");
+							component.handleInput(" ");
+						} else {
+							expect(focusedRow(component)).toContain("Migrate component selections");
+							component.handleInput("\x1b");
+						}
+						return outcome;
+					},
+				},
+			);
+			await harness.command().handler("", harness.ctx);
+			expect(confirm).toHaveBeenCalledOnce();
+			expect(migrate).toHaveBeenCalledTimes(confirmed ? 1 : 0);
+			expect(opens).toBe(2);
+		},
+	);
+	it("routes /zentui migrate through confirmation and never reopens on stale confirmation", async () => {
+		const migrate = vi.fn();
+		const confirm = vi.fn(async () => true);
+		const h = createHarness(cloneConfig(), { migrateSelections: migrate }, { confirm });
+		await h.command().handler("migrate", h.ctx);
+		expect(migrate).toHaveBeenCalledOnce();
+		expect(h.command().getArgumentCompletions("mig")).toEqual([
+			{ value: "migrate", label: "migrate" },
+		]);
+		confirm.mockImplementationOnce(async () => {
+			h.sessionLifecycle.shutdown();
+			h.sessionLifecycle.start();
+			return true;
+		});
+		await h.command().handler("migrate", h.ctx);
+		expect(migrate).toHaveBeenCalledOnce();
+	});
+});
+
+describe("settings clarity and navigation", () => {
+	it("describes Working-line tiers and excludes template separators from the Separator choice", async () => {
+		vi.useFakeTimers();
+		const h = createHarness();
+		await h.command().handler("working-line", h.ctx);
+		selectLabel(h.component(), "Color overrides");
+		const colors = h.component().render(200).join(" ").replace(/\s+/g, " ");
+		expect(colors).toContain("Static Working line uses mid with optional Token rate override");
+		expect(colors).toContain("Classic/KITT animate every segment; Turn summaries use high.");
+		expect(colors).not.toContain("uses high only");
+		await h.command().handler("footer", h.ctx);
+		selectLabel(h.component(), "Separator");
+		const help = h.component().render(200).join(" ").replace(/\s+/g, " ");
+		expect(help).toContain("built-in/layout separators");
+		expect(help).toContain("extension-status joins");
+		expect(help).toContain("width can affect when the layout switches to compact");
+		expect(help).toContain("Does not change $sep (fixed pipe) or literal template separators");
+		h.sessionLifecycle.shutdown();
+	});
+
+	it("activates Confirm semantically when the actual global manager binds Space to navigation", async () => {
+		const previous = getKeybindings();
+		const manager = new KeybindingsManager(TUI_KEYBINDINGS, { "tui.select.down": "space" });
+		setKeybindings(manager);
+		try {
+			let panel: Component | undefined;
+			const h = createHarness(
+				cloneConfig(),
+				{},
+				{
+					custom: async (factory: (...args: unknown[]) => Component) => {
+						panel = factory({ requestRender() {} }, theme(), manager, () => {});
+					},
+				},
+			);
+			await h.command().handler("appearance", h.ctx);
+			if (!panel) throw new Error("No panel");
+			const help = panel.render(200).join("\n");
+			expect(help).toContain("up/space Navigate");
+			expect(help).toContain("enter Change");
+			expect(help).not.toContain("/Space Change");
+			panel.handleInput(" ");
+			expect(focusedRow(panel)).toContain("Selector borders");
+			panel.handleInput("\r");
+			expect(h.calls.selectors).toEqual([{ enabled: false }]);
+			expect(focusedRow(panel)).toContain("Selector borders");
+			panel.handleInput("\r");
+			expect(h.calls.selectors).toEqual([{ enabled: false }, { enabled: true }]);
+			panel.handleInput(" ");
+			expect(focusedRow(panel)).toContain("Selector border style");
+			panel.handleInput("\r"); // Informational, not actionable.
+			expect(h.calls.selectors).toHaveLength(2);
+			expect(getKeybindings()).toBe(manager);
+			expect(manager.getUserBindings()).toEqual({ "tui.select.down": "space" });
+		} finally {
+			setKeybindings(previous);
+		}
+	});
+
+	it.each(["Edit override", "Reset / inherit"])(
+		"opens color dialogs with Confirm under global Space navigation and preserves %s",
+		async (action) => {
+			const previous = getKeybindings();
+			const manager = new KeybindingsManager(TUI_KEYBINDINGS, { "tui.select.down": "space" });
+			setKeybindings(manager);
+			try {
+				let opens = 0;
+				const save = vi.fn();
+				const h = createHarness(
+					cloneConfig(),
+					{ setComponentColor: save },
+					{
+						select: vi.fn().mockResolvedValueOnce("border").mockResolvedValueOnce(action),
+						editor: vi.fn().mockResolvedValue(""),
+						custom: async (factory: (...args: unknown[]) => Component) => {
+							let outcome: unknown;
+							const panel = factory({ requestRender() {} }, theme(), manager, (value: unknown) => {
+								outcome = value;
+							});
+							if (opens++ === 0) {
+								for (let i = 0; i < 5; i++) panel.handleInput(" ");
+								expect(focusedRow(panel)).toContain("Color overrides");
+								panel.handleInput("\r");
+							} else {
+								expect(focusedRow(panel)).toContain("Color overrides");
+								panel.handleInput("\x1b");
+							}
+							return outcome;
+						},
+					},
+				);
+				await h.command().handler("appearance", h.ctx);
+				expect(opens).toBe(2);
+				expect(save).toHaveBeenCalledExactlyOnceWith(
+					"selectorBorders",
+					"border",
+					action === "Edit override" ? "" : undefined,
+					h.ctx,
+				);
+			} finally {
+				setKeybindings(previous);
+			}
+		},
+	);
+
+	it.each([
+		["appearance", "Appearance"],
+		["editor", "Editor"],
+		["messages", "User messages"],
+		["user-messages", "User messages"],
+		["thinking", "Thinking"],
+		["thinking-steps", "Thinking"],
+		["working-line", "Working line"],
+		["footer", "Footer"],
+		["statusline", "Footer"],
+		["status", "Footer"],
+		["status-line", "Footer"],
+		["segments", "Segments"],
+		["git", "Git"],
+		["extensions", "Extension statuses"],
+	])("routes and completes %s without changing selections", async (route, label) => {
+		vi.useFakeTimers();
+		const h = createHarness();
+		const before = structuredClone(h.config);
+		await h.command().handler(route, h.ctx);
+		expect(h.component().render(40)[1]).toContain(label);
+		expect(
+			h
+				.command()
+				.getArgumentCompletions(route)
+				?.map((item) => item.value),
+		).toContain(route);
+		expect(h.config).toEqual(before);
+		h.sessionLifecycle.shutdown();
+	});
+	it("marks dormant choices, explains icons, and makes selector style informational", async () => {
+		const config = cloneConfig();
+		config.components.editor.style = "accent-rail";
+		config.components.footer.style = "hidden";
+		const h = createHarness(config);
+		await h.command().handler("appearance", h.ctx);
+		selectLabel(h.component(), "Selector border style");
+		h.component().handleInput(" ");
+		expect(h.calls.selectors).toEqual([]);
+		expect(h.component().render(160).join("\n")).toContain("Informational");
+		selectLabel(h.component(), "Icon mode");
+		const icons = h.component().render(160).join("\n").replace(/\s+/g, " ");
+		expect(icons).toContain("TERM_PROGRAM=iTerm.app|WezTerm|ghostty");
+		expect(icons).toContain("nonempty KITTY_WINDOW_ID or ALACRITTY_SOCKET");
+		expect(icons).toContain("exact ZENTUI_NERD_FONTS=1|0");
+		expect(icons).toContain("otherwise ASCII");
+		expect(icons).toContain("cannot detect whether a Nerd Font is installed/configured");
+		await h.command().handler("editor", h.ctx);
+		selectLabel(h.component(), "Editor model label");
+		expect(h.component().render(160).join("\n")).toContain("Saved for other editor styles");
+		await h.command().handler("git", h.ctx);
+		expect(h.component().render(40)[1]).toContain("Footer");
+		expect(h.notifications).toContain(
+			"Footer > Git requires Starship. Current Footer is Hidden; saved settings are unchanged.",
+		);
+		await h.command().handler("footer", h.ctx);
+		expect(h.component().render(160).join("\n")).toContain(
+			"Hidden keeps only allowed extension statuses",
+		);
+		config.components.footer.style = "native";
+		await h.command().handler("footer", h.ctx);
+		expect(h.component().render(160).join("\n")).toContain("predecessor");
+	});
+	it.each([8, 12, 18, 24])(
+		"keeps selection, core help and close reachable at height %i",
+		async (height) => {
+			let component: Component | undefined;
+			const h = createHarness(
+				cloneConfig(),
+				{},
+				{
+					custom: async (factory: (...args: unknown[]) => Component) => {
+						component = factory(
+							{ terminal: { rows: height }, requestRender() {} },
+							theme(),
+							{},
+							() => {},
+						);
+					},
+				},
+			);
+			await h.command().handler("footer", h.ctx);
+			if (!component) throw new Error("No panel");
+			for (let i = 0; i < 12; i++) {
+				const rows = component.render(40);
+				expect(rows.join("\n")).not.toMatch(/samples?|synthetic/i);
+				expect(rows.length).toBeLessThanOrEqual(height);
+				expect(rows.every((row) => visibleWidth(row) <= 40)).toBe(true);
+				const text = rows.join("\n");
+				expect(text).toContain("Change");
+				expect(text).toContain("Sections");
+				expect(text).toContain("Close");
+				expect(text).toContain("> ");
+				component.handleInput("\x1b[B");
+			}
+		},
+	);
+	it("uses the injected remapped selection keys without changing global keybindings", async () => {
+		let component: Component | undefined;
+		let closed = 0;
+		const bindings: Record<string, string[]> = {
+			"tui.select.up": ["k"],
+			"tui.select.down": ["j"],
+			"tui.select.confirm": ["x"],
+			"tui.select.cancel": ["q"],
+		};
+		const h = createHarness(
+			cloneConfig(),
+			{},
+			{
+				custom: async (factory: (...args: unknown[]) => Component) => {
+					component = factory(
+						{ requestRender() {} },
+						theme(),
+						{ getKeys: (id: string) => bindings[id] ?? [] },
+						() => {
+							closed++;
+						},
+					);
+				},
+			},
+		);
+		await h.command().handler("appearance", h.ctx);
+		if (!component) throw new Error("No panel");
+		component.handleInput("j");
+		expect(focusedRow(component)).toContain("Selector borders");
+		component.handleInput("x");
+		expect(h.calls.selectors).toEqual([{ enabled: false }]);
+		const narrow = component.render(32).join("\n");
+		expect(narrow).toContain("x Change");
+		expect(narrow).toContain("Tab Sections");
+		expect(narrow).toContain("q Close");
+		expect(narrow).not.toContain("Enter/Space");
+		component.handleInput("k");
+		expect(focusedRow(component)).toContain("Preset");
+		component.handleInput("\t");
+		expect(component.render(40)[1]).toContain("Editor");
+		component.handleInput("\x1b[Z");
+		expect(component.render(40)[1]).toContain("Appearance");
+		component.handleInput("q");
+		expect(closed).toBe(1);
+	});
+});
+
+describe("settings input lifecycle continuations", () => {
+	const cases = ["Spinner speed", "Text motion speed", "Message list"].flatMap((label) =>
+		["save", "cancel", "error", "stale", "restarted", "stale-error"].map((result) => ({
+			label,
+			result,
+		})),
+	);
+	it.each(cases)(
+		"guards $label after $result and preserves the editor draft",
+		async ({ label, result }) => {
+			vi.useFakeTimers();
+			const originalDraft = "expanded paste\n".repeat(30);
+			let draft = originalDraft;
+			let opened = 0;
+			let inputs = 0;
+			const enterInput = async () => {
+				inputs++;
+				// Model Pi's snapshot/restoration around a blocking input, not host scheduling.
+				const saved = draft;
+				draft = "temporary dialog";
+				await Promise.resolve();
+				draft = saved;
+				if (result === "stale" || result === "restarted" || result === "stale-error")
+					h.sessionLifecycle.shutdown();
+				if (result === "restarted") h.sessionLifecycle.start();
+				if (result === "error" || result === "stale-error") throw new Error("dialog failed");
+				return result === "cancel" ? undefined : label === "Message list" ? "One\nTwo" : "123";
+			};
+			const h = createHarness(
+				cloneConfig(),
+				{},
+				{
+					getEditorText: () => draft,
+					setEditorText: (value: string) => {
+						draft = value;
+					},
+					input: enterInput,
+					editor: enterInput,
+					custom: async (factory: (...args: unknown[]) => Component) => {
+						const snapshot = draft;
+						let outcome: unknown;
+						const component = factory({ requestRender() {} }, theme(), {}, (value: unknown) => {
+							outcome = value;
+						});
+						if (opened++ === 0) {
+							selectLabel(component, label);
+							if (label === "Message list") component.handleInput(" ");
+							else component.handleInput(" ");
+						} else component.handleInput("\x1b");
+						draft = snapshot;
+						return outcome;
+					},
+				},
+			);
+			// Custom is reached from the slow preset without changing any speed first.
+			if (label === "Spinner speed") h.config.components.workingLine.spinnerIntervalMs = 160;
+			if (label === "Text motion speed") h.config.components.workingLine.textIntervalMs = 100;
+			await h.command().handler("working-line", h.ctx);
+			expect(inputs).toBe(1);
+			expect(draft).toBe(originalDraft);
+			const stale = ["stale", "restarted", "stale-error"].includes(result);
+			expect(opened).toBe(stale ? 1 : 2);
+			if (result === "save") expect(h.calls.workingLine).toHaveLength(1);
+			else expect(h.calls.workingLine).toEqual([]);
+			if (stale) expect(h.notifications).toEqual([]);
+			if (result === "error")
+				expect(h.notificationEvents).toEqual([
+					{ message: expect.stringContaining("dialog failed"), severity: "error" },
+				]);
+			h.sessionLifecycle.shutdown();
+			expect(vi.getTimerCount()).toBe(0);
+		},
+	);
+	it.each([false, true])("contains panel rejection (stale=%s)", async (stale) => {
+		const h = createHarness(
+			cloneConfig(),
+			{},
+			{
+				custom: async () => {
+					if (stale) h.sessionLifecycle.shutdown();
+					throw new Error("panel unavailable");
+				},
+			},
+		);
+		await h.command().handler("footer", h.ctx);
+		if (stale) expect(h.notifications).toEqual([]);
+		else
+			expect(h.notificationEvents).toEqual([
+				{ message: expect.stringContaining("panel unavailable"), severity: "error" },
+			]);
+	});
+});
+
+describe("nested Starship Footer settings navigation", () => {
+	const pages = [
+		["segments", "Segments", "Current directory"],
+		["git", "Git", "Git branch"],
+	] as const;
+
+	it.each(pages)(
+		"opens %s and restores its Footer entry without saving or replacing the editor",
+		async (route, label, firstRow) => {
+			const draft = "expanded pasted draft\n".repeat(30);
+			let text = draft;
+			const replaceEditor = vi.fn();
+			const h = createHarness(
+				cloneConfig(),
+				{},
+				{
+					getEditorText: () => text,
+					setEditorText: (value: string) => {
+						text = value;
+					},
+					setEditorComponent: replaceEditor,
+				},
+			);
+			const effects = Object.keys(h.deps)
+				.filter(
+					(key) =>
+						/^(set|apply|reconcile|migrate|requestRender)/.test(key) &&
+						typeof h.deps[key as keyof typeof h.deps] === "function",
+				)
+				.map((key) => vi.spyOn(h.deps, key as "requestRender"));
+			const before = structuredClone(h.config);
+			await h.command().handler("footer", h.ctx);
+			const panel = h.component();
+			expect(row(panel, label)).toContain("->");
+			panel.handleInput("\r");
+			expect(panel.render(40)[1]).toContain(`Footer > ${label}`);
+			expect(focusedRow(panel)).toContain(`> ${firstRow}`);
+			expect(panel.render(40).join("\n")).toContain("escape Back");
+			panel.handleInput("\x1b");
+			expect(focusedRow(panel)).toContain(`> ${label}`);
+			expect(h.doneCalls()).toBe(0);
+			panel.handleInput("\r");
+			panel.handleInput("\t");
+			expect(panel.render(40)[1]).toContain("Extension statuses");
+			panel.handleInput("\x1b[Z");
+			expect(panel.render(40)[1]).toContain("Footer");
+			panel.handleInput("\x1b");
+			expect(h.doneCalls()).toBe(1);
+			await h.command().handler(route, h.ctx);
+			expect(h.component().render(40)[1]).toContain(`Footer > ${label}`);
+			h.component().handleInput("\x1b[Z");
+			expect(h.component().render(40)[1]).toContain("Working line");
+			h.sessionLifecycle.shutdown();
+			expect(h.config).toEqual(before);
+			for (const effect of effects) expect(effect).not.toHaveBeenCalled();
+			expect(replaceEditor).not.toHaveBeenCalled();
+			expect(text).toBe(draft);
+			expect(h.command().getArgumentCompletions(route)).toContainEqual({
+				value: route,
+				label: `${route} — Footer > ${label}`,
+			});
+		},
+	);
+
+	it.each(["native", "hidden"] as const)(
+		"redirects every legacy child shortcut under %s without exposing controls or changing preferences",
+		async (style) => {
+			const config = cloneConfig();
+			config.components.footer.style = style;
+			config.components.footer.styles.starship.gitBranch.maxLength = 37;
+			config.components.footer.styles.starship.segments.cwd = false;
+			const before = structuredClone(config);
+			const h = createHarness(config);
+			for (const [route, label, firstRow] of pages) {
+				await h.command().handler(route, h.ctx);
+				const panel = h.component();
+				expect(panel.render(40)[1]).toContain("[Footer] (6/7)");
+				expectFocusOrder(panel, ["Footer style", "Color overrides"]);
+				expect(panel.render(200).join("\n")).not.toContain(firstRow);
+				expect(h.notifications.at(-1)).toBe(
+					`Footer > ${label} requires Starship. Current Footer is ${style === "native" ? "Native" : "Hidden"}; saved settings are unchanged.`,
+				);
+				panel.handleInput("\x1b");
+			}
+			expect(h.config).toEqual(before);
+			expect(h.calls.footer).toEqual([]);
+			expect(h.calls.renders.shared).toBe(0);
+		},
+	);
+
+	it.each([8, 12, 18, 24])(
+		"keeps children, Back and Sections usable at 40 columns and height %i with remapped keys and global Space navigation",
+		async (height) => {
+			const previous = getKeybindings();
+			const global = new KeybindingsManager(TUI_KEYBINDINGS, { "tui.select.down": "space" });
+			setKeybindings(global);
+			try {
+				const down = height === 8 ? " " : "j";
+				const bindings: Record<string, string[]> = {
+					"tui.select.up": ["k"],
+					"tui.select.down": [height === 8 ? "space" : "j"],
+					"tui.select.confirm": ["x"],
+					"tui.select.cancel": ["q"],
+				};
+				let panel: Component | undefined;
+				let closed = 0;
+				const h = createHarness(
+					cloneConfig(),
+					{},
+					{
+						custom: async (factory: (...args: unknown[]) => Component) => {
+							panel = factory(
+								{ terminal: { rows: height }, requestRender() {} },
+								theme(),
+								{ getKeys: (id: string) => bindings[id] ?? [] },
+								() => {
+									closed++;
+								},
+							);
+						},
+					},
+				);
+				const before = structuredClone(h.config);
+				await h.command().handler("footer", h.ctx);
+				if (!panel) throw new Error("No panel");
+				for (const [, label, firstRow] of pages) {
+					for (
+						let i = 0;
+						i < 20 && !panel.render(40).some((line) => line.startsWith(`> ${label}`));
+						i++
+					)
+						panel.handleInput(down);
+					expect(panel.render(40).join("\n")).toContain(`> ${label}`);
+					panel.handleInput("x");
+					expect(focusedRow(panel)).toContain(`> ${firstRow}`);
+					for (let i = 0; i < 15; i++) {
+						const rows = panel.render(40);
+						expect(rows.length).toBeLessThanOrEqual(height);
+						expect(rows.every((line) => visibleWidth(line) <= 40)).toBe(true);
+						expect(rows[1]).toContain(`Footer > ${label}`);
+						expect(rows.join("\n")).toContain("x Change");
+						expect(rows.join("\n")).toContain("Tab Sections");
+						expect(rows.join("\n")).toContain("q Back");
+						expect(rows.some((line) => line.startsWith("> "))).toBe(true);
+						expect(rows.join("\n")).not.toMatch(/samples?|synthetic|sonnet-long-context-preview/i);
+						panel.handleInput(down);
+					}
+					panel.handleInput("k");
+					panel.handleInput("q");
+					expect(focusedRow(panel)).toContain(`> ${label}`);
+					expect(closed).toBe(0);
+				}
+				panel.handleInput("x");
+				panel.handleInput("\t");
+				expect(panel.render(40)[1]).toContain("Extension statuses");
+				panel.handleInput("q");
+				expect(closed).toBe(1);
+				expect(h.config).toEqual(before);
+				expect(getKeybindings()).toBe(global);
+			} finally {
+				setKeybindings(previous);
+			}
+		},
+	);
+
+	it("changes only Footer Starship child settings and preserves keyed status order and colors on return", async () => {
+		const statuses = new Map([
+			["zeta", "Z"],
+			["alpha", "A"],
+		]);
+		const h = createHarness(cloneConfig(), { getActiveExtensionStatuses: () => statuses });
+		const before = structuredClone(h.config);
+		const placement = vi.spyOn(h.deps, "setExtensionStatusChoice");
+		const color = vi.spyOn(h.deps, "setExtensionStatusColorMode");
+		await h.command().handler("segments", h.ctx);
+		const panel = h.component();
+		panel.handleInput("\r");
+		panel.handleInput("\x1b");
+		openFooterPage(panel, "Git");
+		panel.handleInput("\r");
+		panel.handleInput("\x1b");
+		panel.handleInput("\t");
+		expectFocusOrder(panel, [
+			"Default placement",
+			"alpha placement",
+			"alpha color",
+			"zeta placement",
+			"zeta color",
+		]);
+		selectLabel(panel, "Default placement");
+		panel.handleInput("\r");
+		selectLabel(panel, "alpha placement");
+		panel.handleInput("\r");
+		selectLabel(panel, "zeta color");
+		panel.handleInput("\r");
+		expect(placement).toHaveBeenCalledExactlyOnceWith("alpha", "left");
+		expect(color).toHaveBeenCalledExactlyOnceWith("zeta", "original");
+		const expected = structuredClone(before);
+		expected.components.footer.styles.starship.segments.cwd = false;
+		expected.components.footer.styles.starship.segments.gitBranch = false;
+		expected.components.footer.styles.starship.extensionStatuses.defaultPlacement = "right";
+		expected.components.extensionStatuses.defaultVisibility = "hide";
+		expected.components.extensionStatuses.visibility.alpha = "show";
+		expected.components.footer.styles.starship.extensionStatuses.placements.alpha = "left";
+		expected.components.footer.styles.starship.extensionStatuses.colorModes.zeta = "original";
+		expect(h.config).toEqual(expected);
+		statuses.delete("alpha");
+		statuses.set("beta", "B");
+		panel.handleInput("\x1b[Z");
+		panel.handleInput("\t");
+		expectFocusOrder(panel, [
+			"Default placement",
+			"alpha placement",
+			"alpha color",
+			"beta placement",
+			"beta color",
+			"zeta placement",
+			"zeta color",
+		]);
+		expect(row(panel, "zeta color")).toContain("Original");
+	});
+
+	it("closes a stale child without navigating, saving or reinstalling", async () => {
+		const h = createHarness();
+		const before = structuredClone(h.config);
+		await h.command().handler("git", h.ctx);
+		h.sessionLifecycle.shutdown();
+		h.component().handleInput("\r");
+		h.component().handleInput("\x1b");
+		expect(h.doneCalls()).toBe(1);
+		expect(h.config).toEqual(before);
+		expect(h.calls.renders.shared).toBe(0);
+	});
+});
+
+describe("independent Extension statuses settings", () => {
+	it.each(["native", "hidden", "starship"] as const)(
+		"displays inherited positions and Off without saving across %s mode boundaries",
+		async (style) => {
+			for (const defaultVisibility of ["show", "hide"] as const) {
+				const config = cloneConfig();
+				config.components.footer.style = style;
+				config.components.footer.styles.starship.extensionStatuses.defaultPlacement = "off";
+				config.components.footer.styles.starship.extensionStatuses.placements.legacy = "off";
+				config.components.extensionStatuses.defaultVisibility = defaultVisibility;
+				config.components.extensionStatuses.hidden = { defaultPlacement: "middle" };
+				const h = createHarness(config, {
+					getActiveExtensionStatuses: () => new Map([["key", "RAW"]]),
+				});
+				const before = structuredClone(config);
+				const placement = vi.spyOn(h.deps, "setExtensionStatusChoice");
+				const migrate = vi.spyOn(h.deps, "migrateSelections");
+				await h.command().handler("extensions", h.ctx);
+				const panel = h.component();
+				const effective =
+					defaultVisibility === "hide" || style === "starship"
+						? "Off"
+						: style === "hidden"
+							? "Middle"
+							: "Right";
+				for (const label of ["Default placement", "key placement", "legacy placement"])
+					expect(row(panel, label).trim().split(/\s+/).at(-1)).toBe(effective);
+				panel.handleInput("\x1b");
+				expect(config).toEqual(before);
+				expect(h.calls.extensionDefaultPlacement).toEqual([]);
+				expect(placement).not.toHaveBeenCalled();
+				expect(migrate).not.toHaveBeenCalled();
+			}
+		},
+	);
+
+	it.each(["native", "hidden", "starship"] as const)(
+		"offers exactly Left / Middle / Right / Off on both %s placement controls",
+		async (style) => {
+			const config = cloneConfig();
+			config.components.footer.style = style;
+			config.components.footer.styles.starship.extensionStatuses.defaultPlacement = "left";
+			const h = createHarness(config, {
+				getActiveExtensionStatuses: () => new Map([["key", "RAW"]]),
+			});
+			const before = structuredClone(config);
+			const placement = vi.spyOn(h.deps, "setExtensionStatusChoice");
+			await h.command().handler("extensions", h.ctx);
+			const panel = h.component();
+			expectFocusOrder(panel, ["Default placement", "key placement", "key color"]);
+			expect(row(panel, "Default placement")).toMatch(/\sLeft$/);
+			expect(row(panel, "key placement")).toMatch(/\sLeft$/);
+			expect(config).toEqual(before);
+			expect(h.calls.extensionDefaultPlacement).toEqual([]);
+			expect(placement).not.toHaveBeenCalled();
+			for (const label of ["Default placement", "key placement"]) {
+				const choices: string[] = [];
+				for (let i = 0; i < 4; i++) {
+					choices.push(row(panel, label).trim().split(/\s+/).at(-1) ?? "");
+					panel.handleInput("\r");
+				}
+				expect(choices).toEqual(["Left", "Middle", "Right", "Off"]);
+				expect(row(panel, label)).toMatch(/\sLeft$/);
+			}
+			expect(h.calls.extensionDefaultPlacement).toEqual(["middle", "right", "off", "left"]);
+			expect(placement.mock.calls.map(([, choice]) => choice)).toEqual([
+				"middle",
+				"right",
+				"off",
+				"left",
+			]);
+		},
+	);
+
+	it.each(["native", "hidden", "starship"] as const)(
+		"exposes visibility and saved/observed keys under %s without changing other owners",
+		async (style) => {
+			const config = cloneConfig();
+			config.components.footer.style = style;
+			config.components.extensionStatuses.visibility = { saved: "hide" };
+			config.components.footer.styles.starship.extensionStatuses.placements.legacy = "off";
+			const h = createHarness(config, {
+				getActiveExtensionStatuses: () => new Map([["z:third-party", "RAW"]]),
+			});
+			const before = structuredClone(config);
+			await h.command().handler("extensions", h.ctx);
+			const panel = h.component();
+			expect(panel.render(40)[1]).toContain("Extension statuses");
+			expectFocusOrder(panel, [
+				"Default placement",
+				"legacy placement",
+				"legacy color",
+				"saved placement",
+				"saved color",
+				"z:third-party placement",
+				"z:third-party color",
+			]);
+			expect(panel.render(100).join("\n")).not.toContain("Inactive now");
+			expect(panel.render(160).join("\n")).not.toMatch(
+				/Hidden placement|Starship placement|visibility/,
+			);
+			expect(row(panel, "legacy placement")).toContain(
+				style === "starship" ? "Off" : style === "hidden" ? "Left" : "Right",
+			);
+			expect(config).toEqual(before);
+			selectLabel(panel, "Default placement");
+			for (let i = 0; i < (style === "hidden" ? 3 : 1); i++) panel.handleInput("\r");
+			expect(config.components.extensionStatuses.defaultVisibility).toBe("hide");
+			selectLabel(panel, "saved placement");
+			panel.handleInput("\r");
+			expect(config.components.extensionStatuses.visibility.saved).toBe("show");
+			selectLabel(panel, "z:third-party placement");
+			panel.handleInput("\r");
+			expect(config.components.extensionStatuses.visibility["z:third-party"]).toBe("show");
+			for (const owner of [
+				"editor",
+				"userMessages",
+				"workingLine",
+				"selectorBorders",
+				"thinkingSteps",
+			] as const)
+				expect(config.components[owner]).toEqual(before.components[owner]);
+			expect(h.calls.footer).toEqual([]);
+			panel.handleInput("\x1b");
+			expect(h.doneCalls()).toBe(1);
+			expect(h.command().getArgumentCompletions("extensions")).toContainEqual({
+				value: "extensions",
+				label: "extensions",
+			});
+		},
+	);
+	it("supports remapped Change/Close and narrow top-level navigation", async () => {
+		let panel: Component | undefined;
+		let closed = false;
+		const h = createHarness(
+			cloneConfig(),
+			{},
+			{
+				custom: async (factory: (...args: unknown[]) => Component) => {
+					panel = factory(
+						{ terminal: { rows: 8 }, requestRender() {} },
+						theme(),
+						{
+							getKeys: (id: string) =>
+								({
+									"tui.select.confirm": ["x"],
+									"tui.select.cancel": ["q"],
+									"tui.select.down": ["j"],
+									"tui.select.up": ["k"],
+								})[id],
+						},
+						() => {
+							closed = true;
+						},
+					);
+				},
+			},
+		);
+		await h.command().handler("extensions", h.ctx);
+		if (!panel) throw new Error("No panel");
+		expect(panel.render(40).length).toBeLessThanOrEqual(8);
+		expect(panel.render(40).every((line) => visibleWidth(line) <= 40)).toBe(true);
+		panel.handleInput("x");
+		expect(h.config.components.extensionStatuses.defaultVisibility).toBe("hide");
+		panel.handleInput("\x1b[Z");
+		expect(panel.render(40)[1]).toContain("Footer");
+		panel.handleInput("\t");
+		expect(panel.render(40)[1]).toContain("Extension statuses");
+		panel.handleInput("q");
+		expect(closed).toBe(true);
+	});
+});
+
+describe("Hidden extension color settings", () => {
+	it("cycles Original/Zentui independently of Starship colors, visibility and placement", async () => {
+		const config = cloneConfig();
+		config.components.footer.style = "hidden";
+		config.components.extensionStatuses.hidden = { placements: { "demo:build": "right" } };
+		config.components.extensionStatuses.visibility = { "demo:build": "show" };
+		const beforeFooter = structuredClone(config.components.footer);
+		const h = createHarness(config, {
+			getActiveExtensionStatuses: () => new Map([["demo:build", "\x1b[32mBUILD\x1b[0m"]]),
+		});
+		await h.command().handler("extensions", h.ctx);
+		const panel = h.component();
+		selectLabel(panel, "demo:build color");
+		expect(row(panel, "demo:build color")).toContain("Original");
+		expect(panel.render(160).join("\n")).not.toContain("Inactive now");
+		panel.handleInput("\r");
+		expect(row(panel, "demo:build color")).toContain("Zentui");
+		expect(config.components.extensionStatuses.hidden.colorModes).toEqual({
+			"demo:build": "zentui",
+		});
+		panel.handleInput("\r");
+		expect(row(panel, "demo:build color")).toContain("Original");
+		expect(config.components.extensionStatuses.hidden.colorModes).toEqual({});
+		expect(config.components.extensionStatuses.hidden.placements).toEqual({
+			"demo:build": "right",
+		});
+		expect(config.components.extensionStatuses.visibility).toEqual({ "demo:build": "show" });
+		expect(config.components.footer).toEqual(beforeFooter);
+	});
+
+	it("discovers color-only saved keys and removes their sparse override on Original", async () => {
+		const config = cloneConfig();
+		config.components.footer.style = "hidden";
+		config.components.extensionStatuses.hidden = { colorModes: { saved: "zentui" } };
+		const h = createHarness(config);
+		await h.command().handler("extensions", h.ctx);
+		const panel = h.component();
+		selectLabel(panel, "saved color");
+		expect(row(panel, "saved color")).toContain("Zentui");
+		panel.handleInput("\r");
+		expect(config.components.extensionStatuses.hidden.colorModes).toEqual({});
+		expect(panel.render(160).join("\n")).not.toContain("saved color");
+		expect(panel.render(160).join("\n")).toContain("No observed statuses");
+	});
+});
+
+describe("Hidden extension placement settings", () => {
+	it("shows only active Hidden placement controls and turns off a saved unobserved key", async () => {
+		const config = cloneConfig();
+		config.components.footer.style = "hidden";
+		config.components.extensionStatuses.hidden = {
+			defaultPlacement: "right",
+			placements: { saved: "right" },
+		};
+		const beforeFooter = structuredClone(config.components.footer);
+		const h = createHarness(config);
+		await h.command().handler("extensions", h.ctx);
+		const panel = h.component();
+		expectFocusOrder(panel, ["Default placement", "saved placement", "saved color"]);
+		selectLabel(panel, "saved placement");
+		expect(panel.render(160).join("\n")).not.toContain("Starship placement");
+		expect(row(panel, "saved placement")).toContain("Right");
+		panel.handleInput("\r");
+		expect(row(panel, "saved placement")).toContain("Off");
+		expect(config.components.extensionStatuses.hidden.placements).toEqual({ saved: "right" });
+		selectLabel(panel, "Default placement");
+		panel.handleInput("\r"); // Right -> Off; previous Hidden position remains saved
+		expect(config.components.extensionStatuses.defaultVisibility).toBe("hide");
+		expect(config.components.extensionStatuses.hidden.defaultPlacement).toBe("right");
+		panel.handleInput("\r"); // Off -> Left
+		expect(config.components.extensionStatuses.hidden.defaultPlacement).toBe("left");
+		expect(config.components.footer).toEqual(beforeFooter);
+		expect(config.components.extensionStatuses.visibility).toEqual({ saved: "hide" });
+	});
+});