@oh-my-pi/pi-coding-agent 17.0.4 → 17.0.5

package/src/modes/components/transcript-container.ts

@@ -3,7 +3,6 @@ import {
 	Container,
 	type NativeScrollbackCommittedRows,
 	type NativeScrollbackLiveRegion,
-	type NativeScrollbackReplay,
 	type RenderStablePrefix,
 	type ViewportTailProvider,
 } from "@oh-my-pi/pi-tui";
@@ -19,17 +18,11 @@ interface FinalizableBlock {
 	/**
 	 * Monotonic content version for blocks that can still mutate *after*
 	 * reporting finalized (e.g. `AssistantMessageComponent`: the inline error
-	 * restored at the next turn's `agent_start`, late tool-result images). While
-	 * the block's rows are still on screen (not yet fully committed), the
-	 * committed-scrollback render bypass replays its previous rows only when the
-	 * version is unchanged; a bump forces a real render so the TUI's
-	 * committed-prefix audit can observe and re-anchor the change. Once the rows
-	 * fully commit to native scrollback they are dropped from the local frame
-	 * (compacted) — a later mutation no longer recommits on an ordinary frame
-	 * (immutable history the terminal owns; recommitting would duplicate it) and
-	 * instead rehydrates on the next destructive full replay
-	 * ({@link "@oh-my-pi/pi-tui".NativeScrollbackReplay}). Blocks that never
-	 * mutate post-finalize simply omit the method.
+	 * restored at the next turn's `agent_start`, late tool-result images). The
+	 * committed-scrollback render bypass only replays a block's previous rows
+	 * when the version is unchanged; without this signal a post-finalize
+	 * mutation would stay invisible until a global invalidation. Blocks that
+	 * never mutate post-finalize simply omit the method.
 	 */
 	getTranscriptBlockVersion?(): number;
 	/**
@@ -130,8 +123,6 @@ interface BlockSegment {
 	sep: number;
 	/** Whether the block reported finalized when this segment was rendered. */
 	finalized: boolean;
-	/** Safe to drop from the local frame once its rows fully commit to native scrollback: produced while finalized. */
-	compactable: boolean;
 	/** Block version observed when this segment was rendered (see {@link FinalizableBlock}). */
 	version: number | undefined;
 }
@@ -167,12 +158,7 @@ const EMPTY_TAIL: readonly string[] = [];
  */
 export class TranscriptContainer
 	extends Container
