@selesai/code 0.13.39 → 0.14.0

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

@@ -2,20 +2,37 @@ import { CustomEditor, type KeybindingsManager, type Theme } from "@earendil-wor
 import {
 	type AutocompleteProvider,
 	type Component,
+	CURSOR_MARKER,
 	type EditorComponent,
 	type EditorTheme,
+	sliceByColumn,
 	type TUI,
 	truncateToWidth,
 	visibleWidth,
 } from "@earendil-works/pi-tui";
 import { ACCENT_RAIL_CHROME_WIDTH, renderAccentRailEditorFrame } from "./accent-rail-editor";
-import { renderCompletionPalette } from "./completion-menu";
+import type { CodexQuota } from "./codex-quota";
+import { renderCodexQuota } from "./codex-quota-display";
+import { omitTrailingNativeCompletionCountRow, renderCompletionPalette } from "./completion-menu";
+import { componentColor, editorShellColor } from "./component-colors";
 import type { EditorStyle, ZentuiConfig } from "./config";
 import {
 	type EditorMetadataZones,
 	renderEditorMetadataFormatSplit,
+	sanitizeEditorMetadataText,
 } from "./editor-metadata-format";
+import {
+	EditorMouseForwarder,
+	type EditorMouseHandler,
+	editorMouseCells,
+	rememberEditorMouseLayout,
+} from "./editor-mouse";
+import { collectFooterFormatReferences, parseFooterFormat } from "./footer-format";
+import { bashModeLabel } from "./format";
+import type { HostTemplateValues } from "./host-template-values";
 import { type MinimalistEditorMetadata, renderMinimalistFrame } from "./minimalist-editor";
