@selesai/code 0.9.15 → 0.10.0

package/dist/extensions/pi-zentui/test/editor-viewport-indicators.test.ts

@@ -0,0 +1,1286 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { describe, expect, it, vi } from "vitest";
+import {
+	defaultConfig,
+	type EditorStyle,
+	type PolishedTuiConfig,
+} from "../extensions/zentui/config";
+import {
+	PolishedEditor,
+	renderWithAutocompleteCapture,
+	WrappedPolishedEditor,
+} from "../extensions/zentui/ui";
+
+function theme(): Theme {
+	return {
+		fg(_color: string, text: string) {
+			return text;
+		},
+		bold: (text: string) => text,
+		italic: (text: string) => text,
+		underline: (text: string) => text,
+		strikethrough: (text: string) => text,
+		inverse: (text: string) => text,
+	} as Theme;
+}
+
+type EditorOptions = Partial<PolishedTuiConfig["features"]> & {
+	style?: EditorStyle;
+	completionMenu?: "native" | "palette";
+};
+
+function config(
+	options: EditorOptions = {},
+	editorBorderColorMode: PolishedTuiConfig["editorBorderColorMode"] = "static",
+): PolishedTuiConfig {
+	return {
+		...defaultConfig,
+		icons: { ...defaultConfig.icons, mode: "nerd" },
+		components: {
+			...defaultConfig.components,
+			editor: {
+				...defaultConfig.components.editor,
+				enabled: true,
+				style: options.style ?? defaultConfig.components.editor.style,
+				borderColorMode: editorBorderColorMode,
+				viewportIndicators: options.viewportIndicators ?? true,
+				styles: {
+					...defaultConfig.components.editor.styles,
+					opencode: {
+						...defaultConfig.components.editor.styles.opencode,
+						completionMenu: options.completionMenu ?? "palette",
+					},
+					"opencode-copy-friendly": {
+						...defaultConfig.components.editor.styles["opencode-copy-friendly"],
+						completionMenu: options.completionMenu ?? "palette",
+					},
+				},
+			},
+		},
+		features: {
+			...defaultConfig.features,
+			...(options.editor === undefined ? {} : { editor: options.editor }),
+			...(options.statusLine === undefined ? {} : { statusLine: options.statusLine }),
+			...(options.viewportIndicators === undefined
+				? {}
+				: { viewportIndicators: options.viewportIndicators }),
+		},
+	};
+}
+
+function withEditorStyle(
+	base: PolishedTuiConfig,
+	style: PolishedTuiConfig["components"]["editor"]["style"],
+): PolishedTuiConfig {
+	return {
+		...base,
+		components: {
+			...base.components,
+			editor: { ...base.components.editor, style },
+		},
+	};
+}
+
+function nativeBorder(
+	width: number,
+	direction: "above" | "below",
+	count?: number,
+	ansi = false,
+): string {
+	const plain = count
+		? `─── ${direction === "above" ? "↑" : "↓"} ${count} more ${"─".repeat(
+				Math.max(0, width - `─── ↑ ${count} more `.length),
+			)}`
+		: "─".repeat(width);
+	return ansi ? `\x1b[90m${plain}\x1b[0m` : plain;
+}
+
+function baseEditor(options: {
+	above?: number;
+	below?: number;
+	ansi?: boolean;
+	malformedTop?: string;
+	autocomplete?: string[];
+}) {
+	const autocomplete = options.autocomplete ?? [];
+	const autocompleteList = {
+		filteredItems: autocomplete.map((value) => ({ value })),
+		selectedIndex: 0,
+		maxVisible: Math.max(1, autocomplete.length),
+		render: (_width?: number) => autocomplete,
+	};
+	return {
+		render(width: number) {
+			return [
+				options.malformedTop ?? nativeBorder(width, "above", options.above, options.ansi),
+				"typed text",
+				nativeBorder(width, "below", options.below, options.ansi),
+				...(autocomplete.length > 0 ? autocompleteList.render(width) : []),
+			];
+		},
+		invalidate() {},
+		handleInput() {},
+		getText: () => "typed text",
+		setText() {},
+		isShowingAutocomplete: () => autocomplete.length > 0,
+		autocompleteList,
+	};
+}
+
+function wrapped(
+	base: ReturnType<typeof baseEditor> | WrappedPolishedEditor,
+	features: EditorOptions = {},
+	editorBorderColorMode: PolishedTuiConfig["editorBorderColorMode"] = "static",
+): WrappedPolishedEditor {
+	return new WrappedPolishedEditor(
+		base as never,
+		theme(),
+		() => config(features, editorBorderColorMode),
+		() => ({ modelLabel: "model", providerLabel: "provider" }),
+		() => "off",
+	);
+}
+
+function standalone(style: EditorStyle = "opencode"): PolishedEditor {
+	const editor = new PolishedEditor(
+		{ requestRender() {}, terminal: { rows: 24, cols: 80 } } as never,
+		{ borderColor: (text: string) => text, selectList: {} } as never,
+		{} as never,
+		theme(),
+		() => config({ style }),
+		() => ({ modelLabel: "model", providerLabel: "provider" }),
+		() => "off",
+	);
+	editor.setText("typed text");
+	return editor;
+}
+
+const thinkingLevels = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
+type SemanticBorderState = (typeof thinkingLevels)[number] | "shell";
+
+const semanticBorderCodes: Record<SemanticBorderState, number> = {
+	off: 30,
+	minimal: 31,
+	low: 32,
+	medium: 33,
+	high: 34,
+	xhigh: 35,
+	max: 37,
+	shell: 36,
+};
+
+function semanticTheme(): Theme {
+	const base = theme();
+	return {
+		...base,
+		getThinkingBorderColor(level) {
+			const code = semanticBorderCodes[level as (typeof thinkingLevels)[number]] ?? 37;
+			return (text: string) => `\x1b[${code}m${text}\x1b[0m`;
+		},
+		getBashModeBorderColor() {
+			return (text: string) => `\x1b[${semanticBorderCodes.shell}m${text}\x1b[0m`;
+		},
+	} as Theme;
+}
+
+describe("adaptive editor border colors", () => {
+	it("keeps static wrapped-editor rendering independent of Pi's callback", () => {
+		const editor = wrapped(baseEditor({ above: 2, below: 3 }));
+		editor.borderColor = (text) => `\x1b[35m${text}\x1b[0m`;
+
+		const lines = editor.render(80);
+		expect(lines[0]).not.toContain("\x1b[35m");
+		expect(lines.at(-1)).not.toContain("\x1b[35m");
+		expect(lines[0]).toContain("↑ 2 more");
+		expect(lines.at(-1)).toContain("↓ 3 more");
+	});
+
+	it.each(["standalone", "wrapped"] as const)(
+		"follows Pi thinking and shell callback transitions in the %s editor path",
+		(editorKind) => {
+			const piTheme = semanticTheme();
+			let thinkingLevel: (typeof thinkingLevels)[number] = "off";
+			const editor =
+				editorKind === "standalone"
+					? new PolishedEditor(
+							{ requestRender() {}, terminal: { rows: 24, cols: 80 } } as never,
+							{ borderColor: (text: string) => text, selectList: {} } as never,
+							{} as never,
+							piTheme,
+							() => config({}, "adaptive"),
+							() => ({ modelLabel: "model", providerLabel: "provider" }),
+							() => thinkingLevel,
+						)
+					: new WrappedPolishedEditor(
+							baseEditor({ above: 2, below: 3 }) as never,
+							piTheme,
+							() => config({}, "adaptive"),
+							() => ({ modelLabel: "model", providerLabel: "provider" }),
+							() => thinkingLevel,
+						);
+			if (editorKind === "standalone") editor.setText("draft");
+
+			const transitions: SemanticBorderState[] = [...thinkingLevels, "shell", "xhigh", "off"];
+			for (const state of transitions) {
+				if (state === "shell") {
+					editor.borderColor = piTheme.getBashModeBorderColor();
+				} else {
+					thinkingLevel = state;
+					editor.borderColor = piTheme.getThinkingBorderColor(state);
+				}
+
+				const lines = editor.render(80);
+				const expectedCode = semanticBorderCodes[state];
+				for (const border of [lines[0] ?? "", lines.at(-1) ?? ""]) {
+					expect(border).toMatch(new RegExp(`^\\x1b\\[${expectedCode}m`));
+					for (const code of Object.values(semanticBorderCodes)) {
+						if (code !== expectedCode) expect(border).not.toContain(`\x1b[${code}m`);
+					}
+				}
+				expect(lines.every((line) => visibleWidth(line) <= 80)).toBe(true);
+			}
+		},
+	);
+
+	it("does not double-apply adaptive colors through nested branded frames", () => {
+		const inner = wrapped(baseEditor({ above: 3, below: 8 }), {}, "adaptive");
+		inner.borderColor = (text) => `\x1b[32m${text}\x1b[0m`;
+		const outer = wrapped(inner, {}, "adaptive");
+
+		const rendered = outer.render(80).join("\n");
+		expect(rendered.match(/\x1b\[32m/g)).toHaveLength(2);
+		expect(rendered.match(/↑ 3 more/g)).toHaveLength(1);
+		expect(rendered.match(/↓ 8 more/g)).toHaveLength(1);
+		expect(rendered.match(/model/g)).toHaveLength(1);
+	});
+
+	it("preserves low-rail polished viewport layout, clamping, and static fallback", () => {
+		const editor = wrapped(
+			baseEditor({ above: 123456, below: 654321, ansi: true }),
+			{ style: "opencode-copy-friendly" },
+			"adaptive",
+		);
+		editor.borderColor = () => {
+			throw new Error("theme callback failed");
+		};
+
+		const lines = editor.render(12);
+		expect(lines[0]).toContain("↑");
+		expect(lines.at(-1)).toContain("↓");
+		expect(lines.join("\n")).not.toContain("│");
+		expect(lines.every((line) => visibleWidth(line) <= 12)).toBe(true);
+	});
+});
+
+describe("editor viewport indicators", () => {
+	it.each([
+		[7, undefined, "↑ 7 more", undefined],
+		[undefined, 11, undefined, "↓ 11 more"],
+		[7, 11, "↑ 7 more", "↓ 11 more"],
+	] as const)(
+		"preserves top and bottom native counts (above=%s, below=%s)",
+		(above, below, topText, bottomText) => {
+			const lines = wrapped(baseEditor({ above, below, ansi: true })).render(80);
+			if (topText) expect(lines[0]).toContain(topText);
+			else expect(lines[0]).not.toContain("more");
+			if (bottomText) expect(lines.at(-1)).toContain(bottomText);
+			else expect(lines.at(-1)).not.toContain("more");
+		},
+	);
+
+	it("preserves large counts at ample width and clamps them at narrow ANSI-aware widths", () => {
+		const count = 123456789;
+		const editor = wrapped(baseEditor({ above: count, below: count, ansi: true }));
+
+		const ampleLines = editor.render(80);
+		expect(ampleLines[0]).toContain(`↑ ${count} more`);
+		expect(ampleLines.at(-1)).toContain(`↓ ${count} more`);
+
+		const narrowLines = editor.render(12);
+		expect(visibleWidth(narrowLines[0] ?? "")).toBe(12);
+		expect(visibleWidth(narrowLines.at(-1) ?? "")).toBe(12);
+		expect(narrowLines[0]).toContain("↑");
+		expect(narrowLines.at(-1)).toContain("↓");
+		expect(narrowLines[0]).not.toContain(`${count} more`);
+		expect(narrowLines.at(-1)).not.toContain(`${count} more`);
+	});
+
+	it("uses plain polished borders when viewport indicators are disabled", () => {
+		const lines = wrapped(baseEditor({ above: 4, below: 9 }), {
+			viewportIndicators: false,
+		}).render(80);
+		expect(lines[0]).not.toContain("more");
+		expect(lines.at(-1)).not.toContain("more");
+		expect(lines[0]).toMatch(/^─+$/);
+		expect(lines.at(-1)).toMatch(/^─+$/);
+	});
+
+	it("carries counts through nested polished wrappers without double-framing", () => {
+		const inner = wrapped(baseEditor({ above: 3, below: 8 }));
+		const lines = wrapped(inner).render(80);
+		const rendered = lines.join("\n");
+		expect(rendered.match(/↑ 3 more/g)).toHaveLength(1);
+		expect(rendered.match(/↓ 8 more/g)).toHaveLength(1);
+		expect(lines.filter((line) => line.startsWith("───") || /^─+$/.test(line))).toHaveLength(2);
+		expect(rendered.match(/model/g)).toHaveLength(1);
+
+		const narrowLines = wrapped(inner).render(8);
+		expect(narrowLines).toHaveLength(6);
+		expect(narrowLines[0]).toContain("↑");
+		expect(narrowLines.at(-1)).toContain("↓");
+	});
+
+	it.each(["opencode", "opencode-copy-friendly"] as const)(
+		"renders one completion palette through nested %s wrappers",
+		(style) => {
+			const base = baseEditor({ autocomplete: ["→ suggestion-one", "  suggestion-two"] });
+			const renderAutocomplete = base.autocompleteList.render;
+			let calls = 0;
+			base.autocompleteList.render = (width) => {
+				calls += 1;
+				return renderAutocomplete(width);
+			};
+			const inner = wrapped(base, { style });
+			const lines = wrapped(inner, { style }).render(50);
+			const rendered = lines.join("\n");
+			expect(calls).toBe(1);
+			expect(rendered.match(/suggestion-one/g)).toHaveLength(1);
+			expect(rendered.match(/suggestion-two/g)).toHaveLength(1);
+			expect(rendered.match(/↑↓ Navigate/g)).toHaveLength(1);
+			expect(rendered).not.toContain("→ suggestion-one");
+		},
+	);
+
+	it.each(["opencode", "opencode-copy-friendly"] as const)(
+		"keeps ANSI, Unicode, and native count autocomplete rows raw after the terminal bottom border in %s",
+		(style) => {
+			const suggestions = [
+				"\x1b[31msuggestion-one\x1b[0m",
+				"emoji 😀 e\u0301 界",
+				"\x1b[90m (1/47) \x1b[0m",
+			];
+			const lines = wrapped(baseEditor({ below: 5, autocomplete: suggestions }), {
+				style,
+				completionMenu: "native",
+			}).render(80);
+			const bottom = lines.findIndex((line) => line.includes("↓ 5 more"));
+			expect(lines.some((line) => line.includes("├") || line.includes("┤"))).toBe(false);
+			expect(bottom).toBe(lines.length - suggestions.length - 1);
+			expect(lines.slice(bottom + 1)).toEqual(suggestions);
+			expect(lines.every((line) => visibleWidth(line) <= 80)).toBe(true);
+		},
+	);
+
+	it.each(["opencode", "opencode-copy-friendly"] as const)(
+		"renders the default completion palette once without the native count row in %s",
+		(style) => {
+			const suggestions = ["\x1b[1m→ settings\x1b[0m", "  files", "\x1b[90m (1/47) \x1b[0m"];
+			const lines = wrapped(baseEditor({ autocomplete: suggestions }), { style }).render(40);
+			const plain = lines.map((line) => line.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, ""));
+			expect(plain).toContain("  settings".padEnd(40));
+			expect(plain).toContain("  files".padEnd(40));
+			expect(plain.some((line) => line.includes("→"))).toBe(false);
+			expect(plain.some((line) => line.includes("(1/47)"))).toBe(false);
+			expect(plain.at(-1)).toContain("↑↓ Navigate");
+			expect(plain.filter((line) => /^─+$/.test(line.trim()))).toHaveLength(3);
+			expect(lines.every((line) => visibleWidth(line) <= 40)).toBe(true);
+		},
+	);
+
+	it.each(["opencode", "accent-rail"] as const)(
+		"fails open from the same render when a third-party %s editor rewrites captured autocomplete rows",
+		(style) => {
+			for (const mutation of ["replace", "reorder"] as const) {
+				const suggestions = ["→ original-one", "  original-two"];
+				const base = baseEditor({ autocomplete: suggestions });
+				const nativeRender = base.render.bind(base);
+				const widths: number[] = [];
+				let lastOutput: string[] = [];
+				base.render = (width: number) => {
+					widths.push(width);
+					const rendered = nativeRender(width);
+					const editorRows = rendered.slice(0, -suggestions.length);
+					const autocompleteRows = rendered.slice(-suggestions.length);
+					const mutatedRows =
+						mutation === "replace"
+							? ["replacement-one", "replacement-two"]
+							: [...autocompleteRows].reverse();
+					lastOutput = [...editorRows, ...mutatedRows];
+					return lastOutput;
+				};
+
+				const lines = wrapped(base, { style }).render(40);
+				expect(lines).toEqual(lastOutput);
+				expect(widths).toHaveLength(1);
+				expect(widths[0]).toBeLessThan(40);
+				expect(lines.join("\n")).not.toContain("↑↓ Navigate");
+				expect(lines.some((line) => line.startsWith("▎"))).toBe(false);
+			}
+		},
+	);
+
+	it.each([
+		["ASCII spaces", "   ", true],
+		["a tab", "\t", false],
+		["a newline", "\n", false],
+		["a non-breaking space", "\u00a0", false],
+		["a Unicode em space", "\u2003", false],
+	] as const)("treats trailing %s as %s autocomplete padding", (_label, trailing, accepted) => {
+		const suggestions = ["→ original-one", "  original-two"];
+		const base = baseEditor({ autocomplete: suggestions });
+		const nativeRender = base.render.bind(base);
+		const widths: number[] = [];
+		let sameRenderRows: string[] = [];
+		base.render = (width: number) => {
+			widths.push(width);
+			const rendered = nativeRender(width);
+			const editorRows = rendered.slice(0, -suggestions.length);
+			sameRenderRows = [
+				...editorRows,
+				...rendered.slice(-suggestions.length).map((line) => `${line}${trailing}`),
+			];
+			return sameRenderRows;
+		};
+
+		const lines = wrapped(base, { style: "opencode" }).render(40);
+		expect(widths).toHaveLength(1);
+		if (accepted) {
+			expect(lines.join("\n")).toContain("↑↓ Navigate");
+		} else {
+			expect(lines).toEqual(sameRenderRows);
+			expect(lines.join("\n")).not.toContain("↑↓ Navigate");
+		}
+	});
+
+	it.each(["opencode", "accent-rail"] as const)(
+		"preserves same-render %s rows when autocomplete ownership changes during rendering",
+		(style) => {
+			const suggestions = ["→ original-one", "  original-two"];
+			const base = baseEditor({ autocomplete: suggestions });
+			const nativeRender = base.render.bind(base);
+			const replacement = vi.fn(() => ["replacement"]);
+			const widths: number[] = [];
+			let sameRenderRows: string[] = [];
+			base.render = (width: number) => {
+				widths.push(width);
+				sameRenderRows = nativeRender(width);
+				base.autocompleteList.render = replacement;
+				return sameRenderRows;
+			};
+
+			const lines = wrapped(base, { style }).render(40);
+			expect(lines).toEqual(sameRenderRows);
+			expect(widths).toHaveLength(1);
+			expect(replacement).not.toHaveBeenCalled();
+			expect(base.autocompleteList.render).toBe(replacement);
+			expect(lines.join("\n")).not.toContain("↑↓ Navigate");
+			expect(lines.some((line) => line.startsWith("▎"))).toBe(false);
+		},
+	);
+
+	it.each(["opencode", "opencode-copy-friendly"] as const)(
+		"keeps exact no-autocomplete output in %s",
+		(style) => {
+			const ordinary = baseEditor({ below: 2 });
+			const guarded = baseEditor({ below: 2 });
+			guarded.autocompleteList.render = () => {
+				throw new Error("must not inspect an inactive menu");
+			};
+			expect(wrapped(guarded, { style }).render(80)).toEqual(
+				wrapped(ordinary, { style }).render(80),
+			);
+		},
+	);
+
+	it.each(["opencode", "opencode-copy-friendly"] as const)(
+		"keeps raw trailing autocomplete width-safe at widths 5 and 4 in %s",
+		(style) => {
+			for (const width of [5, 4]) {
+				const lines = wrapped(baseEditor({ autocomplete: ["界😀e\u0301"] }), {
+					style,
+					completionMenu: "native",
+				}).render(width);
+				expect(lines.some((line) => line.includes("├") || line.includes("┤"))).toBe(false);
+				expect(lines.at(-2)).toMatch(/^─+$/);
+				expect(visibleWidth(lines.at(-1) ?? "")).toBeLessThanOrEqual(width);
+				expect(lines.every((line) => visibleWidth(line) <= width)).toBe(true);
+			}
+		},
+	);
+
+	it("rerenders standalone Opencode at caller width when reduced-width autocomplete rendering throws", () => {
+		const editor = standalone();
+		let calls = 0;
+		Object.assign(editor as unknown as Record<string, unknown>, {
+			autocompleteState: {},
+			autocompleteList: {
+				render() {
+					calls += 1;
+					if (calls === 1) throw new Error("reduced-width autocomplete failed");
+					return ["caller-width-suggestion"];
+				},
+			},
+		});
+		const lines = editor.render(80);
+		expect(calls).toBe(2);
+		expect(lines.some((line) => line.includes("├"))).toBe(false);
+		expect(lines).toContain("caller-width-suggestion".padEnd(80));
+		expect(lines.every((line) => visibleWidth(line) <= 80)).toBe(true);
+	});
+
+	it("captures standalone Opencode autocomplete from the base render without an extra render", () => {
+		const editor = standalone("opencode-copy-friendly");
+		let calls = 0;
+		Object.assign(editor as unknown as Record<string, unknown>, {
+			autocompleteState: {},
+			autocompleteList: {
+				render() {
+					calls += 1;
+					return calls === 2 ? [] : ["caller-width-suggestion"];
+				},
+			},
+		});
+		const lines = editor.render(80);
+		expect(calls).toBe(1);
+		expect(lines.some((line) => line.includes("├"))).toBe(false);
+		expect(lines.some((line) => line.includes("caller-width-suggestion"))).toBe(true);
+		expect(lines.every((line) => visibleWidth(line) <= 80)).toBe(true);
+	});
+
+	it.each(["opencode", "accent-rail"] as const)(
+		"keeps standalone %s autocomplete to one render when ownership changes",
+		(style) => {
+			const editor = standalone(style);
+			const replacement = vi.fn(() => ["replacement"]);
+			let calls = 0;
+			const autocompleteList = {
+				filteredItems: [{ value: "original" }],
+				selectedIndex: 0,
+				maxVisible: 1,
+				render() {
+					calls += 1;
+					autocompleteList.render = replacement;
+					return ["→ original"];
+				},
+			};
+			Object.assign(editor as unknown as Record<string, unknown>, {
+				autocompleteState: {},
+				autocompleteList,
+			});
+
+			const lines = editor.render(80);
+			expect(calls).toBe(1);
+			expect(replacement).not.toHaveBeenCalled();
+			expect(autocompleteList.render).toBe(replacement);
+			expect(lines.some((line) => line.includes("→ original"))).toBe(true);
+			expect(lines.join("\n")).not.toContain("↑↓ Navigate");
+			expect(lines.some((line) => line.startsWith("▎"))).toBe(false);
+		},
+	);
+
+	it.each([
+		"── ↑ 7 more ─────────",
+		"─── ↓ 7 more ─────────",
+		"─── ↑ 07 more ─────────",
+		"prefix ─── ↑ 7 more ─────────",
+		"[muted]─── ↑ 7 more ─────────[/muted]",
+	])("fails open for an unknown top border form: %s", (malformedTop) => {
+		const lines = wrapped(baseEditor({ below: 2, malformedTop })).render(80);
+		expect(lines[0]).toBe(malformedTop);
+		expect(lines).toContain("typed text");
+		expect(lines.at(-1)).toContain("↓ 2 more");
+	});
+
+	it("preserves every row from a minimal public-contract third-party editor", () => {
+		let text = "draft";
+		const inputs: string[] = [];
+		const base = {
+			render: () => ["third-party header", text, "third-party help"],
+			invalidate() {},
+			handleInput(data: string) {
+				inputs.push(data);
+				text += data;
+			},
+			getText: () => text,
+			setText(next: string) {
+				text = next;
+			},
+		};
+		const editor = wrapped(base as never);
+
+		expect(editor.render(80)).toEqual(["third-party header", "draft", "third-party help"]);
+		editor.handleInput("!");
+		expect(editor.getText()).toBe("draft!");
+		expect(inputs).toEqual(["!"]);
+	});
+
+	it("preserves autocomplete rows when Pi-private inspection fields are absent", () => {
+		const base = {
+			render: (width: number) => [
+				nativeBorder(width, "above"),
+				"typed text",
+				nativeBorder(width, "below"),
+				"suggestion-one",
+				"suggestion-two",
+			],
+			invalidate() {},
+			handleInput() {},
+			getText: () => "typed text",
+			setText() {},
+		};
+
+		const lines = wrapped(base as never).render(80);
+		expect(lines).toContain("typed text");
+		expect(lines).toContain("suggestion-one");
+		expect(lines).toContain("suggestion-two");
+		expect(lines).toHaveLength(5);
+	});
+
+	it.each(["visibility method", "autocomplete getter", "autocomplete render"])(
+		"returns base rows when %s throws",
+		(failure) => {
+			const rendered = ["header", "typed text", "suggestion"];
+			const base: Record<string, unknown> = {
+				render: () => rendered,
+				invalidate() {},
+				handleInput() {},
+				getText: () => "typed text",
+				setText() {},
+			};
+			if (failure === "visibility method") {
+				base.isShowingAutocomplete = () => {
+					throw new Error("visibility failed");
+				};
+			} else {
+				base.isShowingAutocomplete = () => true;
+				if (failure === "autocomplete getter") {
+					Object.defineProperty(base, "autocompleteList", {
+						get() {
+							throw new Error("getter failed");
+						},
+					});
+				} else {
+					base.autocompleteList = {
+						render() {
+							throw new Error("render failed");
+						},
+					};
+				}
+			}
+
+			expect(wrapped(base as never).render(80)).toEqual(rendered);
+		},
+	);
+
+	it("does not trust or invoke a generic editor's spoofed polished-frame splitter", () => {
+		const widths: number[] = [];
+		const spoofedSplit = vi.fn(() => ({
+			editorLines: ["spoofed"],
+			trailingLines: [],
+			viewport: {},
+		}));
+		const base = {
+			render(width: number) {
+				widths.push(width);
+				return [nativeBorder(width, "above"), "typed text", nativeBorder(width, "below")];
+			},
+			invalidate() {},
+			handleInput() {},
+			getText: () => "typed text",
+			setText() {},
+			[Symbol.for("pi-zentui.polished-frame")]: spoofedSplit,
+		};
+		expect(wrapped(base as never).render(80)).toEqual([
+			nativeBorder(78, "above"),
+			"typed text",
+			nativeBorder(78, "below"),
+		]);
+		expect(widths).toEqual([78]);
+		expect(spoofedSplit).not.toHaveBeenCalled();
+	});
+
+	it("fails open for polished-looking rows without exact module-owned array provenance", () => {
+		const trusted = wrapped(baseEditor({ above: 2, below: 3 })).render(80);
+		const staleClone = trusted.slice();
+		const base = {
+			render: () => staleClone,
+			invalidate() {},
+			handleInput() {},
+			getText: () => "typed text",
+			setText() {},
+		};
+
+		const lines = wrapped(base as never).render(80);
+		expect(lines).toEqual(staleClone);
+		expect(lines.join("\n").match(/model/g)).toHaveLength(1);
+	});
+
+	it("rejects in-place mutation of an otherwise provenance-owned rendered array", () => {
+		const rendered = wrapped(baseEditor({ above: 2, below: 3 })).render(80);
+		rendered[1] = "changed-row";
+		rendered.splice(2, 0, "added-row");
+		const base = {
+			render: () => rendered,
+			invalidate() {},
+			handleInput() {},
+			getText: () => "typed text",
+			setText() {},
+		};
+
+		const lines = wrapped(base as never).render(80);
+		expect(lines).toEqual(rendered);
+		expect(lines).toContain("changed-row");
+		expect(lines).toContain("added-row");
+	});
+
+	it("falls back to caller-width rendering when the inner-width probe throws", () => {
+		const widths: number[] = [];
+		const base = {
+			render(width: number) {
+				widths.push(width);
+				if (width < 80) throw new Error("inner-width render failed");
+				return ["caller-width-header", "x".repeat(width + 4), "caller-width-help"];
+			},
+			invalidate() {},
+			handleInput() {},
+			getText: () => "typed text",
+			setText() {},
+		};
+
+		const lines = wrapped(base as never).render(80);
+		expect(widths).toEqual([78, 80]);
+		expect(lines[0]).toBe("caller-width-header");
+		expect(lines.at(-1)).toBe("caller-width-help");
+		expect(lines.every((line) => visibleWidth(line) <= 80)).toBe(true);
+	});
+
+	it("returns unknown third-party output from the completed same-width probe", () => {
+		const widths: number[] = [];
+		const base = {
+			render(width: number) {
+				widths.push(width);
+				return [`header-${width}`, "x".repeat(width + 5), `help-${width}`];
+			},
+			invalidate() {},
+			handleInput() {},
+			getText: () => "typed text",
+			setText() {},
+		};
+
+		const lines = wrapped(base as never).render(80);
+		expect(widths).toEqual([78]);
+		expect(lines[0]).toBe("header-78");
+		expect(lines.at(-1)).toBe("help-78");
+		expect(lines.every((line) => visibleWidth(line) <= 80)).toBe(true);
+	});
+
+	it("only exposes optional editor methods implemented by the base", () => {
+		const withoutCapabilities = wrapped({
+			render: () => ["plain"],
+			invalidate() {},
+			handleInput() {},
+			getText: () => "",
+			setText() {},
+		} as never);
+		for (const method of [
+			"addToHistory",
+			"insertTextAtCursor",
+			"setAutocompleteProvider",
+			"setPaddingX",
+			"setAutocompleteMaxVisible",
+		]) {
+			expect(method in withoutCapabilities).toBe(false);
+		}
+
+		const calls: string[] = [];
+		const withCapabilities = wrapped({
+			render: () => ["plain"],
+			invalidate() {},
+			handleInput() {},
+			getText: () => "",
+			setText() {},
+			addToHistory: () => calls.push("history"),
+			insertTextAtCursor: () => calls.push("insert"),
+			setAutocompleteProvider: () => calls.push("autocomplete"),
+			setPaddingX: () => calls.push("padding"),
+			setAutocompleteMaxVisible: () => calls.push("max-visible"),
+		} as never);
+		withCapabilities.addToHistory?.("history");
+		withCapabilities.insertTextAtCursor?.("insert");
+		withCapabilities.setAutocompleteProvider?.({} as never);
+		withCapabilities.setPaddingX?.(1);
+		withCapabilities.setAutocompleteMaxVisible?.(5);
+		expect(calls).toEqual(["history", "insert", "autocomplete", "padding", "max-visible"]);
+	});
+
+	it("keeps every rendered line within narrow ANSI-aware widths in both chrome modes", () => {
+		for (const style of ["opencode", "opencode-copy-friendly"] as const) {
+			for (const width of [3, 8, 12, 16]) {
+				const lines = wrapped(baseEditor({ above: 12, below: 34, ansi: true }), {
+					style,
+				}).render(width);
+				expect(lines.every((line) => visibleWidth(line) <= width)).toBe(true);
+			}
+		}
+	});
+
+	it("matches Pi's complete native form rather than reconstructing a truncated count", () => {
+		const truncatedNativeTop = truncateToWidth("─── ↑ 12 more ", 10, "");
+		const lines = wrapped(baseEditor({ below: 1, malformedTop: truncatedNativeTop })).render(40);
+		expect(lines[0]).toBe(truncatedNativeTop);
+	});
+});
+
+describe("same-render autocomplete capture", () => {
+	function source(render: (width: number) => string[]) {
+		return {
+			isShowingAutocomplete: () => true,
+			autocompleteList: {
+				filteredItems: [{ value: "one" }],
+				selectedIndex: 0,
+				maxVisible: 1,
+				render,
+			},
+		};
+	}
+
+	it("restores the exact predecessor after descriptor flags mutate", () => {
+		const predecessor = vi.fn(() => ["one"]);
+		const autocomplete = source(predecessor);
+		const original = Object.getOwnPropertyDescriptor(autocomplete.autocompleteList, "render");
+		const result = renderWithAutocompleteCapture(autocomplete as never, () => {
+			const rows = autocomplete.autocompleteList.render(20);
+			const wrapper = autocomplete.autocompleteList.render;
+			Object.defineProperty(autocomplete.autocompleteList, "render", {
+				value: wrapper,
+				configurable: true,
+				enumerable: false,
+				writable: false,
+			});
+			return rows;
+		});
+		expect(result.capture?.compatible).toBe(false);
+		expect(Object.getOwnPropertyDescriptor(autocomplete.autocompleteList, "render")).toEqual(
+			original,
+		);
+		expect(predecessor).toHaveBeenCalledTimes(1);
+	});
+
+	it("preserves a synchronous third-party replacement and suppresses metadata", () => {
+		const autocomplete = source(vi.fn(() => ["one"]));
+		const replacement = vi.fn(() => ["replacement"]);
+		const result = renderWithAutocompleteCapture(autocomplete as never, () => {
+			const rows = autocomplete.autocompleteList.render(20);
+			autocomplete.autocompleteList.render = replacement;
+			return rows;
+		});
+		expect(result.capture?.compatible).toBe(false);
+		expect(autocomplete.autocompleteList.render).toBe(replacement);
+	});
+
+	it("restores through a cleanup descriptor trap when the wrapper is still owned", () => {
+		const predecessor = vi.fn(() => ["one"]);
+		const target = source(predecessor).autocompleteList;
+		let descriptorReads = 0;
+		const proxy = new Proxy(target, {
+			getOwnPropertyDescriptor(current, property) {
+				descriptorReads++;
+				if (descriptorReads === 2) throw new Error("descriptor trap");
+				return Reflect.getOwnPropertyDescriptor(current, property);
+			},
+		});
+		const result = renderWithAutocompleteCapture(
+			{ isShowingAutocomplete: () => true, autocompleteList: proxy } as never,
+			() => proxy.render(20),
+		);
+		expect(result.capture?.compatible).toBe(false);
+		expect(target.render).toBe(predecessor);
+		expect(predecessor).toHaveBeenCalledTimes(1);
+	});
+
+	it.each(["opencode", "accent-rail"] as const)(
+		"fails open from one %s render when inherited-renderer cleanup is rejected",
+		(style) => {
+			const predecessor = vi.fn((_width: number) => ["→ original"]);
+			const target = Object.assign(
+				Object.create({ render: predecessor }) as {
+					render: (width: number) => string[];
+					filteredItems: Array<{ value: string }>;
+					selectedIndex: number;
+					maxVisible: number;
+				},
+				{
+					filteredItems: [{ value: "original" }],
+					selectedIndex: 0,
+					maxVisible: 1,
+				},
+			);
+			const autocompleteList = new Proxy(target, {
+				deleteProperty: () => false,
+			});
+			let renderCalls = 0;
+			let sameRenderRows: string[] = [];
+			const base = {
+				render(width: number) {
+					renderCalls++;
+					sameRenderRows = [
+						nativeBorder(width, "above"),
+						"typed text",
+						nativeBorder(width, "below"),
+						...autocompleteList.render(width),
+					];
+					return sameRenderRows;
+				},
+				invalidate() {},
+				handleInput() {},
+				getText: () => "typed text",
+				setText() {},
+				isShowingAutocomplete: () => true,
+				autocompleteList,
+			};
+
+			const lines = wrapped(base as never, { style }).render(40);
+			expect(lines).toEqual(sameRenderRows);
+			expect(renderCalls).toBe(1);
+			expect(predecessor).toHaveBeenCalledTimes(1);
+			expect(Object.hasOwn(target, "render")).toBe(true);
+			expect(lines.join("\n")).not.toContain("↑↓ Navigate");
+			expect(lines.some((line) => line.startsWith("▎"))).toBe(false);
+		},
+	);
+
+	it("restores after throwing and supports nested capture without extra renders", () => {
+		const predecessor = vi.fn(() => ["one"]);
+		const autocomplete = source(predecessor);
+		const original = autocomplete.autocompleteList.render;
+		expect(() =>
+			renderWithAutocompleteCapture(autocomplete as never, () => {
+				autocomplete.autocompleteList.render(20);
+				throw new Error("render failed");
+			}),
+		).toThrow("render failed");
+		expect(autocomplete.autocompleteList.render).toBe(original);
+
+		predecessor.mockClear();
+		const outer = renderWithAutocompleteCapture(autocomplete as never, () =>
+			renderWithAutocompleteCapture(autocomplete as never, () =>
+				autocomplete.autocompleteList.render(20),
+			),
+		);
+		expect(predecessor).toHaveBeenCalledTimes(1);
+		expect(outer.capture).toMatchObject({ compatible: true, called: 1 });
+		expect(outer.value.capture).toMatchObject({ compatible: true, called: 1 });
+		expect(autocomplete.autocompleteList.render).toBe(original);
+	});
+});
+
+describe("accent rail editor integration", () => {
+	it("decorates trusted wrapped input and autocomplete rows", () => {
+		const editor = wrapped(baseEditor({ autocomplete: ["one", "two"] }), {
+			style: "accent-rail",
+		});
+		const lines = editor.render(24);
+		expect(lines).toHaveLength(3);
+		expect(lines[0]).toMatch(/^▎ typed text/);
+		expect(lines.every((line) => visibleWidth(line) === 24)).toBe(true);
+		expect(lines.slice(1).map((line) => line.trimEnd())).toEqual(["one", "two"]);
+	});
+
+	it("fails open from the reduced same-render rows for untrusted third-party output", () => {
+		const base = baseEditor({ malformedTop: "third-party header" });
+		const editor = wrapped(base, { style: "accent-rail" });
+		const lines = editor.render(24);
+		expect(lines).toEqual(base.render(22));
+		expect(lines.join("\n")).not.toContain("▎");
+	});
+
+	it("renders the standalone editor with the same accent rail", () => {
+		const lines = standalone("accent-rail").render(24);
+		expect(lines.some((line) => line.startsWith("▎ "))).toBe(true);
+		expect(lines.every((line) => visibleWidth(line) <= 24)).toBe(true);
+	});
+});
+
+describe("minimalist editor integration", () => {
+	it("switches renderer modes without replacing the wrapped editor", () => {
+		let current = config();
+		const base = baseEditor({});
+		const editor = new WrappedPolishedEditor(
+			base as never,
+			theme(),
+			() => current,
+			() => ({ modelLabel: "model", providerLabel: "provider" }),
+			() => "off",
+			() => ({ cwd: "/tmp/project", modelLabel: "model", costLabel: "$0.100" }),
+		);
+
+		expect(editor.render(80)[0]).toMatch(/^─+$/);
+		current = withEditorStyle(current, "minimalist");
+		const minimalist = editor.render(80);
+		expect(minimalist[0]).toMatch(/^╭.*╮$/);
+		expect(minimalist.at(-1)).toMatch(/^╰.*╯$/);
+		expect(minimalist.join("\n")).toContain("$0.100 – model");
+	});
+
+	it("cycles one wrapped adapter through every style without nesting owned chrome", () => {
+		let current = config({ style: "opencode" });
+		const rawWidths: number[] = [];
+		const raw = baseEditor({});
+		const rawRender = raw.render.bind(raw);
+		raw.render = (width: number) => {
+			rawWidths.push(width);
+			return rawRender(width);
+		};
+		const inner = new WrappedPolishedEditor(
+			raw as never,
+			theme(),
+			() => config({ style: "opencode" }),
+			() => ({ modelLabel: "model", providerLabel: "provider" }),
+			() => "off",
+		);
+		const decoration = vi.fn();
+		const editor = new WrappedPolishedEditor(
+			inner as never,
+			theme(),
+			() => current,
+			() => ({ modelLabel: "model", providerLabel: "provider" }),
+			() => "off",
+			() => ({ cwd: "/tmp/project", modelLabel: "model", costLabel: "$0.100" }),
+			decoration,
+		);
+
+		const polished = editor.render(40);
+		current = withEditorStyle(current, "opencode-copy-friendly");
+		const lowRail = editor.render(40);
+		current = withEditorStyle(current, "accent-rail");
+		const accentRail = editor.render(40);
+		current = withEditorStyle(current, "minimalist");
+		const minimalist = editor.render(40);
+		current = withEditorStyle(current, "opencode");
+		const polishedAgain = editor.render(40);
+
+		expect(rawWidths).toEqual([36, 38, 36, 34, 36]);
+		expect(polished.join("\n").match(/provider/g)).toHaveLength(1);
+		expect(lowRail.join("\n").match(/provider/g)).toHaveLength(1);
+		expect(accentRail[0]).toMatch(/^▎ typed text/);
+		expect(accentRail.join("\n")).not.toContain("provider");
+		expect(minimalist[0]).toMatch(/^╭.*╮$/);
+		expect(minimalist.at(-1)).toMatch(/^╰.*╯$/);
+		expect(polishedAgain.join("\n").match(/provider/g)).toHaveLength(1);
+		expect(polishedAgain.join("\n")).not.toContain("╭");
+		expect(decoration.mock.calls.map(([active]) => active)).toEqual([
+			false,
+			false,
+			false,
+			true,
+			false,
+		]);
+	});
+
+	it("places native viewport counts at the far left before minimalist metadata", () => {
+		const editor = new WrappedPolishedEditor(
+			baseEditor({ above: 7, below: 11 }) as never,
+			theme(),
+			() => withEditorStyle(config(), "minimalist"),
+			() => ({ modelLabel: "model", providerLabel: "provider" }),
+			() => "off",
+			() => ({
+				cwd: "/tmp/project",
+				branch: "main",
+				ahead: 2,
+				behind: 1,
+				agentDurationMs: 5000,
+			}),
+		);
+
+		const lines = editor.render(80);
+		expect(lines[0]).toMatch(/^╭─ ↑ 7 more · 5s/);
+		expect(lines.at(-1)).toMatch(/^╰─ ↓ 11 more · main ↑2 ↓1/);
+	});
+
+	it("honors the shared viewport indicator toggle in minimalist mode", () => {
+		const editor = new WrappedPolishedEditor(
+			baseEditor({ above: 7, below: 11 }) as never,
+			theme(),
+			() => withEditorStyle(config({ viewportIndicators: false }), "minimalist"),
+			() => ({ modelLabel: "model", providerLabel: "provider" }),
+			() => "off",
+			() => ({ cwd: "/tmp/project" }),
+		);
+
+		expect(editor.render(80).join("\n")).not.toContain("more");
+	});
+
+	it("keeps known autocomplete rows inside the minimalist frame", () => {
+		const base = baseEditor({ below: 5, autocomplete: ["one", "two"] });
+		const editor = new WrappedPolishedEditor(
+			base as never,
+			theme(),
+			() => withEditorStyle(config(), "minimalist"),
+			() => ({ modelLabel: "model", providerLabel: "provider" }),
+			() => "off",
+			() => ({ cwd: "/tmp" }),
+		);
+		const lines = editor.render(40);
+		expect(lines.some((line) => /^├─+┤$/.test(line))).toBe(true);
+		expect(lines.findIndex((line) => line.includes("one"))).toBeGreaterThan(
+			lines.findIndex((line) => line.startsWith("├")),
+		);
+		expect(lines.findIndex((line) => line.includes("one"))).toBeLessThan(lines.length - 1);
+		expect(lines.at(-1)).toContain("↓ 5 more");
+		expect(lines.at(-1)).toMatch(/^╰.*╯$/);
+	});
+
+	it("fails open from the reduced same-render rows for unknown third-party output", () => {
+		const widths: number[] = [];
+		const decoration = vi.fn();
+		const base = {
+			render(width: number) {
+				widths.push(width);
+				return [`header-${width}`, "body", `help-${width}`];
+			},
+			invalidate() {},
+			handleInput() {},
+			getText: () => "body",
+			setText() {},
+		};
+		const editor = new WrappedPolishedEditor(
+			base as never,
+			theme(),
+			() => withEditorStyle(config(), "minimalist"),
+			() => ({ modelLabel: "model", providerLabel: "provider" }),
+			() => "off",
+			() => ({ cwd: "/tmp" }),
+			decoration,
+		);
+		expect(editor.render(40)).toEqual(["header-36", "body", "help-36"]);
+		expect(widths).toEqual([36]);
+		expect(decoration).toHaveBeenLastCalledWith(false);
+	});
+
+	it("unwraps module-owned polished chrome, viewport counts, and autocomplete", () => {
+		const inner = wrapped(baseEditor({ above: 3, below: 8, autocomplete: ["one", "two"] }));
+		const outer = new WrappedPolishedEditor(
+			inner as never,
+			theme(),
+			() => withEditorStyle(config(), "minimalist"),
+			() => ({ modelLabel: "outer", providerLabel: "provider" }),
+			() => "off",
+			() => ({ cwd: "/tmp", modelLabel: "minimal-model" }),
+		);
+
+		const lines = outer.render(80);
+		const rendered = lines.join("\n");
+		expect(lines[0]).toMatch(/^╭.*╮$/);
+		expect(lines.at(-1)).toMatch(/^╰.*╯$/);
+		expect(rendered).toContain("minimal-model");
+		expect(rendered).not.toContain("provider");
+		expect(rendered.match(/minimal-model/g)).toHaveLength(1);
+		expect(rendered.match(/↑ 3 more/g)).toHaveLength(1);
+		expect(rendered.match(/↓ 8 more/g)).toHaveLength(1);
+		expect(lines.some((line) => /^├─+┤$/.test(line))).toBe(true);
+		expect(lines.filter((line) => line.includes("one") || line.includes("two"))).toHaveLength(2);
+	});
+
+	it("rejects mutated module-owned polished provenance in minimalist mode", () => {
+		const owned = wrapped(baseEditor({ above: 2, below: 3 })).render(36);
+		owned[1] = "mutated-row";
+		const base = {
+			render: () => owned,
+			invalidate() {},
+			handleInput() {},
+			getText: () => "typed text",
+			setText() {},
+		};
+		const decoration = vi.fn();
+		const editor = new WrappedPolishedEditor(
+			base as never,
+			theme(),
+			() => withEditorStyle(config(), "minimalist"),
+			() => ({ modelLabel: "model", providerLabel: "provider" }),
+			() => "off",
+			() => ({ cwd: "/tmp" }),
+			decoration,
+		);
+
+		expect(editor.render(40)).toEqual(owned);
+		expect(decoration).toHaveBeenLastCalledWith(false);
+	});
+
+	it("falls back at four columns and decorates after resizing to five", () => {
+		const widths: number[] = [];
+		const decoration = vi.fn();
+		const base = baseEditor({});
+		const renderBase = base.render.bind(base);
+		base.render = (width: number) => {
+			widths.push(width);
+			return renderBase(width);
+		};
+		const editor = new WrappedPolishedEditor(
+			base as never,
+			theme(),
+			() => withEditorStyle(config(), "minimalist"),
+			() => ({ modelLabel: "model", providerLabel: "provider" }),
+			() => "off",
+			() => ({ cwd: "/tmp" }),
+			decoration,
+		);
+
+		const narrow = editor.render(4);
+		expect(narrow[0]).not.toContain("╭");
+		expect(narrow.every((line) => visibleWidth(line) <= 4)).toBe(true);
+		const decorated = editor.render(5);
+		expect(decorated[0]).toMatch(/^╭.*╮$/);
+		expect(decorated.every((line) => visibleWidth(line) <= 5)).toBe(true);
+		expect(widths).toEqual([4, 1]);
+		expect(decoration.mock.calls.map(([active]) => active)).toEqual([false, true]);
+	});
+
+	it("preserves empty, multiline, blank, and inverse-video editor rows", () => {
+		const inverseCursor = "\x1b[7m \x1b[0m";
+		const base = {
+			render: (width: number) => [
+				nativeBorder(width, "above"),
+				"",
+				inverseCursor,
+				"second line",
+				nativeBorder(width, "below"),
+			],
+			invalidate() {},
+			handleInput() {},
+			getText: () => "\nsecond line",
+			setText() {},
+		};
+		const editor = new WrappedPolishedEditor(
+			base as never,
+			theme(),
+			() => withEditorStyle(config(), "minimalist"),
+			() => ({ modelLabel: "model", providerLabel: "provider" }),
+			() => "off",
+			() => ({ cwd: "/tmp" }),
+		);
+		const lines = editor.render(40);
+		expect(lines[1]).toMatch(/^│\s+│$/);
+		expect(lines.join("\n")).toContain(inverseCursor);
+		expect(lines.join("\n")).toContain("second line");
+
+		const empty = new WrappedPolishedEditor(
+			{
+				render: (width: number) => [nativeBorder(width, "above"), nativeBorder(width, "below")],
+				invalidate() {},
+				handleInput() {},
+				getText: () => "",
+				setText() {},
+			} as never,
+			theme(),
+			() => withEditorStyle(config(), "minimalist"),
+			() => ({ modelLabel: "model", providerLabel: "provider" }),
+			() => "off",
+			() => ({ cwd: "/tmp" }),
+		).render(40);
+		expect(empty).toHaveLength(2);
+		expect(empty[0]).toMatch(/^╭.*╮$/);
+		expect(empty[1]).toMatch(/^╰.*╯$/);
+	});
+});