pi-open-tui 0.4.0 → 0.4.2

package/extensions/open-tui/editor.ts

@@ -2,9 +2,8 @@ import {
 	CustomEditor,
 	type ExtensionAPI,
 	type ExtensionContext,
-	type KeybindingsManager,
 } from "@earendil-works/pi-coding-agent";
-import type { EditorTheme, TuiMouseEvent, TuiMouseEventResult, TUI } from "@earendil-works/pi-tui";
+import type { Component, Container, EditorComponent, TUI } from "@earendil-works/pi-tui";
 import { CURSOR_MARKER, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import type { CursorStyle } from "./config.ts";
 import { findBottomBorderIndex, isEditorBorderLine, stripAnsi } from "./utils.ts";
@@ -23,6 +22,8 @@ const DEFAULT_CURSOR_STYLE_SEQUENCE = "\x1b[0 q";
 const EDITOR_FRAME_LEFT_INSET = 2;
 const EDITOR_FRAME_HORIZONTAL_CHROME = EDITOR_FRAME_LEFT_INSET * 2;
 
+type EditorFactory = NonNullable<Parameters<ExtensionContext["ui"]["setEditorComponent"]>[0]>;
+
 interface WorkingStatusIndicator {
 	renderInBorder(width: number): string;
 	renderSpinnerInBorder(width: number): string;
@@ -200,125 +201,204 @@ function inlineBorder(
 	return `${paint(corners[0])}${left}${leftCell}${paint("─".repeat(fill))}${rightCell}${right}${paint("─")}${paint(corners[1])}`;
 }
 
-export class OpenTuiEditor extends CustomEditor {
-	readonly embedWorkingStatus = true;
-	private readonly getRail: () => string;
-	private readonly getBorder: (s: string) => string;
-	private embeddedWorkingStatusIndicator: WorkingStatusIndicator | undefined;
-	private readonly inlineFooter: InlineFooterRenderer | undefined;
-	private cursorStyle: CursorStyle;
-	private previewHardwareCursor = false;
-
-	constructor(
-		tui: TUI,
-		editorTheme: EditorTheme,
-		keybindings: KeybindingsManager,
-		cursorStyle: CursorStyle = "block",
-		inlineFooter?: InlineFooterRenderer,
-	) {
-		super(tui, editorTheme, keybindings, { paddingX: 0 });
-		this.cursorStyle = cursorStyle;
-		this.inlineFooter = inlineFooter;
-		configureCursor(tui, cursorStyle);
-		// ponytail: route the frame through this.borderColor so Pi can recolor it
-		// via updateEditorBorderColor() — bash mode ("! " prefix → green) and
-		// thinking-level borders both flow through this one property.
-		this.getRail = () => this.borderColor("│");
-		this.getBorder = (s: string) => this.borderColor(s);
-	}
-
-	override setPaddingX(_padding: number): void {
-		// The custom rail owns the horizontal inset and keeps one stable text gap.
-		super.setPaddingX(0);
-	}
+interface OpenTuiEditorOptions {
+	cursorStyle?: CursorStyle;
+	inlineFooter?: InlineFooterRenderer;
+}
 
-	override handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
-		if (event.width < EDITOR_FRAME_HORIZONTAL_CHROME) return super.handleMouse(event);
+/** Capabilities this decorator adds to the editor instance it wraps. */
+interface OpenTuiEditorDecoration {
+	embedWorkingStatus?: boolean;
+	setWorkingStatusIndicator(indicator: WorkingStatusIndicator | undefined): void;
+	setCursorStyle(cursorStyle: CursorStyle, blockHardwareCursor?: boolean): void;
+}
 
-		return super.handleMouse({
-			...event,
-			x: event.x - EDITOR_FRAME_LEFT_INSET,
-			width: event.width - EDITOR_FRAME_HORIZONTAL_CHROME,
-		});
-	}
+type FrameableEditor = EditorComponent & Pick<CustomEditor,
+	"focused" | "borderColor" | "handleMouse" | "getPaddingX" | "setPaddingX"
+>;
+
+// 按能力识别，避免跨模块加载时 instanceof 失效；仅支持保留 Pi 原生布局的编辑器。
+function isFrameableEditor(editor: EditorComponent): editor is FrameableEditor {
+	return typeof editor.borderColor === "function"
+		&& typeof editor.handleMouse === "function"
+		&& "getPaddingX" in editor && typeof editor.getPaddingX === "function"
+		&& typeof editor.setPaddingX === "function"
+		&& "focused" in editor && typeof editor.focused === "boolean";
+}
 
-	setWorkingStatusIndicator(indicator: WorkingStatusIndicator | undefined): void {
-		this.embeddedWorkingStatusIndicator = indicator;
-		this.tui.requestRender();
-	}
+interface EditorDecoration {
+	tui: TUI;
+	editor: FrameableEditor;
+	cursorStyle: CursorStyle;
+	previewHardwareCursor: boolean;
+	inlineFooter: InlineFooterRenderer | undefined;
+	indicator: WorkingStatusIndicator | undefined;
+	baseRender: (width: number) => string[];
+	framedWidth: number | undefined;
+	active: boolean;
+	cleanup(): void;
+}
 
-	setCursorStyle(cursorStyle: CursorStyle, blockHardwareCursor = false): void {
-		const styleChanged = cursorStyle !== this.cursorStyle;
-		this.previewHardwareCursor = cursorStyle !== "block";
-		this.cursorStyle = cursorStyle;
-		if (styleChanged) {
-			if (cursorStyle === "block") {
-				this.tui.terminal.write(DEFAULT_CURSOR_STYLE_SEQUENCE);
-				this.tui.setShowHardwareCursor(blockHardwareCursor);
-			} else {
-				configureCursor(this.tui, cursorStyle);
-			}
+// One decoration per instance: installing twice must not stack two frames.
+const DECORATIONS = new WeakMap<object, EditorDecoration>();
+
+function applyCursorStyle(
+	decoration: EditorDecoration,
+	cursorStyle: CursorStyle,
+	blockHardwareCursor = false,
+): void {
+	const styleChanged = cursorStyle !== decoration.cursorStyle;
+	decoration.previewHardwareCursor = cursorStyle !== "block";
+	decoration.cursorStyle = cursorStyle;
+	if (styleChanged) {
+		const tui = decoration.tui;
+		if (cursorStyle === "block") {
+			tui.terminal.write(DEFAULT_CURSOR_STYLE_SEQUENCE);
+			tui.setShowHardwareCursor(blockHardwareCursor);
+		} else {
+			configureCursor(tui, cursorStyle);
 		}
-		this.tui.requestRender();
 	}
+	decoration.tui.requestRender();
+}
 
-	private renderBase(width: number): string[] {
-		const renderedLines = super.render(width);
-		if (this.cursorStyle === "block") return renderedLines;
-
-		// Pi re-applies settings.showHardwareCursor after session_start (/reload,
-		// /new, session switches). Non-block styles have no software cursor left to
-		// fall back on, so re-assert the hardware cursor instead of losing it.
-		if (!this.tui.getShowHardwareCursor()) configureCursor(this.tui, this.cursorStyle);
-
-		// A focused overlay suppresses the editor's cursor marker. Preserve its
-		// position only for the live settings preview, then clear it on refocus.
-		let cursorMarker = this.previewHardwareCursor && !this.focused ? CURSOR_MARKER : "";
-		if (this.focused) this.previewHardwareCursor = false;
-		return renderedLines.map((line) => {
-			const rendered = removeSoftwareCursor(line, cursorMarker);
-			if (rendered !== line) cursorMarker = "";
-			return rendered;
-		});
-	}
+function renderWithCursor(decoration: EditorDecoration, width: number): string[] {
+	const renderedLines = decoration.baseRender(width);
+	if (decoration.cursorStyle === "block") return renderedLines;
+
+	const tui = decoration.tui;
+	// Pi re-applies settings.showHardwareCursor after session_start (/reload,
+	// /new, session switches). Non-block styles have no software cursor left to
+	// fall back on, so re-assert the hardware cursor instead of losing it.
+	if (!tui.getShowHardwareCursor()) configureCursor(tui, decoration.cursorStyle);
+
+	// A focused overlay suppresses the editor's cursor marker. Preserve its
+	// position only for the live settings preview, then clear it on refocus.
+	const focused = decoration.editor.focused;
+	let cursorMarker = decoration.previewHardwareCursor && !focused ? CURSOR_MARKER : "";
+	if (focused) decoration.previewHardwareCursor = false;
+	return renderedLines.map((line) => {
+		const rendered = removeSoftwareCursor(line, cursorMarker);
+		if (rendered !== line) cursorMarker = "";
+		return rendered;
+	});
+}
 
-	render(width: number): string[] {
-		if (width < EDITOR_FRAME_HORIZONTAL_CHROME) return this.renderBase(width);
-
-		const rail = this.getRail();
-		const borderPaint = this.getBorder;
-		// ponytail: 1-char rail + 1-char gap on each side = 4 chars of chrome.
-		const innerWidth = Math.max(0, width - EDITOR_FRAME_HORIZONTAL_CHROME);
-		const baseLines = this.renderBase(innerWidth);
-		const bottomIdx = findBottomBorderIndex(baseLines);
-
-		const result: string[] = [];
-		const inlineFooter = this.inlineFooter?.enabled() === true;
-		const renderInlineLine = (kind: "top" | "bottom", budget: number): InlineFooterLine | undefined =>
-			this.inlineFooter?.render(budget)?.[kind];
-		result.push(inlineFooter
-			? inlineBorder(width, "top", borderPaint, (budget) => renderInlineLine("top", budget), baseLines[0], this.embeddedWorkingStatusIndicator)
-			: roundedBorder(width, "top", borderPaint, baseLines[0], this.embeddedWorkingStatusIndicator));
-
-		for (let i = 1; i < bottomIdx; i++) {
-			const line = baseLines[i] ?? "";
-			if (isEditorBorderLine(line)) {
-				result.push(`${rail} ${fillLine("", innerWidth)} ${rail}`);
-			} else {
-				result.push(`${rail} ${fillLine(line, innerWidth)} ${rail}`);
-			}
-		}
+function renderFrame(decoration: EditorDecoration, width: number): string[] {
+	decoration.framedWidth = undefined;
+	if (width < EDITOR_FRAME_HORIZONTAL_CHROME) return renderWithCursor(decoration, width);
 
-		result.push(inlineFooter
-			? inlineBorder(width, "bottom", borderPaint, (budget) => renderInlineLine("bottom", budget), baseLines[bottomIdx])
-			: roundedBorder(width, "bottom", borderPaint, baseLines[bottomIdx]));
+	const innerWidth = Math.max(0, width - EDITOR_FRAME_HORIZONTAL_CHROME);
+	const baseLines = renderWithCursor(decoration, innerWidth);
+	const bottomIdx = findBottomBorderIndex(baseLines);
+	if (bottomIdx <= 1 || !isEditorBorderLine(baseLines[0] ?? "") || !isEditorBorderLine(baseLines[bottomIdx] ?? "")) {
+		return renderWithCursor(decoration, width);
+	}
+	const borderPaint = (text: string) => decoration.editor.borderColor(text);
+	const rail = borderPaint("│");
+
+	const result: string[] = [];
+	const inlineFooter = decoration.inlineFooter?.enabled() === true;
+	const renderInlineLine = (kind: "top" | "bottom", budget: number): InlineFooterLine | undefined =>
+		decoration.inlineFooter?.render(budget)?.[kind];
+	result.push(inlineFooter
+		? inlineBorder(width, "top", borderPaint, (budget) => renderInlineLine("top", budget), baseLines[0], decoration.indicator)
+		: roundedBorder(width, "top", borderPaint, baseLines[0], decoration.indicator));
+
+	for (let i = 1; i < bottomIdx; i++) {
+		const line = baseLines[i] ?? "";
+		result.push(`${rail} ${fillLine(line, innerWidth)} ${rail}`);
+	}
 
-		for (let i = bottomIdx + 1; i < baseLines.length; i++) {
-			result.push(baseLines[i]!);
-		}
+	result.push(inlineFooter
+		? inlineBorder(width, "bottom", borderPaint, (budget) => renderInlineLine("bottom", budget), baseLines[bottomIdx])
+		: roundedBorder(width, "bottom", borderPaint, baseLines[bottomIdx]));
 
-		return result.map((line) => truncateToWidth(line, width, ""));
+	for (let i = bottomIdx + 1; i < baseLines.length; i++) {
+		result.push(baseLines[i]!);
 	}
+
+	decoration.framedWidth = width;
+	return result.map((line) => truncateToWidth(line, width, ""));
+}
+
+/**
+ * Adds the open-tui frame to an existing editor **in place** and returns that same
+ * instance. Patching (instead of wrapping) keeps `onSubmit` / `onChange` / `handleInput`
+ * on one object, so Pi and every extension that wrapped the factory before us keep working.
+ */
+export function decorateOpenTuiEditor<T extends FrameableEditor>(
+	editor: T,
+	tui: TUI,
+	options: OpenTuiEditorOptions = {},
+): T & OpenTuiEditorDecoration {
+	const existing = DECORATIONS.get(editor);
+	if (existing) return editor as T & OpenTuiEditorDecoration;
+
+	const decorated = editor as FrameableEditor & OpenTuiEditorDecoration;
+	const restore: (() => void)[] = [];
+	const baseHandleMouse = editor.handleMouse.bind(editor);
+	const baseSetPaddingX = editor.setPaddingX.bind(editor);
+	const baseSetWorkingStatus = decorated.setWorkingStatusIndicator?.bind(editor);
+	const baseSetCursorStyle = decorated.setCursorStyle?.bind(editor);
+	let padding = editor.getPaddingX();
+	const decoration: EditorDecoration = {
+		tui,
+		editor,
+		cursorStyle: options.cursorStyle ?? "block",
+		previewHardwareCursor: false,
+		inlineFooter: options.inlineFooter,
+		indicator: undefined,
+		baseRender: editor.render.bind(editor),
+		framedWidth: undefined,
+		active: true,
+		cleanup() {
+			if (!decoration.active) return;
+			decoration.active = false;
+			for (const undo of restore) undo();
+			baseSetPaddingX(padding);
+			DECORATIONS.delete(editor);
+		},
+	};
+	// 只撤销仍属于自己的属性；后来包装的方法会通过 active=false 调用原实现。
+	const patch = <K extends keyof OpenTuiEditorDecoration | "render" | "handleMouse" | "setPaddingX">(
+		key: K,
+		value: (FrameableEditor & OpenTuiEditorDecoration)[K],
+	): void => {
+		const descriptor = Object.getOwnPropertyDescriptor(editor, key);
+		decorated[key] = value;
+		restore.push(() => {
+			if (decorated[key] !== value) return;
+			if (descriptor) Object.defineProperty(editor, key, descriptor);
+			else Reflect.deleteProperty(editor, key);
+		});
+	};
+	DECORATIONS.set(editor, decoration);
+	configureCursor(tui, decoration.cursorStyle);
+	patch("embedWorkingStatus", true);
+	patch("setWorkingStatusIndicator", (indicator) => {
+		if (!decoration.active) return baseSetWorkingStatus?.(indicator);
+		decoration.indicator = indicator;
+		tui.requestRender();
+	});
+	patch("setCursorStyle", (style, hardware = false) => {
+		if (decoration.active) applyCursorStyle(decoration, style, hardware);
+		else baseSetCursorStyle?.(style, hardware);
+	});
+	patch("render", (width) => decoration.active
+		? renderFrame(decoration, width)
+		: decoration.baseRender(width));
+	patch("handleMouse", (event) => baseHandleMouse(
+		decoration.active && event.width === decoration.framedWidth
+			? { ...event, x: event.x - EDITOR_FRAME_LEFT_INSET, width: event.width - EDITOR_FRAME_HORIZONTAL_CHROME }
+			: event,
+	));
+	patch("setPaddingX", (nextPadding) => {
+		padding = nextPadding;
+		baseSetPaddingX(decoration.active ? 0 : nextPadding);
+	});
+	baseSetPaddingX(0);
+	return editor as T & OpenTuiEditorDecoration;
 }
 
 type StreamWrite = (...args: unknown[]) => boolean;
@@ -364,7 +444,8 @@ export function installEditor(
 	inlineFooter?: InlineFooterRenderer,
 ) {
 	let activeTui: TUI | undefined;
-	let activeEditor: OpenTuiEditor | undefined;
+	let activeEditor: (FrameableEditor & OpenTuiEditorDecoration) | undefined;
+	let enabled = true;
 	let previousHardwareCursor: boolean | undefined;
 	let currentCursorStyle = cursorStyle;
 	let hiddenThinkingTarget: HiddenThinkingLabelComponent | undefined;
@@ -410,14 +491,114 @@ export function installEditor(
 		if (activeTui?.mode === "fullscreen") activeTui.requestRender(true);
 	});
 
-	ctx.ui.setEditorComponent((tui, editorTheme, keybindings) => {
+	const ui = ctx.ui;
+	const originalSetEditor = ui.setEditorComponent;
+	const originalGetEditor = ui.getEditorComponent;
+	let inheritedFactory = originalGetEditor.call(ui);
+	let mountedEditor: EditorComponent | undefined;
+	let mountedFactory: EditorFactory | undefined;
+	let mountedRender: EditorComponent["render"] | undefined;
+	let restoreEditorMount: (() => void) | undefined;
+	const releaseEditor = (): void => {
+		if (activeEditor) DECORATIONS.get(activeEditor)?.cleanup();
+		activeEditor = undefined;
+		if (activeTui && previousHardwareCursor !== undefined) {
+			if (currentCursorStyle !== "block") activeTui.terminal.write(DEFAULT_CURSOR_STYLE_SEQUENCE);
+			activeTui.setShowHardwareCursor(previousHardwareCursor);
+		}
+		previousHardwareCursor = undefined;
+	};
+	const mountEditor = (tui: TUI, editor: EditorComponent): void => {
+		releaseEditor();
 		activeTui = tui;
+		mountedEditor = editor;
+		mountedFactory = originalGetEditor.call(ui);
 		resetHiddenThinkingTarget();
-		previousHardwareCursor = tui.getShowHardwareCursor();
-		activeEditor = new OpenTuiEditor(tui, editorTheme, keybindings, currentCursorStyle, inlineFooter);
-		return activeEditor;
-	});
+		if (isFrameableEditor(editor)) {
+			let lines: string[] = [];
+			try {
+				lines = editor.render(tui.terminal.columns);
+			} catch {
+				// A failed layout probe must not prevent Pi from mounting the editor.
+			}
+			const bottom = findBottomBorderIndex(lines);
+			// Capabilities alone do not guarantee that the first and bottom rows are replaceable borders.
+			if (bottom > 1 && isEditorBorderLine(lines[0] ?? "") && isEditorBorderLine(lines[bottom] ?? "")) {
+				previousHardwareCursor = tui.getShowHardwareCursor?.();
+				activeEditor = decorateOpenTuiEditor(editor, tui, { cursorStyle: currentCursorStyle, inlineFooter });
+			}
+		}
+		mountedRender = editor.render;
+	};
+	const wrapFactory = (delegate: EditorFactory | undefined): EditorFactory => {
+		const wrapped: EditorFactory = (tui, editorTheme, keybindings) => {
+			let inner: EditorComponent | undefined;
+			try {
+				inner = delegate?.(tui, editorTheme, keybindings);
+			} catch {
+				// 上游工厂不可用时保留默认编辑器。
+			}
+			inner ??= new CustomEditor(tui, editorTheme, keybindings, { paddingX: 0 });
+			// A factory captured by another context must keep its original delegate.
+			if (enabled && originalGetEditor.call(ui) === wrapped) mountEditor(tui, inner);
+			return inner;
+		};
+		return wrapped;
+	};
+	let factory = wrapFactory(inheritedFactory);
+	const getEditor: typeof ui.getEditorComponent = () => {
+		const current = originalGetEditor.call(ui);
+		return enabled && current === factory ? inheritedFactory : current;
+	};
+	const setEditor: typeof ui.setEditorComponent = (next) => {
+		if (!enabled) return originalSetEditor.call(ui, next);
+		inheritedFactory = next;
+		factory = wrapFactory(next);
+		originalSetEditor.call(ui, factory);
+	};
+	ui.getEditorComponent = getEditor;
+	ui.setEditorComponent = setEditor;
+	originalSetEditor.call(ui, factory);
+
+	// Shortcut contexts have a fresh ui object; intercept their shared mount before status routing.
+	const pending: Component[] = activeTui ? [activeTui] : [];
+	const visited = new Set<Component>();
+	while (pending.length > 0) {
+		const component = pending.pop()!;
+		if (visited.has(component)) continue;
+		visited.add(component);
+		const container = component as Partial<Container>;
+		if (!Array.isArray(container.children)) continue;
+		if (!mountedEditor || !container.children.includes(mountedEditor) || typeof container.addChild !== "function") {
+			pending.push(...container.children);
+			continue;
+		}
+		const target = container as Container;
+		const original = target.addChild;
+		const descriptor = Object.getOwnPropertyDescriptor(target, "addChild");
+		const patched: typeof original = function (this: Container, child) {
+			const candidate = child as Partial<EditorComponent>;
+			// Reused instances can have a new factory or render; unchanged dialog returns need no remount.
+			if (enabled && activeTui
+				&& (child !== mountedEditor || originalGetEditor.call(ui) !== mountedFactory || child.render !== mountedRender)
+				&& typeof candidate.getText === "function" && typeof candidate.setText === "function"
+				&& typeof candidate.handleInput === "function"
+				&& typeof candidate.onSubmit === "function" && candidate.onSubmit === mountedEditor?.onSubmit
+				&& typeof candidate.onChange === "function" && candidate.onChange === mountedEditor?.onChange) {
+				mountEditor(activeTui, candidate as EditorComponent);
+			}
+			original.call(this, child);
+		};
+		target.addChild = patched;
+		restoreEditorMount = () => {
+			if (target.addChild !== patched) return;
+			if (descriptor) Object.defineProperty(target, "addChild", descriptor);
+			else Reflect.deleteProperty(target, "addChild");
+		};
+		break;
+	}
 	return {
+		isFramed: () => enabled && activeEditor !== undefined,
 		/** `build` receives the hidden-thinking text width and runs again whenever that width changes. */
 		setLatestHiddenThinkingLabel(build: (width: number) => string): void {
 			const tui = getActiveTui();
@@ -429,17 +610,28 @@ export function installEditor(
 			tui.requestRender();
 		},
 		resetHiddenThinkingLabelTarget: resetHiddenThinkingTarget,
+		getTui: (): TUI | undefined => activeTui,
 		setCursorStyle(nextCursorStyle: CursorStyle): void {
 			currentCursorStyle = nextCursorStyle;
 			activeEditor?.setCursorStyle(nextCursorStyle, previousHardwareCursor);
 		},
 		cleanup(): void {
+			if (!enabled) return;
+			enabled = false;
+			restoreEditorMount?.();
+			releaseEditor();
 			restoreStderr();
 			resetHiddenThinkingTarget();
-			ctx.ui.setEditorComponent(undefined);
-			if (activeTui) {
-				if (currentCursorStyle !== "block") activeTui.terminal.write(DEFAULT_CURSOR_STYLE_SEQUENCE);
-				if (previousHardwareCursor !== undefined) activeTui.setShowHardwareCursor(previousHardwareCursor);
+			// 只恢复自己的代理；后来捕获的代理会在停用后透传到原接口。
+			if (ui.setEditorComponent === setEditor) ui.setEditorComponent = originalSetEditor;
+			if (ui.getEditorComponent === getEditor) ui.getEditorComponent = originalGetEditor;
+			const current = originalGetEditor.call(ui);
+			if (current === factory || current === mountedFactory) {
+				try {
+					originalSetEditor.call(ui, current === factory ? inheritedFactory : current);
+				} catch {
+					originalSetEditor.call(ui, undefined);
+				}
 			}
 		},
 	};

package/extensions/open-tui/footer.ts

@@ -226,6 +226,7 @@ export interface FooterHooks {
 	setRequestRender: (fn: (() => void) | undefined) => void;
 	scheduleGitRefresh: () => void;
 	getLiveTps?: () => LiveTps | null;
+	canEmbedInEditor?: () => boolean;
 }
 
 interface FooterDataLike {
@@ -274,7 +275,7 @@ function fitInlineSegments(
 		parts,
 		Math.max(0, width - separatorReserve),
 		theme.fg("dim", "..."),
-	).join(separator);
+	).filter(Boolean).join(separator);
 }
 
 function renderFooterContent(
@@ -321,7 +322,7 @@ function renderFooterContent(
 		leftParts.push({
 			text: `${cwdPrefix}${accent(truncatePath(cwd, maxCwd))}`,
 			compactText: `${cwdPrefix}${accent(truncatePath(basenamePath(cwd), maxCwd))}`,
-			priority: 0,
+			priority: 4,
 			truncate: (_text, maxWidth, ellipsis) => {
 				const pathWidth = maxWidth - visibleWidth(cwdPrefix);
 				if (pathWidth <= visibleWidth(ellipsis)) {
@@ -337,7 +338,7 @@ function renderFooterContent(
 		if (shortHost) {
 			leftParts.push({
 				text: `${theme.fg("dim", glyphs.host)} ${theme.fg("accent", shortHost)}`,
-				priority: 1,
+				priority: 3,
 			});
 			inlineTopRightParts.push(leftParts.at(-1)!);
 		}
@@ -355,13 +356,13 @@ function renderFooterContent(
 	}
 	const gitSeg = renderGitSegment(theme, state.git, glyphs, segments);
 	if (gitSeg) {
-		leftParts.push({ text: gitSeg, priority: 3 });
+		leftParts.push({ text: gitSeg, priority: 1 });
 		inlineTopLeftParts.push(leftParts.at(-1)!);
 	}
 	if (segments.runtime) {
 		const runtimeSeg = renderRuntimeSegment(theme, state.runtime, config.icons.mode, segments.nerdIconSpacing);
 		if (runtimeSeg) {
-			leftParts.push({ text: runtimeSeg, priority: 4 });
+			leftParts.push({ text: runtimeSeg, priority: 0 });
 			inlineTopRightParts.push(leftParts.at(-1)!);
 		}
 	}
@@ -374,7 +375,7 @@ function renderFooterContent(
 			? timerSeg
 			: `${timerSeg} ${theme.fg("dim", "·")} ${theme.fg(liveTps.stale ? "dim" : "accent", `${glyphs.speed} ~${Math.round(liveTps.tps)} tok/s`)}`;
 		// Narrow widths shed the live TPS before the timer itself.
-		leftParts.push({ text, compactText: liveTps === null ? undefined : timerSeg, priority: 1 });
+		leftParts.push({ text, compactText: liveTps === null ? undefined : timerSeg, priority: 3 });
 		inlineTopRightParts.push(leftParts.at(-1)!);
 	}
 
@@ -391,15 +392,15 @@ function renderFooterContent(
 	}
 	const allParts: PrioritizedSegment[] = [...leftParts];
 	if (contextText) {
-		// ponytail: priority 4 = sheds with runtime, before git/timer/cwd.
-		allParts.push({ text: contextText, compactText: contextCompact, priority: 4 });
+		// Context sheds with runtime, before git/session/host/timer/cwd.
+		allParts.push({ text: contextText, compactText: contextCompact, priority: 0 });
 		// Context stays at the far right; cwd is the first item in this group.
-		inlineTopRightParts.push({ text: contextText, compactText: contextCompact, priority: 4 });
+		inlineTopRightParts.push({ text: contextText, compactText: contextCompact, priority: 0 });
 	}
 
 	const fitted = fitSegmentsByPriority(allParts, width, theme.fg("dim", "..."));
 	const fittedContext = contextText ? fitted.pop() ?? "" : "";
-	const line1 = alignRight(fitted.join(" "), fittedContext, width, theme);
+	const line1 = alignRight(fitted.filter(Boolean).join(" "), fittedContext, width, theme);
 
 	const inlineLeftBudget = Math.floor(width * 0.45);
 	const inlineTopLeft = fitInlineSegments(inlineTopLeftParts, inlineLeftBudget, theme);
@@ -468,7 +469,8 @@ export function installFooter(
 			render(width: number): string[] {
 				if (width <= 0) return [""];
 				const { mainLines, extensionLines } = getContent(width);
-				return getConfig().inlineFooter ? extensionLines : [...mainLines, ...extensionLines];
+				const inline = getConfig().inlineFooter && (hooks.canEmbedInEditor?.() ?? true);
+				return inline ? extensionLines : [...mainLines, ...extensionLines];
 			},
 		};
 	});

package/extensions/open-tui/git.ts

@@ -58,7 +58,7 @@ export async function readGitStatus(
 	options: { readCommit?: boolean; readTag?: boolean; readCounts?: boolean } = {},
 ): Promise<GitStatus> {
 	const stdout = await gitExec(
-		["status", "--porcelain=v1", "--branch", "--show-stash"],
+		["status", "--porcelain=v1", "--branch"],
 		cwd,
 	);
 	if (stdout === null) {
@@ -67,7 +67,6 @@ export async function readGitStatus(
 
 	const status = emptyGitStatus();
 	const lines = stdout.split("\n");
-	let stashSupported = true;
 
 	for (const line of lines) {
 		if (line.startsWith("## ")) {
@@ -89,17 +88,7 @@ export async function readGitStatus(
 			continue;
 		}
 
-		if (line.startsWith("# stash ")) {
-			const stashCount = parseInt(line.slice(8).trim(), 10);
-			if (!Number.isNaN(stashCount)) {
-				status.stashed = stashCount;
-				stashSupported = true;
-			}
-			continue;
-		}
-
-		// ponytail: skip file-entry counting when only branch/commit display is on;
-		// the first `git status` call itself can't be split, but the stash fallback below can.
+		// Skip file-entry counting and the separate stash query for branch-only display.
 		if (options.readCounts === false) continue;
 		if (line.length < 3) continue;
 		const x = line[0]!;
@@ -107,19 +96,21 @@ export async function readGitStatus(
 
 		if (x === "U" || y === "U" || (x === "A" && y === "A") || (x === "D" && y === "D")) status.conflicted++;
 		else if (x === "?" && y === "?") status.untracked++;
-		else if (x === "R") status.renamed++;
-		else if (x === "D" || y === "D") status.deleted++;
+		else if (x === "R") {
+			status.renamed++;
+			if (y === "M") status.modified++;
+			else if (y === "D") status.deleted++;
+		} else if (x === "D" || y === "D") status.deleted++;
 		else {
 			if (x !== " " && x !== "?") status.staged++;
 			if (y === "M" || y === "D") status.modified++;
 		}
 	}
 
-	if (options.readCounts !== false && stashSupported && status.stashed === 0 && !stdout.includes("# stash")) {
-		const stashOut = await gitExec(["stash", "list", "--count"], cwd);
+	if (options.readCounts !== false) {
+		const stashOut = await gitExec(["stash", "list", "--format=%H"], cwd);
 		if (stashOut !== null) {
-			const count = parseInt(stashOut.trim(), 10);
-			if (!Number.isNaN(count)) status.stashed = count;
+			status.stashed = stashOut.split("\n").filter((line) => line.trim() !== "").length;
 		}
 	}
 
@@ -138,16 +129,3 @@ export async function readGitStatus(
 
 	return status;
 }
-
-export function hasGitChanges(s: GitStatus): boolean {
-	return (
-		s.modified > 0 ||
-		s.untracked > 0 ||
-		s.staged > 0 ||
-		s.conflicted > 0 ||
-		s.renamed > 0 ||
-		s.deleted > 0 ||
-		s.ahead > 0 ||
-		s.behind > 0
-	);
-}