+import { minimalistTemplateReferences } from "./minimalist-template";
+import { getOmpEditorFrame, renderWithOmpEditorFrame } from "./omp-editor-frame";
 import {
 	EDITOR_ACCENT_FALLBACK,
 	EDITOR_BORDER_FALLBACK,
@@ -23,6 +40,9 @@ import {
 	safeThemeFg,
 } from "./style";
 
+// Reserve at least four label cells beside Minimalist metadata.
+const MIN_WORKING_LINE_BORDER_WIDTH = 16;
+
 const LEGACY_SPLIT_POLISHED_FRAME = Symbol.for("pi-zentui.polished-frame");
 
 export type ViewportCounts = {
@@ -35,6 +55,7 @@ type PolishedFrameSplit = {
 	/** Logical, unframed autocomplete payload rows owned by this module. */
 	trailingLines: string[];
 	viewport: ViewportCounts;
+	nativeStatusLine?: string;
 };
 
 type PolishedFrameProvenance = {
@@ -48,7 +69,10 @@ type AutocompleteListInternals = Pick<Component, "render">;
 
 type AutocompleteEditorInternals = {
 	autocompleteList?: AutocompleteListInternals;
+	debugChildren?: readonly AutocompleteListInternals[];
 	isShowingAutocomplete?: () => boolean;
+	getPaddingX?: () => number;
+	getBorderStyle?: () => unknown;
 };
 
 type AutocompleteCapture = {
@@ -59,6 +83,7 @@ type AutocompleteCapture = {
 
 type WrappedEditor = EditorComponent &
 	AutocompleteEditorInternals & {
+		handleMouse?: EditorMouseHandler;
 		focused?: boolean;
 		onEscape?: () => void;
 		onCtrlD?: () => void;
@@ -81,9 +106,11 @@ type WrappedEditor = EditorComponent &
 	};
 
 export type EditorMeta = {
+	codexQuota?: CodexQuota;
 	modelLabel: string;
 	modelId?: string;
 	modelName?: string;
+	fastMode?: string;
 	providerLabel: string;
 	sessionName?: string;
 	contextPercent?: number;
@@ -91,6 +118,8 @@ export type EditorMeta = {
 	inputTokens?: number;
 	outputTokens?: number;
 	cacheHitRate?: number;
+	customVariables?: ReadonlyMap<string, string>;
+	hostTemplateValues?: HostTemplateValues;
 };
 
 export type PolishedEditorFrameOptions = {
@@ -103,11 +132,14 @@ export type PolishedEditorFrameOptions = {
 	modelMeta: EditorMeta;
 	thinkingLevel?: string;
 	rightStatus?: string;
+	workingLineFrame?: string;
+	shellMode?: boolean;
 	borderColor?: (text: string) => string;
 };
 
 type PolishedFrameOptions = {
 	width: number;
+	baseWidth: number;
 	baseRendered: string[];
 	autocompleteSource: AutocompleteEditorInternals;
 	autocompleteCapture?: AutocompleteCapture;
@@ -116,8 +148,11 @@ type PolishedFrameOptions = {
 	modelMeta: EditorMeta;
 	thinkingLevel: string | undefined;
 	rightStatus?: string;
+	shellMode?: boolean;
 	ownedFrame?: PolishedFrameSplit;
 	trustedBaseFrame?: boolean;
+	getWorkingLineFrame: () => string | undefined;
+	reportWorkingLineBorder: (active: boolean) => void;
 	borderColor?: (text: string) => string;
 };
 
@@ -127,7 +162,9 @@ type PolishedFrameResult = {
 };
 
 type AccentRailFrameAdapterOptions = {
+	codexQuota?: CodexQuota;
 	width: number;
+	baseWidth: number;
 	baseRendered: string[];
 	autocompleteSource: AutocompleteEditorInternals;
 	autocompleteCapture?: AutocompleteCapture;
@@ -139,13 +176,15 @@ type AccentRailFrameAdapterOptions = {
 
 type MinimalistFrameAdapterOptions = {
 	width: number;
+	baseWidth: number;
 	baseRendered: string[];
 	autocompleteSource: AutocompleteEditorInternals;
 	autocompleteCapture?: AutocompleteCapture;
 	uiTheme: Theme;
 	config: ZentuiConfig;
 	inputText: string;
-	metadata: MinimalistEditorMetadata;
+	getMetadata: () => MinimalistEditorMetadata;
+	reportWorkingLineBorder: (active: boolean) => void;
 	ownedFrame?: PolishedFrameSplit;
 	trustedBaseFrame?: boolean;
 	borderColor?: (text: string) => string;
@@ -180,10 +219,25 @@ function stripNativeRightPadding(value: string): string {
 	return value.replace(/ +$/, "");
 }
 
+// Mirrors the native editor's per-render padding clamp: effective horizontal
+// padding never exceeds half of the rendered width.
+function nativeHorizontalPadding(source: AutocompleteEditorInternals, baseWidth: number): number {
+	try {
+		if (typeof source.getPaddingX !== "function") return 0;
+		const padding = source.getPaddingX.call(source);
+		if (!Number.isFinite(padding)) return 0;
+		const maxPadding = Math.max(0, Math.floor((baseWidth - 1) / 2));
+		return Math.min(Math.max(0, Math.floor(padding)), maxPadding);
+	} catch {
+		return 0;
+	}
+}
+
 function autocompleteCount(
 	source: AutocompleteEditorInternals,
 	capture: AutocompleteCapture | undefined,
 	baseRendered: string[],
+	baseWidth: number,
 ): AutocompleteCount {
 	try {
 		const showing = source.isShowingAutocomplete;
@@ -195,13 +249,18 @@ function autocompleteCount(
 			capture.rows.length >= baseRendered.length
 		)
 			return { known: false };
+		const paddingX = nativeHorizontalPadding(source, baseWidth);
+		const leftPadding = " ".repeat(paddingX);
 		const suffix = baseRendered.slice(-capture.rows.length);
 		if (
 			!suffix.every((line, index) => {
 				const captured = capture.rows[index];
+				const unpadded =
+					paddingX > 0 && line.startsWith(leftPadding) ? line.slice(leftPadding.length) : line;
 				return (
 					captured !== undefined &&
-					(line === captured || stripNativeRightPadding(line) === stripNativeRightPadding(captured))
+					(line === captured ||
+						stripNativeRightPadding(unpadded) === stripNativeRightPadding(captured))
 				);
 			})
 		)
@@ -212,6 +271,17 @@ function autocompleteCount(
 	}
 }
 
+// The native editor renders autocomplete rows wrapped in its horizontal
+// padding; prefer the raw captured rows so decoration starts at column zero.
+function capturedAutocompleteLines(
+	capture: AutocompleteCapture | undefined,
+	baseRendered: string[],
+	count: number,
+): string[] {
+	if (count <= 0) return [];
+	return capture && capture.rows.length === count ? capture.rows : baseRendered.slice(-count);
+}
+
 /** @internal Exported only for descriptor-safety regression tests. */
 export function renderWithAutocompleteCapture<T>(
 	source: AutocompleteEditorInternals,
@@ -231,7 +301,7 @@ export function renderWithAutocompleteCapture<T>(
 	let own: PropertyDescriptor | undefined;
 	let predecessor: (...args: unknown[]) => unknown;
 	try {
-		const candidate = source.autocompleteList;
+		const candidate = source.autocompleteList ?? source.debugChildren?.[0];
 		if (!candidate) return { value: render() };
 		own = Object.getOwnPropertyDescriptor(candidate, "render");
 		const current = Reflect.get(candidate, "render");
@@ -319,6 +389,20 @@ function isLowRailPolishedStyle(style: EditorStyle): boolean {
 	return style === "opencode-copy-friendly";
 }
 
+function isShellModeInput(text: string): boolean {
+	return bashModeLabel(text) !== "";
+}
+
+export function editorWantsContext(config: ZentuiConfig): boolean {
+	const editor = config.components.editor;
+	if (!editor.enabled || editor.style === "accent-rail") return false;
+	if (editor.style === "minimalist")
+		return minimalistTemplateReferences(editor.styles.minimalist).has("context");
+	return collectFooterFormatReferences(
+		parseFooterFormat(sanitizeEditorMetadataText(editor.styles[editor.style].metadataFormat)),
+	).has("context");
+}
+
 function selectedPolishedConfig(config: ZentuiConfig) {
 	switch (config.components.editor.style) {
 		case "opencode":
@@ -337,23 +421,31 @@ function lowRailPrompt(config: ZentuiConfig, uiTheme: Theme, reset: string): str
 		? `${renderStyleForSourceOrFallback(
 				uiTheme,
 				config.components.editor.colorSource,
-				config.colors.editorPrompt ?? config.colors.editorAccent,
+				componentColor(config, "editor", "prompt") ?? componentColor(config, "editor", "accent"),
 				EDITOR_ACCENT_FALLBACK,
 				promptIcon,
 			)}${reset} `
 		: "";
 }
 
-function getEditorChromeWidths(config: ZentuiConfig, uiTheme: Theme, reset: string) {
+function getEditorChromeWidths(
+	config: ZentuiConfig,
+	uiTheme: Theme,
+	reset: string,
+	shellMode = false,
+) {
 	const lowRail = isLowRailPolishedStyle(config.components.editor.style);
 	const prompt = lowRailPrompt(config, uiTheme, reset);
+	const chromeColor = shellMode
+		? editorShellColor(config)
+		: { color: componentColor(config, "editor", "accent"), fallback: EDITOR_ACCENT_FALLBACK };
 	const rail = lowRail
 		? ""
 		: `${renderStyleForSourceOrFallback(
 				uiTheme,
 				config.components.editor.colorSource,
-				config.colors.editorAccent,
-				EDITOR_ACCENT_FALLBACK,
+				chromeColor.color,
+				chromeColor.fallback,
 				config.icons.rail,
 			)}${reset} `;
 	return {
@@ -436,7 +528,7 @@ function parseEditorBorder(
 	if (/^─+$/.test(plain)) return {};
 
 	const arrow = direction === "above" ? "↑" : "↓";
-	const match = new RegExp(`^─── ${arrow} ([1-9]\\d*) more ─*$`).exec(plain);
+	const match = new RegExp(`^─{3,} ${arrow} ([1-9]\\d*) more ─*$`).exec(plain);
 	return match?.[1] ? { count: match[1] } : undefined;
 }
 
@@ -451,10 +543,144 @@ function renderEditorBorder(
 	return `${indicator}${"─".repeat(Math.max(0, width - visibleWidth(indicator)))}`;
 }
 
+/** Slice native chrome in terminal cells without dropping the zero-width caret. */
+function sliceEditorColumns(line: string, start: number, length: number): string | undefined {
+	const markerIndex = line.indexOf(CURSOR_MARKER);
+	if (markerIndex < 0) return sliceByColumn(line, start, length, true);
+	if (line.indexOf(CURSOR_MARKER, markerIndex + CURSOR_MARKER.length) >= 0) return undefined;
+	const before = line.slice(0, markerIndex);
+	const after = line.slice(markerIndex + CURSOR_MARKER.length);
+	const markerColumn = visibleWidth(before);
+	if (markerColumn < start || markerColumn > start + length) return undefined;
+	const beforeLength = markerColumn - start;
+	return (
+		sliceByColumn(before, start, beforeLength, true) +
+		CURSOR_MARKER +
+		sliceByColumn(after, 0, length - beforeLength, true)
+	);
+}
+
+type NormalizedBaseFrame = PolishedFrameSplit & { nativeFrame: boolean };
+
+/** Both hosts feed the same unframed payload into the existing style renderers. */
+function normalizeBaseFrame(
+	baseRendered: string[],
+	baseWidth: number,
+	source: AutocompleteEditorInternals,
+	capture: AutocompleteCapture | undefined,
+	ownedFrame: PolishedFrameSplit | undefined,
+	trustedBaseFrame: boolean,
+): NormalizedBaseFrame | undefined {
+	if (ownedFrame) return { ...ownedFrame, nativeFrame: false };
+	const native = getOmpEditorFrame(baseRendered);
+	if (native) return { ...native, viewport: {}, nativeFrame: true };
+	if (source.getBorderStyle?.() === "band") {
+		if (!trustedBaseFrame && source.getPaddingX?.() !== 0) return undefined;
+		const autocomplete = autocompleteCount(source, capture, baseRendered, baseWidth);
+		if (!autocomplete.known) return undefined;
+		const end = baseRendered.length - autocomplete.count;
+		if (end < 2) return undefined;
+		const editorLines: string[] = [];
+		for (let index = 1; index < end; index++) {
+			const row = baseRendered[index];
+			const plain = ansiStrippedText(row.replaceAll(CURSOR_MARKER, ""));
+			if (!plain.startsWith(index === 1 ? "╰─ " : "   ")) return undefined;
+			const rowWidth = visibleWidth(row.replaceAll(CURSOR_MARKER, ""));
+			if (rowWidth < 3 || rowWidth > baseWidth) return undefined;
+			const content = sliceEditorColumns(row, 3, rowWidth - 3);
+			if (content === undefined) return undefined;
+			editorLines.push(content);
+		}
+		return {
+			editorLines,
+			trailingLines: capturedAutocompleteLines(capture, baseRendered, autocomplete.count),
+			viewport: {},
+			nativeFrame: true,
+			nativeStatusLine: baseRendered[0],
+		};
+	}
+	const top = ansiStrippedText(baseRendered[0] ?? "");
+	if (top.startsWith("╭")) {
+		// The native subclass explicitly selects zero padding. A predecessor with
+		// unknown padding is not safe to unwrap: leading spaces may be prompt text.
+		if (
+			!/^╭.*╮$/.test(top) ||
+			visibleWidth(top) !== baseWidth ||
+			top.includes(CURSOR_MARKER) ||
+			(typeof source.getBorderStyle === "function" && source.getBorderStyle() !== "box") ||
+			baseWidth < 4 ||
+			(!trustedBaseFrame &&
+				(typeof source.getPaddingX !== "function" || source.getPaddingX() !== 0))
+		)
+			return undefined;
+		const editorLines: string[] = [];
+		for (let index = 1; index < baseRendered.length; index++) {
+			const row = baseRendered[index] ?? "";
+			const plain = ansiStrippedText(row.replaceAll(CURSOR_MARKER, ""));
+			const rowWidth = visibleWidth(row.replaceAll(CURSOR_MARKER, ""));
+			const last = plain.startsWith("╰─") && plain.endsWith("╯");
+			if (
+				rowWidth < 3 ||
+				rowWidth > baseWidth + 1 ||
+				(!last && !(plain.startsWith("│") && /[│█]$/.test(plain)))
+			)
+				return undefined;
+			const leftWidth = last ? 2 : 1;
+			const content = sliceEditorColumns(row, leftWidth, rowWidth - leftWidth - 1);
+			if (content === undefined) return undefined;
+			editorLines.push(content);
+			if (last) {
+				return {
+					editorLines,
+					trailingLines: baseRendered.slice(index + 1),
+					viewport: {},
+					nativeFrame: true,
+					nativeStatusLine: /[^╭╮─\s]/u.test(top) ? baseRendered[0] : undefined,
+				};
+			}
+		}
+		return undefined;
+	}
+	// Other OMP composer shapes are not Pi frames, even when the source is native.
+	if (typeof source.getBorderStyle === "function") return undefined;
+	const autocomplete = autocompleteCount(source, capture, baseRendered, baseWidth);
+	if (!autocomplete.known) return undefined;
+	const frame = autocomplete.count > 0 ? baseRendered.slice(0, -autocomplete.count) : baseRendered;
+	if (frame.length < 2) return undefined;
+	const parsedTop = parseEditorBorder(frame[0] ?? "", "above");
+	const parsedBottom = parseEditorBorder(frame.at(-1) ?? "", "below");
+	if (!trustedBaseFrame && (!parsedTop || !parsedBottom)) return undefined;
+	return {
+		editorLines: frame.slice(1, -1),
+		trailingLines: capturedAutocompleteLines(capture, baseRendered, autocomplete.count),
+		viewport: { above: parsedTop?.count, below: parsedBottom?.count },
+		nativeFrame: false,
+	};
+}
+
+function rememberNormalizedMouseLayout(
+	lines: string[],
+	baseRendered: string[],
+	frame: NormalizedBaseFrame,
+	layout: Parameters<typeof rememberEditorMouseLayout>[4],
+): void {
+	// OMP's merged bottom has different per-row offsets and completion origins.
+	// Until its geometry is exposed, consume decorated clicks rather than send
+	// Pi coordinates to a predecessor's native input handler.
+	rememberEditorMouseLayout(
+		lines,
+		baseRendered,
+		frame.editorLines.length,
+		frame.trailingLines.length,
+		frame.nativeFrame ? { body: [], completion: [] } : layout,
+	);
+}
+
 function unwrapPolishedFrameOnly(
 	lines: string[],
 	config: ZentuiConfig,
 	uiTheme: Theme,
+	shellMode = false,
 ): { editorLines: string[]; viewport: ViewportCounts } | undefined {
 	if (lines.length < 5) return undefined;
 	const top = parseEditorBorder(lines[0] ?? "", "above");
@@ -486,7 +712,7 @@ function unwrapPolishedFrameOnly(
 		return { editorLines: unwrapped, viewport };
 	}
 
-	const { rail } = getEditorChromeWidths(config, uiTheme, "\x1b[0m");
+	const { rail } = getEditorChromeWidths(config, uiTheme, "\x1b[0m", shellMode);
 	if (!rail || interior.some((line) => !line.startsWith(rail))) return undefined;
 	const unrailed = interior.map((line) => line.slice(rail.length));
 	if (
@@ -501,12 +727,18 @@ function splitPolishedFrame(
 	lines: string[],
 	config: ZentuiConfig,
 	uiTheme: Theme,
+	shellMode = false,
 ): PolishedFrameSplit | undefined {
 	if (!parseEditorBorder(lines[0] ?? "", "above")) return undefined;
 
 	for (let bottomIndex = lines.length - 1; bottomIndex >= 4; bottomIndex--) {
 		if (!parseEditorBorder(lines[bottomIndex] ?? "", "below")) continue;
-		const frame = unwrapPolishedFrameOnly(lines.slice(0, bottomIndex + 1), config, uiTheme);
+		const frame = unwrapPolishedFrameOnly(
+			lines.slice(0, bottomIndex + 1),
+			config,
+			uiTheme,
+			shellMode,
+		);
 		if (frame) return { ...frame, trailingLines: lines.slice(bottomIndex + 1) };
 	}
 	return undefined;
@@ -528,7 +760,12 @@ function inspectPolishedFrameProvenance(
 	const unsafe =
 		Boolean(provenance && !provenanceMatches) ||
 		LEGACY_SPLIT_POLISHED_FRAME in base ||
-		(!ownedFrame && Boolean(splitPolishedFrame(rendered, config, uiTheme)));
+		// A predecessor may return cached rows from either input mode.
+		(!ownedFrame &&
+			Boolean(
+				splitPolishedFrame(rendered, config, uiTheme) ||
+					splitPolishedFrame(rendered, config, uiTheme, true),
+			));
 	return { safe: !unsafe, ownedFrame };
 }
 
@@ -559,7 +796,9 @@ function readVimStatus(editor: WrappedEditor, uiTheme: Theme): string | undefine
 }
 
 function renderAccentRailFrameFromBase({
+	codexQuota,
 	width,
+	baseWidth,
 	baseRendered,
 	autocompleteSource,
 	autocompleteCapture,
@@ -568,41 +807,26 @@ function renderAccentRailFrameFromBase({
 	ownedFrame,
 	trustedBaseFrame = false,
 }: AccentRailFrameAdapterOptions): PolishedFrameResult {
-	if (width < ACCENT_RAIL_CHROME_WIDTH + 1 || baseRendered.length < 2) {
+	if (width < ACCENT_RAIL_CHROME_WIDTH + 1) {
 		return { lines: clampRenderedLines(baseRendered, width), decorated: false };
 	}
 	if (ownedFrame && !isPolishedFrameSplit(ownedFrame, baseRendered.length)) {
 		return { lines: clampRenderedLines(baseRendered, width), decorated: false };
 	}
-	const autocomplete = ownedFrame
-		? { known: true as const, count: ownedFrame.trailingLines.length }
-		: autocompleteCount(autocompleteSource, autocompleteCapture, baseRendered);
-	if (!autocomplete.known) {
-		return { lines: clampRenderedLines(baseRendered, width), decorated: false };
-	}
-	const editorFrame =
-		!ownedFrame && autocomplete.count > 0
-			? baseRendered.slice(0, -autocomplete.count)
-			: baseRendered;
-	const autocompleteLines = ownedFrame
-		? ownedFrame.trailingLines
-		: autocomplete.count > 0
-			? baseRendered.slice(-autocomplete.count)
-			: [];
-	if (editorFrame.length < 2) {
-		return { lines: clampRenderedLines(baseRendered, width), decorated: false };
-	}
-	const parsedTop = parseEditorBorder(editorFrame[0] ?? "", "above");
-	const parsedBottom = parseEditorBorder(editorFrame.at(-1) ?? "", "below");
-	if (!ownedFrame && !trustedBaseFrame && (!parsedTop || !parsedBottom)) {
-		return { lines: clampRenderedLines(baseRendered, width), decorated: false };
-	}
-	const editorLines = ownedFrame?.editorLines ?? editorFrame.slice(1, -1);
-	const viewport = ownedFrame?.viewport ?? {
-		above: parsedTop?.count,
-		below: parsedBottom?.count,
-	};
+	const frame = normalizeBaseFrame(
+		baseRendered,
+		baseWidth,
+		autocompleteSource,
+		autocompleteCapture,
+		ownedFrame,
+		trustedBaseFrame,
+	);
+	if (!frame) return { lines: clampRenderedLines(baseRendered, width), decorated: false };
+	const { editorLines, trailingLines: autocompleteLines, viewport } = frame;
+	const quotaRow = renderCodexQuota(codexQuota, uiTheme, config, "editor");
+	const quotaVisible = quotaRow && visibleWidth(quotaRow) <= width - ACCENT_RAIL_CHROME_WIDTH;
 	const renderedLines = renderAccentRailEditorFrame({
+		codexQuota,
 		width,
 		editorLines,
 		autocompleteLines,
@@ -611,77 +835,97 @@ function renderAccentRailFrameFromBase({
 		config,
 	});
 	const lines = renderedLines.length === 1 ? ["", ...renderedLines, ""] : renderedLines;
+	if (frame.nativeStatusLine !== undefined) lines.unshift(frame.nativeStatusLine);
+	const bodyStart =
+		(renderedLines.length === 1 ? 1 : 0) +
+		(config.components.editor.viewportIndicators && viewport.above ? 1 : 0);
+	rememberNormalizedMouseLayout(lines, baseRendered, frame, {
+		body: editorMouseCells(editorLines.length, ACCENT_RAIL_CHROME_WIDTH, bodyStart),
+		completion: editorMouseCells(
+			autocompleteLines.length,
+			0,
+			bodyStart +
+				editorLines.length +
+				(quotaVisible ? 1 : 0) +
+				(config.components.editor.viewportIndicators && viewport.below ? 1 : 0),
+		),
+	});
 	POLISHED_FRAME_SPLITS.set(lines, {
 		rows: Object.freeze([...lines]),
-		split: { editorLines, trailingLines: autocompleteLines, viewport },
+		split: {
+			editorLines,
+			trailingLines: autocompleteLines,
+			viewport,
+			nativeStatusLine: frame.nativeStatusLine,
+		},
 	});
 	return { lines, decorated: true };
 }
 
 function renderMinimalistFrameFromBase({
 	width,
+	baseWidth,
 	baseRendered,
 	autocompleteSource,
 	autocompleteCapture,
 	uiTheme,
 	config,
 	inputText,
-	metadata,
+	getMetadata,
+	reportWorkingLineBorder,
 	ownedFrame,
 	trustedBaseFrame = false,
 	borderColor,
 }: MinimalistFrameAdapterOptions): PolishedFrameResult {
-	if (width <= 4 || baseRendered.length < 2) {
+	if (width <= 4) {
 		return { lines: clampRenderedLines(baseRendered, width), decorated: false };
 	}
 	if (ownedFrame && !isPolishedFrameSplit(ownedFrame, baseRendered.length)) {
 		return { lines: clampRenderedLines(baseRendered, width), decorated: false };
 	}
-	const autocomplete = ownedFrame
-		? { known: true as const, count: ownedFrame.trailingLines.length }
-		: autocompleteCount(autocompleteSource, autocompleteCapture, baseRendered);
-	if (!autocomplete.known) {
-		return { lines: clampRenderedLines(baseRendered, width), decorated: false };
-	}
-	const editorFrame =
-		!ownedFrame && autocomplete.count > 0
-			? baseRendered.slice(0, -autocomplete.count)
-			: baseRendered;
-	const autocompleteLines = ownedFrame
-		? ownedFrame.trailingLines
-		: autocomplete.count > 0
-			? baseRendered.slice(-autocomplete.count)
-			: [];
-	if (editorFrame.length < 2) {
-		return { lines: clampRenderedLines(baseRendered, width), decorated: false };
-	}
-	const parsedTop = parseEditorBorder(editorFrame[0] ?? "", "above");
-	const parsedBottom = parseEditorBorder(editorFrame.at(-1) ?? "", "below");
-	if (!ownedFrame && !trustedBaseFrame && (!parsedTop || !parsedBottom)) {
-		return { lines: clampRenderedLines(baseRendered, width), decorated: false };
-	}
-	const viewport = ownedFrame?.viewport ?? {
-		above: parsedTop?.count,
-		below: parsedBottom?.count,
-	};
-	return {
-		lines: renderMinimalistFrame({
-			width,
-			editorLines: ownedFrame?.editorLines ?? editorFrame.slice(1, -1),
-			autocompleteLines,
-			viewport: config.components.editor.viewportIndicators ? viewport : undefined,
-			inputText,
-			metadata,
-			uiTheme,
-			config,
-			borderColor,
-		}),
-		decorated: true,
-	};
+	const frame = normalizeBaseFrame(
+		baseRendered,
+		baseWidth,
+		autocompleteSource,
+		autocompleteCapture,
+		ownedFrame,
+		trustedBaseFrame,
+	);
+	if (!frame) return { lines: clampRenderedLines(baseRendered, width), decorated: false };
+	const { editorLines, trailingLines: autocompleteLines, viewport } = frame;
+	// Publish safe geometry before reading the controller-gated Working frame.
+	reportWorkingLineBorder(
+		width >= MIN_WORKING_LINE_BORDER_WIDTH &&
+			Boolean(
+				ownedFrame ||
+					frame.nativeFrame ||
+					(typeof autocompleteSource.isShowingAutocomplete === "function" &&
+						autocompleteCapture?.compatible),
+			),
+	);
+	const metadata = getMetadata();
+	const lines = renderMinimalistFrame({
+		width,
+		editorLines,
+		autocompleteLines,
+		viewport: config.components.editor.viewportIndicators ? viewport : undefined,
+		inputText,
+		metadata,
+		uiTheme,
+		config,
+		borderColor,
+	});
+	if (frame.nativeStatusLine !== undefined) lines.unshift(frame.nativeStatusLine);
+	rememberNormalizedMouseLayout(lines, baseRendered, frame, {
+		body: editorMouseCells(editorLines.length, 2, 1),
+		completion: editorMouseCells(autocompleteLines.length, 2, editorLines.length + 2),
+	});
+	return { lines, decorated: true };
 }
 
 function renderPolishedFrame({
 	width,
+	baseWidth,
 	baseRendered,
 	autocompleteSource,
 	autocompleteCapture,
@@ -690,48 +934,40 @@ function renderPolishedFrame({
 	modelMeta,
 	thinkingLevel,
 	rightStatus,
+	shellMode = false,
 	ownedFrame,
 	trustedBaseFrame = false,
+	getWorkingLineFrame,
+	reportWorkingLineBorder,
 	borderColor,
 }: PolishedFrameOptions): PolishedFrameResult {
 	if (width <= 2) return { lines: clampRenderedLines(baseRendered, width), decorated: false };
 
-	if (baseRendered.length < 2) {
-		return { lines: clampRenderedLines(baseRendered, width), decorated: false };
-	}
 	if (ownedFrame && !isPolishedFrameSplit(ownedFrame, baseRendered.length)) {
 		return { lines: clampRenderedLines(baseRendered, width), decorated: false };
 	}
 
-	const autocomplete = ownedFrame
-		? { known: true, count: ownedFrame.trailingLines.length }
-		: autocompleteCount(autocompleteSource, autocompleteCapture, baseRendered);
-	if (!autocomplete.known) {
-		return { lines: clampRenderedLines(baseRendered, width), decorated: false };
-	}
-	const editorFrame =
-		!ownedFrame && autocomplete.count > 0
-			? baseRendered.slice(0, -autocomplete.count)
-			: baseRendered;
-	const autocompleteLines = ownedFrame
-		? ownedFrame.trailingLines
-		: autocomplete.count > 0
-			? baseRendered.slice(-autocomplete.count)
-			: [];
-	if (editorFrame.length < 2) {
-		return { lines: clampRenderedLines(baseRendered, width), decorated: false };
-	}
-
-	const parsedTop = parseEditorBorder(editorFrame[0] ?? "", "above");
-	const parsedBottom = parseEditorBorder(editorFrame.at(-1) ?? "", "below");
-	if (!ownedFrame && !trustedBaseFrame && (!parsedTop || !parsedBottom)) {
-		return { lines: clampRenderedLines(baseRendered, width), decorated: false };
-	}
-	const editorLines = ownedFrame?.editorLines ?? editorFrame.slice(1, -1);
-	const viewport = ownedFrame?.viewport ?? {
-		above: parsedTop?.count,
-		below: parsedBottom?.count,
-	};
+	const frame = normalizeBaseFrame(
+		baseRendered,
+		baseWidth,
+		autocompleteSource,
+		autocompleteCapture,
+		ownedFrame,
+		trustedBaseFrame,
+	);
+	if (!frame) return { lines: clampRenderedLines(baseRendered, width), decorated: false };
+	const { editorLines, trailingLines: autocompleteLines, viewport } = frame;
+	// Publish safe geometry before reading the controller-gated Working frame.
+	reportWorkingLineBorder(
+		width >= MIN_WORKING_LINE_BORDER_WIDTH &&
+			Boolean(
+				ownedFrame ||
+					frame.nativeFrame ||
+					(typeof autocompleteSource.isShowingAutocomplete === "function" &&
+						autocompleteCapture?.compatible),
+			),
+	);
+	const workingLineFrame = getWorkingLineFrame();
 	const lines = renderPolishedEditorFrame({
 		width,
 		editorLines,
@@ -742,14 +978,27 @@ function renderPolishedFrame({
 		modelMeta,
 		thinkingLevel,
 		rightStatus,
+		workingLineFrame,
+		shellMode,
 		borderColor,
 	});
+	if (frame.nativeStatusLine !== undefined) lines.unshift(frame.nativeStatusLine);
+	const { railWidth } = getEditorChromeWidths(config, uiTheme, "\x1b[0m", shellMode);
+	const completionCount =
+		selectedPolishedConfig(config)?.completionMenu === "palette"
+			? omitTrailingNativeCompletionCountRow(autocompleteLines).length
+			: autocompleteLines.length;
+	rememberNormalizedMouseLayout(lines, baseRendered, frame, {
+		body: editorMouseCells(editorLines.length, railWidth, 2),
+		completion: editorMouseCells(completionCount, 0, editorLines.length + 5),
+	});
 	POLISHED_FRAME_SPLITS.set(lines, {
 		rows: Object.freeze([...lines]),
 		split: {
 			editorLines,
 			trailingLines: autocompleteLines,
 			viewport,
+			nativeStatusLine: frame.nativeStatusLine,
 		},
 	});
 	return { lines, decorated: true };
@@ -766,33 +1015,61 @@ export function renderPolishedEditorFrame({
 	modelMeta,
 	thinkingLevel,
 	rightStatus,
+	workingLineFrame,
+	shellMode = false,
 	borderColor,
 }: PolishedEditorFrameOptions): string[] {
 	if (width <= 2) return clampRenderedLines(editorLines, width);
 	const reset = "\x1b[0m";
 	const colorSource = config.components.editor.colorSource;
-	const { prompt, promptWidth, rail, railWidth } = getEditorChromeWidths(config, uiTheme, reset);
-	const innerWidth = Math.max(0, width - railWidth);
-	const lowRailContinuation = " ".repeat(promptWidth);
-	const metadataZones = renderEditorMetadataFormatSplit(
-		selectedPolishedConfig(config)?.metadataFormat ??
-			config.components.editor.styles.opencode.metadataFormat,
-		{
-			model: modelMeta.modelLabel,
-			modelId: modelMeta.modelId ?? "",
-			modelName: modelMeta.modelName ?? "",
-			provider: modelMeta.providerLabel,
-			thinking: thinkingLevel ?? "",
-			sessionName: modelMeta.sessionName ?? "",
-			contextPercent: modelMeta.contextPercent,
-			contextWindow: modelMeta.contextWindow,
-			inputTokens: modelMeta.inputTokens,
-			outputTokens: modelMeta.outputTokens,
-			cacheHitRate: modelMeta.cacheHitRate,
-		},
-		uiTheme,
+	const { prompt, promptWidth, rail, railWidth } = getEditorChromeWidths(
 		config,
+		uiTheme,
+		reset,
+		shellMode,
 	);
+	const innerWidth = Math.max(0, width - railWidth);
+	const lowRailContinuation = " ".repeat(promptWidth);
+	const renderMetadata = (codexQuota?: CodexQuota, includeCustom = true) =>
+		renderEditorMetadataFormatSplit(
+			selectedPolishedConfig(config)?.metadataFormat ??
+				config.components.editor.styles.opencode.metadataFormat,
+			{
+				codexQuota,
+				model: modelMeta.modelLabel,
+				modelId: modelMeta.modelId ?? "",
+				modelName: modelMeta.modelName ?? "",
+				provider: modelMeta.providerLabel,
+				thinking: thinkingLevel ?? "",
+				fastMode: modelMeta.fastMode,
+				sessionName: modelMeta.sessionName ?? "",
+				contextPercent: modelMeta.contextPercent,
+				contextWindow: modelMeta.contextWindow,
+				inputTokens: modelMeta.inputTokens,
+				outputTokens: modelMeta.outputTokens,
+				cacheHitRate: modelMeta.cacheHitRate,
+				customVariables: includeCustom ? modelMeta.customVariables : undefined,
+				hostTemplateValues: modelMeta.hostTemplateValues,
+			},
+			uiTheme,
+			config,
+			shellMode,
+		);
+	let metadataZones = renderMetadata(modelMeta.codexQuota);
+	// Quota is atomic: never clip away its labels or trailing stale warning.
+	const metadataBudget = isLowRailPolishedStyle(config.components.editor.style)
+		? width - 1
+		: innerWidth;
+	const naturalWidth = () =>
+		Object.values(metadataZones).reduce((sum, zone) => sum + visibleWidth(zone), 0) +
+		Object.values(metadataZones).filter(Boolean).length -
+		1 +
+		(rightStatus ? visibleWidth(rightStatus) + 1 : 0);
+	// Configured extension values yield whole before any built-in metadata is cropped.
+	const includeCustom = naturalWidth() <= metadataBudget;
+	if (!includeCustom) metadataZones = renderMetadata(modelMeta.codexQuota, false);
+	if (modelMeta.codexQuota && naturalWidth() > metadataBudget)
+		metadataZones = renderMetadata(undefined, includeCustom);
 	const lowRailMeta = composeEditorMetadataLine(metadataZones, rightStatus, Math.max(0, width - 1));
 	const railedMeta = composeEditorMetadataLine(metadataZones, rightStatus, innerWidth);
 
@@ -800,7 +1077,7 @@ export function renderPolishedEditorFrame({
 		renderStyleForSourceOrFallback(
 			uiTheme,
 			colorSource,
-			config.colors.editorBorder,
+			componentColor(config, "editor", "border"),
 			EDITOR_BORDER_FALLBACK,
 			text,
 		);
@@ -818,13 +1095,23 @@ export function renderPolishedEditorFrame({
 			return renderStaticBorder(text);
 		}
 	};
-	const top = renderBorder(
+	let top = renderBorder(
 		renderEditorBorder(
 			width,
 			"above",
 			config.components.editor.viewportIndicators ? viewport.above : undefined,
 		),
 	);
+	if (workingLineFrame && width >= MIN_WORKING_LINE_BORDER_WIDTH) {
+		const label = truncateToWidth(workingLineFrame, width - 6, "…");
+		top = `${renderBorder("── ")}${label}${renderBorder(
+			` ${renderEditorBorder(
+				width - visibleWidth(label) - 4,
+				"above",
+				config.components.editor.viewportIndicators ? viewport.above : undefined,
+			)}`,
+		)}`;
+	}
 	const bottom = renderBorder(
 		renderEditorBorder(
 			width,
@@ -874,6 +1161,11 @@ export class PolishedEditor extends CustomEditor {
 	private readonly getConfig: () => ZentuiConfig;
 	private readonly uiTheme: Theme;
 
+	private readonly mouse = new EditorMouseForwarder();
+	private workingLineBorderCapable = false;
+	private metadataDecorated = false;
+	private metadataDecoratedStyle?: EditorStyle;
+
 	constructor(
 		tui: TUI,
 		theme: EditorTheme,
@@ -884,8 +1176,12 @@ export class PolishedEditor extends CustomEditor {
 		getThinkingLevel: () => string | undefined,
 		getMinimalistMetadata: () => MinimalistEditorMetadata = () => ({ cwd: "" }),
 		onMinimalistDecorationChange: (active: boolean) => void = () => {},
+		private readonly onWorkingLineBorderCapabilityChange: () => void = () => {},
+		private readonly onMetadataDecorationChange: () => void = () => {},
 	) {
 		super(tui, theme, keybindings, { paddingX: 0 });
+		// OMP accepts the legacy constructor but ignores its options argument.
+		this.setPaddingX(0);
 		this.borderColor = (text: string) => safeThemeFg(uiTheme, "border", text);
 		this.uiTheme = uiTheme;
 		this.getConfig = getConfig;
@@ -893,35 +1189,117 @@ export class PolishedEditor extends CustomEditor {
 		this.getThinkingLevel = getThinkingLevel;
 		this.getMinimalistMetadata = getMinimalistMetadata;
 		this.onMinimalistDecorationChange = onMinimalistDecorationChange;
+		// Pi defines focused as an instance field; observe its public focus lifecycle
+		// without shadowing the native cursor's value with a prototype accessor.
+		let focused = this.focused;
+		Object.defineProperty(this, "focused", {
+			configurable: true,
+			enumerable: true,
+			get: () => focused,
+			set: (value: boolean) => {
+				focused = value;
+				if (!value) this.reportWorkingLineBorder(false);
+			},
+		});
+		// Resolve subclass prototype overrides before installing the instance adapter.
+		// Their super call reaches the native prototype directly, so translate once.
+		const handleMouse = (this as unknown as { handleMouse?: EditorMouseHandler }).handleMouse;
+		if (typeof handleMouse === "function") {
+			Object.defineProperty(this, "handleMouse", {
+				value: (event: Parameters<EditorMouseHandler>[0]) =>
+					this.mouse.forward(this, handleMouse, event),
+				writable: true,
+				configurable: true,
+			});
+		}
+	}
+
+	/** OMP's native tree adapter falls back to render() for a null description. */
+	describe(): null {
+		return null;
+	}
+
+	isMetadataDecorated(): boolean {
+		return (
+			this.metadataDecorated &&
+			this.metadataDecoratedStyle === this.getConfig().components.editor.style
+		);
+	}
+	private reportMetadataDecoration(active: boolean): void {
+		const style = active ? this.getConfig().components.editor.style : undefined;
+		if (this.metadataDecorated === active && this.metadataDecoratedStyle === style) return;
+		this.metadataDecorated = active;
+		this.metadataDecoratedStyle = style;
+		this.onMetadataDecorationChange();
 	}
 
 	private reportMinimalistDecoration(active: boolean): void {
 		this.onMinimalistDecorationChange(active);
 	}
 
+	private renderBase(width: number): string[] {
+		return this.mouse.baseRendered(
+			width,
+			renderWithOmpEditorFrame(this as unknown as AutocompleteEditorInternals, width, () =>
+				super.render(width),
+			),
+		);
+	}
+
+	canEmbedWorkingLineBorder(): boolean {
+		return this.focused && this.workingLineBorderCapable;
+	}
+
+	private reportWorkingLineBorder = (active: boolean): void => {
+		active = active && this.focused;
+		if (this.workingLineBorderCapable === active) return;
+		this.workingLineBorderCapable = active;
+		this.onWorkingLineBorderCapabilityChange();
+	};
+
+	private renderFallback(lines: string[], width: number): string[] {
+		this.reportMetadataDecoration(false);
+		this.reportWorkingLineBorder(false);
+		return clampRenderedLines(lines, width);
+	}
+
 	render(width: number): string[] {
+		try {
+			return this.mouse.rendered(this.renderDecorated(width));
+		} catch (error) {
+			this.reportMetadataDecoration(false);
+			this.reportWorkingLineBorder(false);
+			throw error;
+		}
+	}
+
+	private renderDecorated(width: number): string[] {
 		const config = this.getConfig();
 		if (!config.components.editor.enabled) {
 			this.reportMinimalistDecoration(false);
-			return clampRenderedLines(super.render(width), width);
+			return this.renderFallback(this.renderBase(width), width);
 		}
 		if (config.components.editor.style === "accent-rail") {
+			this.reportMetadataDecoration(false);
+			this.reportWorkingLineBorder(false);
 			this.reportMinimalistDecoration(false);
 			if (width < ACCENT_RAIL_CHROME_WIDTH + 1) {
-				return clampRenderedLines(super.render(width), width);
+				return this.renderFallback(this.renderBase(width), width);
 			}
 			let captured: { value: string[]; capture?: AutocompleteCapture };
 			try {
 				captured = renderWithAutocompleteCapture(
 					this as unknown as AutocompleteEditorInternals,
-					() => super.render(width - ACCENT_RAIL_CHROME_WIDTH),
+					() => this.renderBase(width - ACCENT_RAIL_CHROME_WIDTH),
 				);
 			} catch {
-				return clampRenderedLines(super.render(width), width);
+				return this.renderFallback(this.renderBase(width), width);
 			}
 			try {
 				const result = renderAccentRailFrameFromBase({
+					codexQuota: this.getModelMeta().codexQuota,
 					width,
+					baseWidth: width - ACCENT_RAIL_CHROME_WIDTH,
 					baseRendered: captured.value,
 					autocompleteSource: this as unknown as AutocompleteEditorInternals,
 					autocompleteCapture: captured.capture,
@@ -933,86 +1311,104 @@ export class PolishedEditor extends CustomEditor {
 			} catch {
 				// Decoration is optional; preserve the completed same-render rows below.
 			}
-			return clampRenderedLines(captured.value, width);
+			return this.renderFallback(captured.value, width);
 		}
 		if (config.components.editor.style === "minimalist") {
 			if (width <= 4) {
 				this.reportMinimalistDecoration(false);
-				return clampRenderedLines(super.render(width), width);
+				return this.renderFallback(this.renderBase(width), width);
 			}
 			let captured: { value: string[]; capture?: AutocompleteCapture };
 			try {
 				captured = renderWithAutocompleteCapture(
 					this as unknown as AutocompleteEditorInternals,
-					() => super.render(Math.max(0, width - 4)),
+					() => this.renderBase(Math.max(0, width - 4)),
 				);
 			} catch {
 				this.reportMinimalistDecoration(false);
-				return clampRenderedLines(super.render(width), width);
+				return this.renderFallback(this.renderBase(width), width);
 			}
 			try {
 				const result = renderMinimalistFrameFromBase({
 					width,
+					baseWidth: Math.max(0, width - 4),
 					baseRendered: captured.value,
 					autocompleteSource: this as unknown as AutocompleteEditorInternals,
 					autocompleteCapture: captured.capture,
 					uiTheme: this.uiTheme,
 					config,
 					inputText: this.getText(),
-					metadata: this.getMinimalistMetadata(),
+					getMetadata: this.getMinimalistMetadata,
+					reportWorkingLineBorder: this.reportWorkingLineBorder,
 					trustedBaseFrame: true,
 					borderColor: this.borderColor,
 				});
+				this.reportMetadataDecoration(result.decorated);
 				this.reportMinimalistDecoration(result.decorated);
+				if (!result.decorated) this.reportWorkingLineBorder(false);
 				return result.lines;
 			} catch {
 				this.reportMinimalistDecoration(false);
-				return clampRenderedLines(captured.value, width);
+				return this.renderFallback(captured.value, width);
 			}
 		}
 		this.reportMinimalistDecoration(false);
 		if (width <= 2) {
-			return clampRenderedLines(super.render(width), width);
+			return this.renderFallback(this.renderBase(width), width);
 		}
 
-		const { railWidth } = getEditorChromeWidths(config, this.uiTheme, "\x1b[0m");
+		const shellMode = isShellModeInput(this.getText());
+		const { railWidth } = getEditorChromeWidths(config, this.uiTheme, "\x1b[0m", shellMode);
 		const innerWidth = Math.max(0, width - railWidth);
 		let captured: { value: string[]; capture?: AutocompleteCapture };
 		try {
 			captured = renderWithAutocompleteCapture(this as unknown as AutocompleteEditorInternals, () =>
-				super.render(innerWidth),
+				this.renderBase(innerWidth),
 			);
 		} catch {
-			return clampRenderedLines(super.render(width), width);
+			return this.renderFallback(this.renderBase(width), width);
 		}
 		try {
 			const result = renderPolishedFrame({
 				width,
+				baseWidth: innerWidth,
 				baseRendered: captured.value,
 				autocompleteSource: this as unknown as AutocompleteEditorInternals,
 				autocompleteCapture: captured.capture,
 				uiTheme: this.uiTheme,
 				config,
 				modelMeta: this.getModelMeta(),
+				getWorkingLineFrame: () => this.getMinimalistMetadata().workingLineFrame,
+				reportWorkingLineBorder: this.reportWorkingLineBorder,
 				thinkingLevel: this.getThinkingLevel(),
+				shellMode,
 				trustedBaseFrame: true,
 				borderColor: this.borderColor,
 			});
-			if (result.decorated) return result.lines;
+			if (result.decorated) {
+				this.reportMetadataDecoration(true);
+				return result.lines;
+			}
 		} catch {
 			// Decoration is optional; preserve the completed same-render rows below.
 		}
-		return clampRenderedLines(captured.value, width);
+		return this.renderFallback(captured.value, width);
 	}
 }
 
 export class WrappedPolishedEditor implements EditorComponent {
+	declare readonly handleMouse?: EditorMouseHandler;
 	declare readonly addToHistory?: (text: string) => void;
 	declare readonly insertTextAtCursor?: (text: string) => void;
 	declare readonly setAutocompleteProvider?: (provider: AutocompleteProvider) => void;
 	declare readonly setPaddingX?: (padding: number) => void;
 	declare readonly setAutocompleteMaxVisible?: (maxVisible: number) => void;
 
+	private readonly mouse = new EditorMouseForwarder();
+	private workingLineBorderCapable = false;
+	private metadataDecorated = false;
+	private metadataDecoratedStyle?: EditorStyle;
+
 	constructor(
 		private readonly base: WrappedEditor,
 		private readonly uiTheme: Theme,
@@ -1021,7 +1417,15 @@ export class WrappedPolishedEditor implements EditorComponent {
 		private readonly getThinkingLevel: () => string | undefined,
 		private readonly getMinimalistMetadata: () => MinimalistEditorMetadata = () => ({ cwd: "" }),
 		private readonly onMinimalistDecorationChange: (active: boolean) => void = () => {},
+		private readonly onWorkingLineBorderCapabilityChange: () => void = () => {},
+		private readonly onMetadataDecorationChange: () => void = () => {},
 	) {
+		if (typeof base.handleMouse === "function") {
+			this.handleMouse = (event) => {
+				const handler = base.handleMouse;
+				return typeof handler === "function" ? this.mouse.forward(base, handler, event) : undefined;
+			};
+		}
 		if (typeof base.addToHistory === "function") {
 			this.addToHistory = (text) => base.addToHistory?.(text);
 		}
@@ -1043,7 +1447,11 @@ export class WrappedPolishedEditor implements EditorComponent {
 		return Boolean(this.base.focused);
 	}
 	set focused(value: boolean) {
-		this.base.focused = value;
+		try {
+			this.base.focused = value;
+		} finally {
+			if (!value) this.reportWorkingLineBorder(false);
+		}
 	}
 
 	get borderColor(): ((str: string) => string) | undefined {
@@ -1116,28 +1524,75 @@ export class WrappedPolishedEditor implements EditorComponent {
 		this.base.disableSubmit = value;
 	}
 
+	isMetadataDecorated(): boolean {
+		return (
+			this.metadataDecorated &&
+			this.metadataDecoratedStyle === this.getConfig().components.editor.style
+		);
+	}
+	private reportMetadataDecoration(active: boolean): void {
+		const style = active ? this.getConfig().components.editor.style : undefined;
+		if (this.metadataDecorated === active && this.metadataDecoratedStyle === style) return;
+		this.metadataDecorated = active;
+		this.metadataDecoratedStyle = style;
+		this.onMetadataDecorationChange();
+	}
+
 	private reportMinimalistDecoration(active: boolean): void {
 		this.onMinimalistDecorationChange(active);
 	}
 
+	private renderBase(width: number): string[] {
+		return this.mouse.baseRendered(width, this.base.render(width));
+	}
+
+	canEmbedWorkingLineBorder(): boolean {
+		return this.focused && this.workingLineBorderCapable;
+	}
+
+	private reportWorkingLineBorder = (active: boolean): void => {
+		active = active && this.focused;
+		if (this.workingLineBorderCapable === active) return;
+		this.workingLineBorderCapable = active;
+		this.onWorkingLineBorderCapabilityChange();
+	};
+
+	private renderFallback(lines: string[], width: number): string[] {
+		this.reportMetadataDecoration(false);
+		this.reportWorkingLineBorder(false);
+		return clampRenderedLines(lines, width);
+	}
+
 	render(width: number): string[] {
+		try {
+			return this.mouse.rendered(this.renderDecorated(width));
+		} catch (error) {
+			this.reportMetadataDecoration(false);
+			this.reportWorkingLineBorder(false);
+			throw error;
+		}
+	}
+
+	private renderDecorated(width: number): string[] {
 		const config = this.getConfig();
 		if (!config.components.editor.enabled) {
 			this.reportMinimalistDecoration(false);
-			return clampRenderedLines(this.base.render(width), width);
+			return this.renderFallback(this.renderBase(width), width);
 		}
 		if (config.components.editor.style === "accent-rail") {
+			this.reportMetadataDecoration(false);
+			this.reportWorkingLineBorder(false);
 			this.reportMinimalistDecoration(false);
 			if (width < ACCENT_RAIL_CHROME_WIDTH + 1) {
-				return clampRenderedLines(this.base.render(width), width);
+				return this.renderFallback(this.renderBase(width), width);
 			}
 			let captured: { value: string[]; capture?: AutocompleteCapture };
 			try {
 				captured = renderWithAutocompleteCapture(this.base, () =>
-					this.base.render(width - ACCENT_RAIL_CHROME_WIDTH),
+					this.renderBase(width - ACCENT_RAIL_CHROME_WIDTH),
 				);
 			} catch {
-				return clampRenderedLines(this.base.render(width), width);
+				return this.renderFallback(this.renderBase(width), width);
 			}
 			try {
 				const provenance = inspectPolishedFrameProvenance(
@@ -1148,7 +1603,9 @@ export class WrappedPolishedEditor implements EditorComponent {
 				);
 				if (provenance.safe) {
 					const result = renderAccentRailFrameFromBase({
+						codexQuota: this.getModelMeta().codexQuota,
 						width,
+						baseWidth: width - ACCENT_RAIL_CHROME_WIDTH,
 						baseRendered: captured.value,
 						autocompleteSource: this.base,
 						autocompleteCapture: captured.capture,
@@ -1161,21 +1618,21 @@ export class WrappedPolishedEditor implements EditorComponent {
 			} catch {
 				// Decoration is optional; preserve the completed same-render rows below.
 			}
-			return clampRenderedLines(captured.value, width);
+			return this.renderFallback(captured.value, width);
 		}
 		if (config.components.editor.style === "minimalist") {
 			if (width <= 4) {
 				this.reportMinimalistDecoration(false);
-				return clampRenderedLines(this.base.render(width), width);
+				return this.renderFallback(this.renderBase(width), width);
 			}
 			let captured: { value: string[]; capture?: AutocompleteCapture };
 			try {
 				captured = renderWithAutocompleteCapture(this.base, () =>
-					this.base.render(Math.max(0, width - 4)),
+					this.renderBase(Math.max(0, width - 4)),
 				);
 			} catch {
 				this.reportMinimalistDecoration(false);
-				return clampRenderedLines(this.base.render(width), width);
+				return this.renderFallback(this.renderBase(width), width);
 			}
 			try {
 				const provenance = inspectPolishedFrameProvenance(
@@ -1187,17 +1644,20 @@ export class WrappedPolishedEditor implements EditorComponent {
 				if (provenance.safe) {
 					const result = renderMinimalistFrameFromBase({
 						width,
+						baseWidth: Math.max(0, width - 4),
 						baseRendered: captured.value,
 						autocompleteSource: this.base,
 						autocompleteCapture: captured.capture,
 						uiTheme: this.uiTheme,
 						config,
 						inputText: this.base.getText(),
-						metadata: this.getMinimalistMetadata(),
+						getMetadata: this.getMinimalistMetadata,
+						reportWorkingLineBorder: this.reportWorkingLineBorder,
 						ownedFrame: provenance.ownedFrame,
 						borderColor: this.borderColor,
 					});
 					if (result.decorated) {
+						this.reportMetadataDecoration(true);
 						this.reportMinimalistDecoration(true);
 						return result.lines;
 					}
@@ -1206,18 +1666,19 @@ export class WrappedPolishedEditor implements EditorComponent {
 				// Decoration is optional; preserve the completed same-render rows below.
 			}
 			this.reportMinimalistDecoration(false);
-			return clampRenderedLines(captured.value, width);
+			return this.renderFallback(captured.value, width);
 		}
 		this.reportMinimalistDecoration(false);
-		if (width <= 2) return clampRenderedLines(this.base.render(width), width);
+		if (width <= 2) return this.renderFallback(this.renderBase(width), width);
 
-		const { railWidth } = getEditorChromeWidths(config, this.uiTheme, "\x1b[0m");
+		const shellMode = isShellModeInput(this.base.getText());
+		const { railWidth } = getEditorChromeWidths(config, this.uiTheme, "\x1b[0m", shellMode);
 		const innerWidth = Math.max(0, width - railWidth);
 		let captured: { value: string[]; capture?: AutocompleteCapture };
 		try {
-			captured = renderWithAutocompleteCapture(this.base, () => this.base.render(innerWidth));
+			captured = renderWithAutocompleteCapture(this.base, () => this.renderBase(innerWidth));
 		} catch {
-			return clampRenderedLines(this.base.render(width), width);
+			return this.renderFallback(this.renderBase(width), width);
 		}
 		let result: PolishedFrameResult | undefined;
 		try {
@@ -1230,14 +1691,18 @@ export class WrappedPolishedEditor implements EditorComponent {
 			if (provenance.safe) {
 				result = renderPolishedFrame({
 					width,
+					baseWidth: innerWidth,
 					baseRendered: captured.value,
 					autocompleteSource: this.base,
 					autocompleteCapture: captured.capture,
 					uiTheme: this.uiTheme,
 					config,
 					modelMeta: this.getModelMeta(),
+					getWorkingLineFrame: () => this.getMinimalistMetadata().workingLineFrame,
+					reportWorkingLineBorder: this.reportWorkingLineBorder,
 					thinkingLevel: this.getThinkingLevel(),
 					rightStatus: readVimStatus(this.base, this.uiTheme),
+					shellMode,
 					ownedFrame: provenance.ownedFrame,
 					borderColor: this.borderColor,
 				});
@@ -1245,8 +1710,11 @@ export class WrappedPolishedEditor implements EditorComponent {
 		} catch {
 			// Decoration is optional; preserve the completed same-render rows below.
 		}
-		if (result?.decorated) return result.lines;
-		return clampRenderedLines(captured.value, width);
+		if (result?.decorated) {
+			this.reportMetadataDecoration(true);
+			return result.lines;
+		}
+		return this.renderFallback(captured.value, width);
 	}
 
 	invalidate(): void {