-	implements
-		NativeScrollbackLiveRegion,
-		NativeScrollbackCommittedRows,
-		NativeScrollbackReplay,
-		RenderStablePrefix,
-		ViewportTailProvider
+	implements NativeScrollbackLiveRegion, NativeScrollbackCommittedRows, RenderStablePrefix, ViewportTailProvider
 {
 	// Bumped to retire every block segment at once (theme change / clear); a
 	// segment is only reused when its stored generation matches.
@@ -181,6 +167,7 @@ export class TranscriptContainer
 	// final: the leading finalized blocks plus the first live block's declared
 	// settled rows. TUI commits rows to native scrollback only above it.
 	#nativeScrollbackLiveRegionStart: number | undefined;
+	#nativeScrollbackLiveRegionPinned = false;
 	// Persistent assembled transcript rows. Rows before the stable floor are
 	// byte-identical to the previous render; rows at/after it were re-pushed.
 	#lines: string[] = [];
@@ -190,14 +177,6 @@ export class TranscriptContainer
 	// Finalized blocks wholly before this boundary are immutable on-screen history;
 	// their previous contribution can be replayed without calling render().
 	#committedRows = 0;
-	// Leading children whose rows were handed to native scrollback and dropped
-	// from the local frame. Children remain owned by the session and can be
-	// re-rendered when the TUI prepares a destructive full replay.
-	#compactedChildStart = 0;
-	// Suppresses re-compaction for the rehydrating render. The TUI feeds its old
-	// committed-row count immediately before render, so resetting that count
-	// alone cannot distinguish a replay from an ordinary update.
-	#replayPending = false;
 	// Stable-prefix floor accumulated across renders since the last
 	// getRenderStablePrefixRows() read (see RenderStablePrefix: reading
 	// consumes the report and re-bases the baseline). Out-of-band renders
@@ -213,14 +192,12 @@ export class TranscriptContainer
 	override clear(): void {
 		this.#generation++;
 		super.clear();
-		this.#compactedChildStart = 0;
 		this.#committedRows = 0;
-		this.#replayPending = false;
 	}
 
 	override setNativeScrollbackCommittedRows(rows: number): void {
 		this.#committedRows = Number.isFinite(rows) ? Math.max(0, Math.trunc(rows)) : 0;
-		for (let i = this.#compactedChildStart; i < this.children.length; i++) {
+		for (let i = 0; i < this.children.length; i++) {
 			const child = this.children[i]!;
 			const segment = this.#segments[i];
 			if (segment === undefined || segment.component !== child) continue;
@@ -243,18 +220,6 @@ export class TranscriptContainer
 		}
 	}
 
-	override prepareNativeScrollbackReplay(): void {
-		// Replay retires the old terminal tape, so descendants may discard layout
-		// locks whose only purpose was keeping that immutable history byte-stable.
-		super.prepareNativeScrollbackReplay();
-		if (this.#compactedChildStart === 0) return;
-		this.#compactedChildStart = 0;
-		this.#replayPending = true;
-		this.#generation++;
-		this.#lines.length = 0;
-		this.#stableRowsFloor = 0;
-	}
-
 	getRenderStablePrefixRows(): number {
 		const value = Math.min(this.#stableRowsFloor, this.#lines.length);
 		this.#stableRowsFloor = this.#lines.length;
@@ -265,6 +230,11 @@ export class TranscriptContainer
 		return this.#nativeScrollbackLiveRegionStart;
 	}
 
+	/** Propagates viewport pinning from the first still-mutating transcript block. */
+	isNativeScrollbackLiveRegionPinned(): boolean {
+		return this.#nativeScrollbackLiveRegionPinned;
+	}
+
 	/**
 	 * Whether none of `component`'s rows (per the most recent render) have
 	 * entered native scrollback. Callers that retract ephemeral blocks (IRC
@@ -275,14 +245,8 @@ export class TranscriptContainer
 	 * committed rows and is safely removable.
 	 */
 	isBlockUncommitted(component: Component): boolean {
-		const index = this.children.indexOf(component);
-		// Compacted prefix is already committed native history and must not be
-		// retracted. Compacted slots may be sparse holes after a later re-render
-		// (render only fills from #compactedChildStart), so the loop below must
-		// skip undefined entries.
-		if (index >= 0 && index < this.#compactedChildStart) return false;
 		for (const segment of this.#segments) {
-			if (segment === undefined || segment.component !== component) continue;
+			if (segment.component !== component) continue;
 			return segment.rowCount === 0 || segment.startRow >= this.#committedRows;
 		}
 		return true;
@@ -336,7 +300,7 @@ export class TranscriptContainer
 		if (maxRows <= 0) return EMPTY_TAIL;
 		const collected: (readonly string[])[] = [];
 		let total = 0;
-		for (let i = this.children.length - 1; i >= this.#compactedChildStart && total < maxRows; i--) {
+		for (let i = this.children.length - 1; i >= 0 && total < maxRows; i--) {
 			const contribution = stripPlainBlankEdges(this.children[i]!.render(width));
 			if (contribution.length === 0) continue;
 			// One blank separator sits between this block and the (already
@@ -358,9 +322,9 @@ export class TranscriptContainer
 	override render(width: number): readonly string[] {
 		width = Math.max(1, width);
 		this.#nativeScrollbackLiveRegionStart = undefined;
+		this.#nativeScrollbackLiveRegionPinned = false;
 
 		const count = this.children.length;
-		if (this.#compactedChildStart > count) this.#compactedChildStart = count;
 
 		// Seal displaceable snapshots whose rows are already on the tape (per the
 		// previous frame's segments — the geometry the committed count was
@@ -370,7 +334,7 @@ export class TranscriptContainer
 		// frame, and every frame so a block that BECAME displaceable after its
 		// pending-preview rows committed (late result on a scrolled-off call) is
 		// caught too.
-		for (let i = this.#compactedChildStart; i < count && i < this.#segments.length; i++) {
+		for (let i = 0; i < count && i < this.#segments.length; i++) {
 			const previous = this.#segments[i];
 			if (previous === undefined) continue;
 			if (previous.startRow >= this.#committedRows) break;
@@ -386,10 +350,14 @@ export class TranscriptContainer
 		// reaches.
 		let liveStartIndex = -1;
 		let hasLiveBlock = false;
-		for (let i = this.#compactedChildStart; i < count; i++) {
+		for (let i = 0; i < count; i++) {
 			if (!isBlockFinalized(this.children[i]!)) {
 				liveStartIndex = i;
 				hasLiveBlock = true;
+				this.#nativeScrollbackLiveRegionPinned =
+					(
+						this.children[i] as Component & Partial<NativeScrollbackLiveRegion>
+					).isNativeScrollbackLiveRegionPinned?.() === true;
 				break;
 			}
 		}
@@ -418,7 +386,7 @@ export class TranscriptContainer
 		// Frame row cursor: rows emitted (reused or pushed) so far.
 		let row = 0;
 		let stableRows = 0;
-		for (let i = this.#compactedChildStart; i < count; i++) {
+		for (let i = 0; i < count; i++) {
 			const child = this.children[i]!;
 
 			// This child's contribution: its current render with plain-blank
@@ -459,7 +427,6 @@ export class TranscriptContainer
 					previous.width === width &&
 					previous.generation === this.#generation);
 			const contribution = reusable ? previous.contribution : stripPlainBlankEdges(raw);
-			const compactable = finalized && previous?.finalized !== false;
 
 			// Empty (or stripped-to-nothing) children contribute nothing and never
 			// affect spacing. An empty still-live child still gates the commit
@@ -484,7 +451,6 @@ export class TranscriptContainer
 					rowCount: 0,
 					sep: 0,
 					finalized,
-					compactable,
 					version,
 				};
 				continue;
@@ -536,7 +502,6 @@ export class TranscriptContainer
 				rowCount,
 				sep,
 				finalized,
-				compactable,
 				version,
 			};
 			row += rowCount;
@@ -546,72 +511,8 @@ export class TranscriptContainer
 		if (lines.length !== row) lines.length = row;
 		this.#segments = segments;
 		this.#stableRowsFloor = Math.min(stableFloorBefore, stableRows, row);
-		if (this.#replayPending) {
-			this.#replayPending = false;
-		} else {
-			this.#compactCommittedPrefix();
-		}
 		return lines;
 	}
-
-	#compactCommittedPrefix(): void {
-		if (this.#committedRows <= 0 || this.#compactedChildStart >= this.children.length) return;
-		const lines = this.#lines;
-		const segments = this.#segments;
-		let dropRows = 0;
-		let dropUntil = this.#compactedChildStart;
-		for (let i = this.#compactedChildStart; i < segments.length; i++) {
-			const segment = segments[i];
-			if (segment === undefined || !segment.compactable) break;
-			const segmentEnd = segment.startRow + segment.rowCount;
-			if (segmentEnd > this.#committedRows) break;
-			dropRows = segmentEnd;
-			dropUntil = i + 1;
-		}
-		const retained = segments[dropUntil];
-		if (retained !== undefined && retained.sep > 0) {
-			const committedSeparatorRows = this.#committedRows - retained.startRow;
-			if (committedSeparatorRows <= 0) {
-				dropRows = 0;
-				dropUntil = this.#compactedChildStart;
-			} else {
-				const trim = Math.min(retained.sep, committedSeparatorRows);
-				dropRows += trim;
-				retained.sep -= trim;
-				retained.rowCount -= trim;
-			}
-		}
-		if (dropRows === 0) return;
-
-		lines.splice(0, dropRows);
-		for (let i = this.#compactedChildStart; i < dropUntil; i++) {
-			const segment = segments[i];
-			if (segment === undefined) continue;
-			segments[i] = {
-				component: segment.component,
-				rawRef: EMPTY_TAIL,
-				contribution: EMPTY_TAIL,
-				width: segment.width,
-				generation: segment.generation,
-				startRow: 0,
-				rowCount: 0,
-				sep: 0,
-				finalized: true,
-				compactable: false,
-				version: segment.version,
-			};
-		}
-		for (let i = dropUntil; i < segments.length; i++) {
-			const segment = segments[i];
-			if (segment !== undefined) segment.startRow -= dropRows;
-		}
-		this.#compactedChildStart = dropUntil;
-		this.#committedRows = Math.max(0, this.#committedRows - dropRows);
-		this.#stableRowsFloor = 0;
-		if (this.#nativeScrollbackLiveRegionStart !== undefined) {
-			this.#nativeScrollbackLiveRegionStart = Math.max(0, this.#nativeScrollbackLiveRegionStart - dropRows);
-		}
-	}
 }
 
 /**

package/src/modes/components/tree-selector.ts

@@ -66,7 +66,7 @@ class TreeList implements Component {
 	#activePathIds: Set<string> = new Set();
 	#lastSelectedId: string | null = null;
 
-	onSelect?: (entryId: string) => void;
+	onSelect?: (entryId: string, options: { summarize: boolean }) => void;
 	onCancel?: () => void;
 	onLabelEdit?: (entryId: string, currentLabel: string | undefined) => void;
 
@@ -792,10 +792,16 @@ class TreeList implements Component {
 		} else if (matchesKey(keyData, "right")) {
 			// Page down
 			this.#selectedIndex = Math.min(this.#filteredNodes.length - 1, this.#selectedIndex + this.maxVisibleLines);
+		} else if (matchesKey(keyData, "shift+enter") || matchesKey(keyData, "shift+return")) {
+			// Summarize-and-switch: fork with a branch summary without the extra prompt.
+			const selected = this.#filteredNodes[this.#selectedIndex];
+			if (selected && this.onSelect) {
+				this.onSelect(selected.node.entry.id, { summarize: true });
+			}
 		} else if (matchesKey(keyData, "enter") || matchesKey(keyData, "return") || keyData === "\n") {
 			const selected = this.#filteredNodes[this.#selectedIndex];
 			if (selected && this.onSelect) {
-				this.onSelect(selected.node.entry.id);
+				this.onSelect(selected.node.entry.id, { summarize: false });
 			}
 		} else if (matchesAppInterrupt(keyData)) {
 			if (this.#searchQuery) {
@@ -923,7 +929,7 @@ export class TreeSelectorComponent extends Container {
 		tree: SessionTreeNode[],
 		currentLeafId: string | null,
 		terminalHeight: number,
-		onSelect: (entryId: string) => void,
+		onSelect: (entryId: string, options: { summarize: boolean }) => void,
 		onCancel: () => void,
 		private readonly onLabelChangeCallback?: (entryId: string, label: string | undefined) => void,
 		initialFilterMode: FilterMode = "default",
@@ -948,7 +954,7 @@ export class TreeSelectorComponent extends Container {
 			new TruncatedText(
 				theme.fg(
 					"muted",
-					"Up/Down: move. Left/Right: page. Shift+L: label. Ctrl+O/Shift+Ctrl+O: filter. Alt+D/T/U/L/A: filter. Type to search",
+					"Enter: switch. Shift+Enter: summarize & switch. Shift+L: label. Ctrl+O: filter. Alt+D/T/U/L/A: filter. Type to search",
 				),
 				0,
 				0,

package/src/modes/controllers/event-controller.ts

@@ -247,7 +247,6 @@ export class EventController {
 		toolCallId: string,
 		result: { content: Array<{ type: string; data?: string; mimeType?: string }> },
 	): boolean {
-		if (!settings.get("terminal.showImages")) return false;
 		const assistantComponent = this.#readToolCallAssistantComponents.get(toolCallId);
 		if (!assistantComponent) return false;
 		const images: ImageContent[] = result.content
@@ -258,7 +257,7 @@ export class EventController {
 			.map(content => ({ type: "image", data: content.data, mimeType: content.mimeType }));
 		if (images.length === 0) return false;
 		assistantComponent.setToolResultImages(toolCallId, images);
-		return true;
+		return settings.get("terminal.showImages");
 	}
 
 	#insertAfterTranscriptComponent(anchor: Component | undefined, component: Component): boolean {

package/src/modes/controllers/input-controller.ts

@@ -771,7 +771,7 @@ export class InputController {
 			// While loop mode is on, every user-typed prompt becomes the new loop
 			// prompt that auto-resubmits after each yield.
 			if (this.ctx.loopModeEnabled) {
-				this.ctx.loopPrompt = text;
+				this.ctx.setLoopPrompt(text);
 			}
 
 			// Queue input during compaction

package/src/modes/controllers/selector-controller.ts

@@ -442,13 +442,20 @@ export class SelectorController {
 				break;
 
 			// Settings with UI side effects
-			case "showImages":
+			case "terminal.showImages":
+			case "showImages": {
+				const visible = value as boolean;
 				for (const child of this.ctx.chatContainer.children) {
 					if (child instanceof ToolExecutionComponent) {
-						child.setShowImages(value as boolean);
+						child.setShowImages(visible);
+					} else if (child instanceof AssistantMessageComponent) {
+						child.setImagesVisible(visible);
 					}
 				}
+				if (!visible) this.ctx.ui.clearInlineImages();
+				this.ctx.ui.resetDisplay();
 				break;
+			}
 			case "hideThinkingBlock":
 				this.ctx.hideThinkingBlock = value as boolean;
 				for (const child of this.ctx.chatContainer.children) {
@@ -1130,7 +1137,7 @@ export class SelectorController {
 				tree,
 				realLeafId,
 				this.ctx.ui.terminal.rows,
-				async entryId => {
+				async (entryId, options) => {
 					// Selecting the current leaf is a no-op (already there)
 					if (entryId === realLeafId) {
 						done();
@@ -1141,13 +1148,15 @@ export class SelectorController {
 					// Ask about summarization
 					done(); // Close selector first
 
-					// Loop until user makes a complete choice or cancels to tree
-					let wantsSummary = false;
+					// Loop until user makes a complete choice or cancels to tree.
+					// Shift+Enter in the tree selector pre-answers "Summarize" and
+					// skips the prompt entirely.
+					let wantsSummary = options.summarize;
 					let customInstructions: string | undefined;
 
 					const branchSummariesEnabled = settings.get("branchSummary.enabled");
 
-					while (branchSummariesEnabled) {
+					while (!wantsSummary && branchSummariesEnabled) {
 						const summaryChoice = await this.ctx.showHookSelector("Summarize branch?", [
 							"No summary",
 							"Summarize",
@@ -1476,7 +1485,14 @@ export class SelectorController {
 				// focus (#5339).
 				onManualCodeInput: useManualInput ? () => dialog.showManualInput(MANUAL_LOGIN_PROMPT) : undefined,
 			});
-			this.ctx.session.modelRegistry.refreshInBackground();
+			// Scope the post-login refresh to the just-authenticated provider with an
+			// `online` strategy: the default all-provider `online-if-uncached` reuses
+			// a fresh authoritative cache row (e.g. an empty result fetched before
+			// login), so newly persisted credentials would never re-run discovery and
+			// models would stay unavailable in-session (#5780). Unrelated providers
+			// are left untouched. `refreshProvider` swallows discovery failures, so
+			// awaiting cannot reject the login.
+			await this.ctx.session.modelRegistry.refreshProvider(providerId, "online");
 			const block = new TranscriptBlock();
 			// Name the account (and Anthropic organization) that was stored so a
 			// login that lands on an unintended account/subscription is visible
@@ -1516,7 +1532,12 @@ export class SelectorController {
 				return;
 			}
 
-			await this.ctx.session.modelRegistry.refresh();
+			// Provider-scoped online refresh so the removed credential's stale
+			// endpoint/deployment models are invalidated deterministically; the
+			// default all-provider `online-if-uncached` would reuse the fresh
+			// authoritative cache row and keep showing models the credential
+			// unlocked (#5780). Other providers are left untouched.
+			await this.ctx.session.modelRegistry.refreshProvider(providerId, "online");
 			const block = new TranscriptBlock();
 			block.addChild(
 				new Text(

package/src/modes/interactive-mode.ts

@@ -208,6 +208,8 @@ import type {
 } from "./types";
 import { UiHelpers } from "./utils/ui-helpers";
 
+const STILL_CLOSING_DELAY_MS = 3_000;
+
 const HINT_SHIMMER_PALETTE: ShimmerPalette = {
 	low: "dim",
 	mid: "muted",
@@ -451,6 +453,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	vibeModeEnabled = false;
 	planModePlanFilePath: string | undefined = undefined;
 	loopModeEnabled = false;
+	loopModePaused = false;
 	loopPrompt: string | undefined = undefined;
 	loopLimit: LoopLimitRuntime | undefined = undefined;
 	#loopAutoSubmitTimer: NodeJS.Timeout | undefined;
@@ -696,6 +699,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.errorBannerContainer = new AnchoredLiveContainer();
 		this.modelCycleContainer = new AnchoredLiveContainer();
 		this.editor = new CustomEditor(getEditorTheme());
+		this.ui.enableScopedInputRender(this.editor);
 		this.editor.setUseTerminalCursor(this.ui.getShowHardwareCursor());
 		this.editor.setImeSafeCursorLayout(settings.get("tui.imeSafeCursor"));
 		this.editor.setAutocompleteMaxVisible(settings.get("autocompleteMaxVisible"));
@@ -1349,6 +1353,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.disableLoopMode("Loop limit reached. Loop mode disabled.");
 			return;
 		}
+		this.#syncLoopModeStatus();
 
 		if (action === "compact") {
 			await this.handleCompactCommand();
@@ -1358,19 +1363,36 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#submitLoopPromptWhenReady(prompt);
 	}
 
+	#syncLoopModeStatus(): void {
+		const state: "waiting" | "running" | "paused" = this.loopModePaused
+			? "paused"
+			: this.loopPrompt
+				? "running"
+				: "waiting";
+		this.statusLine.setLoopModeStatus(this.loopModeEnabled ? { state, limit: this.loopLimit } : undefined);
+		this.ui.requestRender();
+	}
+
 	disableLoopMode(message = "Loop mode disabled."): void {
 		const wasEnabled = this.loopModeEnabled;
 		this.loopModeEnabled = false;
+		this.loopModePaused = false;
 		this.loopPrompt = undefined;
 		this.loopLimit = undefined;
 		this.#cancelLoopAutoSubmit();
-		this.statusLine.setLoopModeStatus(undefined);
-		this.ui.requestRender();
+		this.#syncLoopModeStatus();
 		if (wasEnabled) {
 			this.showStatus(message);
 		}
 	}
 
+	setLoopPrompt(prompt: string): void {
+		if (!this.loopModeEnabled) return;
+		this.loopPrompt = prompt;
+		this.loopModePaused = false;
+		this.#syncLoopModeStatus();
+	}
+
 	/**
 	 * Pause the loop without exiting it: drops the captured prompt and any
 	 * pending auto-resubmit. Loop mode stays enabled — the next prompt the
@@ -1378,7 +1400,9 @@ export class InteractiveMode implements InteractiveModeContext {
 	 */
 	pauseLoop(): void {
 		this.loopPrompt = undefined;
+		this.loopModePaused = true;
 		this.#cancelLoopAutoSubmit();
+		this.#syncLoopModeStatus();
 	}
 
 	async handleLoopCommand(args = ""): Promise<string | undefined> {
@@ -1392,10 +1416,10 @@ export class InteractiveMode implements InteractiveModeContext {
 			return undefined;
 		}
 		this.loopModeEnabled = true;
+		this.loopModePaused = false;
 		this.loopPrompt = undefined;
 		this.loopLimit = createLoopLimitRuntime(parsed.limit);
-		this.statusLine.setLoopModeStatus({ enabled: true });
-		this.ui.requestRender();
+		this.#syncLoopModeStatus();
 		const limitSuffix = parsed.limit ? ` Limited to ${describeLoopLimit(parsed.limit)}.` : "";
 		const remainingSuffix = this.loopLimit ? ` ${describeLoopLimitRuntime(this.loopLimit)}.` : "";
 		const tail = parsed.prompt ? "Repeating it after each turn." : "Your next prompt will repeat after each turn.";
@@ -3746,10 +3770,17 @@ export class InteractiveMode implements InteractiveModeContext {
 		// first runs the work, the other awaits the same settled promise.
 		// The teardown is registered lazily in `init()` — a `/exit` reached
 		// before `init()` completed falls back to a direct dispose.
-		if (this.#signalTeardown) {
-			await this.#signalTeardown();
-		} else {
-			await this.session.dispose({ mnemopiConsolidateTimeoutMs: SHUTDOWN_CONSOLIDATE_BUDGET_MS });
+		const stillClosingTimer = setTimeout(() => {
+			this.showStatus("Still closing… (flushing memory backend / network)");
+		}, STILL_CLOSING_DELAY_MS);
+		try {
+			if (this.#signalTeardown) {
+				await this.#signalTeardown();
+			} else {
+				await this.session.dispose({ mnemopiConsolidateTimeoutMs: SHUTDOWN_CONSOLIDATE_BUDGET_MS });
+			}
+		} finally {
+			clearTimeout(stillClosingTimer);
 		}
 
 		// Do not force a final render during teardown: disposed session/UI state can
@@ -3794,6 +3825,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		const nextEditor = factory
 			? factory(this.ui, getEditorTheme(), this.keybindings)
 			: new CustomEditor(getEditorTheme());
+		if (!factory) this.ui.enableScopedInputRender(nextEditor);
 
 		nextEditor.setUseTerminalCursor(this.ui.getShowHardwareCursor());
 		nextEditor.setImeSafeCursorLayout(this.settings.get("tui.imeSafeCursor"));

package/src/modes/noninteractive-dispose.test.ts

@@ -8,6 +8,7 @@
 import { describe, expect, it, spyOn } from "bun:test";
 import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import type { AgentSession } from "../session/agent-session";
+import * as telemetryExport from "../telemetry-export";
 import { runPrintMode } from "./print-mode";
 
 /** Stand-in for `process.exit`: it terminates, so nothing after it should run. */
@@ -35,11 +36,20 @@ describe("print-mode error exit disposes the session before exit", () => {
 			extensionRunner: undefined,
 			subscribe: () => {},
 			state: { messages: [errorMsg] },
+			getLastAssistantMessage: () => errorMsg,
+			prepareForHeadlessAdvisorDrain: () => {},
+			waitForAdvisorCatchup: async () => {
+				order.push("catchup");
+				return true;
+			},
 			dispose: async () => {
 				order.push("dispose");
 			},
 		} as unknown as AgentSession;
 
+		const flushSpy = spyOn(telemetryExport, "flushTelemetryExport").mockImplementation(async () => {
+			order.push("flush");
+		});
 		const exitSpy = spyOn(process, "exit").mockImplementation(((code: number) => {
 			order.push("exit");
 			throw new ProcessExit(code);
@@ -53,8 +63,9 @@ describe("print-mode error exit disposes the session before exit", () => {
 		} finally {
 			exitSpy.mockRestore();
 			stderrSpy.mockRestore();
+			flushSpy.mockRestore();
 		}
 
-		expect(order).toEqual(["dispose", "exit"]);
+		expect(order).toEqual(["catchup", "flush", "dispose", "exit"]);
 	});
 });

package/src/modes/print-mode.ts

@@ -6,7 +6,7 @@
  * - `omp --mode json "prompt"` - JSON event stream
  */
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
-import type { AssistantMessage, ImageContent } from "@oh-my-pi/pi-ai";
+import type { ImageContent } from "@oh-my-pi/pi-ai";
 import { logger, sanitizeText } from "@oh-my-pi/pi-utils";
 import { type AgentSession, type AgentSessionEvent, SHUTDOWN_CONSOLIDATE_BUDGET_MS } from "../session/agent-session";
 import { isSilentAbort } from "../session/messages";
@@ -29,6 +29,11 @@ export interface PrintModeOptions {
 	printThoughts?: boolean;
 }
 
+/** Matches the longest built-in provider request deadline while bounding tool-loop stalls. */
+export const PRINT_MODE_ADVISOR_DRAIN_TIMEOUT_MS = 10 * 60_000;
+/** Error exits cannot hold automation for the full normal drain budget. */
+export const PRINT_MODE_ERROR_ADVISOR_DRAIN_TIMEOUT_MS = 30_000;
+
 /** Drop the provider-opaque replay payload (e.g. encrypted reasoning items) before printing. */
 function stripProviderPayload<T extends AgentMessage>(message: T): T {
 	if (!("providerPayload" in message) || message.providerPayload === undefined) return message;
@@ -130,14 +135,19 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 		await logger.time("print:prompt:next", () => session.prompt(message));
 	}
 
+	// From this point onward a late blocker must be recorded without starting a
+	// primary turn whose response print mode would never emit.
+	session.prepareForHeadlessAdvisorDrain();
+
 	// In text mode, output final response
 	if (mode === "text") {
-		const state = session.state;
-		const lastMessage = state.messages[state.messages.length - 1];
-
-		if (lastMessage?.role === "assistant") {
-			const assistantMsg = lastMessage as AssistantMessage;
+		// Read via the session accessor, not the raw state tail: a classifier
+		// refusal is pruned from active context at settle, and an aborted turn
+		// can trail synthetic tool results — both would hide the terminal
+		// assistant message (and its error) from a last-element read.
+		const assistantMsg = session.getLastAssistantMessage();
 
+		if (assistantMsg) {
 			// Check for error/aborted — skip silent-abort (plan-mode compaction transition)
 			if (
 				(assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") &&
@@ -151,6 +161,7 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 				// `dispose()` (releaseTabsForOwner) actually runs — otherwise an
 				// OMP-owned Chromium survives this exit (issue #5643). `dispose()`
 				// is idempotent, so the unreachable call below is a harmless no-op.
+				await session.waitForAdvisorCatchup(PRINT_MODE_ERROR_ADVISOR_DRAIN_TIMEOUT_MS);
 				await flushTelemetryExport();
 				await session.dispose({ mnemopiConsolidateTimeoutMs: SHUTDOWN_CONSOLIDATE_BUDGET_MS });
 				const flushed = process.stderr.write(`${errorLine}\n`);
@@ -180,14 +191,15 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 		}
 	}
 
-	// Ensure stdout is fully flushed before returning
-	// This prevents race conditions where the process exits before all output is written
+	await session.waitForAdvisorCatchup(PRINT_MODE_ADVISOR_DRAIN_TIMEOUT_MS);
+
+	// Ensure stdout, including late JSON advisor events, is fully flushed before returning.
+	// This prevents race conditions where the process exits before all output is written.
 	await new Promise<void>((resolve, reject) => {
 		process.stdout.write("", err => {
 			if (err) reject(err);
 			else resolve();
 		});
 	});
-
 	await session.dispose({ mnemopiConsolidateTimeoutMs: SHUTDOWN_CONSOLIDATE_BUDGET_MS });
 }