@oh-my-pi/pi-coding-agent 17.0.0 → 17.0.2

package/src/modes/components/hook-editor.ts

@@ -7,7 +7,7 @@
  *   (Ctrl+Q / Ctrl+Enter) submits, bordered popup
  * - Prompt-style (ask): Enter submits, Shift+Enter inserts newline, legacy ask chrome
  */
-import { Container, Editor, matchesKey, Spacer, Text, type TUI } from "@oh-my-pi/pi-tui";
+import { Container, Editor, type Focusable, matchesKey, Spacer, Text, type TUI } from "@oh-my-pi/pi-tui";
 import { getEditorTheme, theme } from "../../modes/theme/theme";
 import {
 	matchesAppExternalEditor,
@@ -20,14 +20,24 @@ import { DynamicBorder } from "./dynamic-border";
 export interface HookEditorOptions {
 	/** When true, use prompt-style keybindings with the legacy ask prompt chrome. */
 	promptStyle?: boolean;
+	/**
+	 * Max rows the inner Editor may occupy. When omitted, the editor is
+	 * bounded to the current terminal height minus the component's chrome
+	 * (≈10 rows) so long content scrolls instead of pushing the submit
+	 * hint out of view.
+	 */
+	maxHeight?: number;
 }
 
-export class HookEditorComponent extends Container {
+/** Interactive multiline dialog used by hooks and the ask tool's Other response. */
+export class HookEditorComponent extends Container implements Focusable {
 	#editor: Editor;
 	#onSubmitCallback: (value: string) => void;
 	#onCancelCallback: () => void;
 	#tui: TUI;
 	#promptStyle: boolean;
+	/** Focus state mirrored to the nested editor during rendering. */
+	focused = false;
 
 	constructor(
 		tui: TUI,
@@ -47,8 +57,11 @@ export class HookEditorComponent extends Container {
 		this.addChild(new DynamicBorder());
 		this.addChild(new Spacer(1));
 
-		// Title
-		this.addChild(new Text(theme.fg("accent", title), 1, 0));
+		// Title. Prompt-style renders the borderless editor's `> ` gutter at
+		// column 0, so pad the title to match; hook-style keeps the 1-col indent
+		// that lines up with its bordered editor body (#5313).
+		const chromePadX = this.#promptStyle ? 0 : 1;
+		this.addChild(new Text(theme.fg("accent", title), chromePadX, 0));
 		this.addChild(new Spacer(1));
 
 		// Editor
@@ -58,6 +71,11 @@ export class HookEditorComponent extends Container {
 			this.#editor.setPromptGutter("> ");
 			this.#editor.disableSubmit = true;
 		}
+		// Bound the editor so long content scrolls instead of pushing the
+		// submit hint off-screen. Caller may override via options.maxHeight.
+		const termRows = this.#tui.terminal?.rows ?? process.stdout.rows ?? 40;
+		this.#editor.setMaxHeight(options?.maxHeight ?? Math.max(3, termRows - 12));
+		this.#editor.setScrollbarVisible(true);
 		if (prefill) {
 			this.#editor.setText(prefill);
 		}
@@ -69,12 +87,24 @@ export class HookEditorComponent extends Container {
 		const hint = this.#promptStyle
 			? "enter or ctrl+q submit  esc cancel  ctrl+g external editor"
 			: "ctrl+q/ctrl+enter submit  esc cancel  ctrl+g external editor";
-		this.addChild(new Text(theme.fg("dim", hint), 1, 0));
+		this.addChild(new Text(theme.fg("dim", hint), chromePadX, 0));
 
 		this.addChild(new Spacer(1));
 		this.addChild(new DynamicBorder());
 	}
 
+	/** Keep the nested editor's software/hardware cursor mode aligned with the dialog focus target. */
+	setUseTerminalCursor(useTerminalCursor: boolean): void {
+		if (this.#editor.getUseTerminalCursor() === useTerminalCursor) return;
+		this.#editor.setUseTerminalCursor(useTerminalCursor);
+	}
+
+	/** Render the dialog after forwarding its focus state to the nested editor. */
+	override render(width: number): readonly string[] {
+		this.#editor.focused = this.focused;
+		return super.render(width);
+	}
+
 	handleInput(keyData: string): void {
 		if (this.#promptStyle) {
 			this.#handlePromptStyleInput(keyData);

package/src/modes/components/login-dialog.test.ts

@@ -0,0 +1,56 @@
+import { beforeAll, describe, expect, it } from "bun:test";
+import type { TUI } from "@oh-my-pi/pi-tui";
+import { initTheme } from "../theme/theme";
+import { LoginDialogComponent } from "./login-dialog";
+
+/** Minimal TUI stub — the dialog only calls requestRender/setFocus. */
+function makeDialog(): LoginDialogComponent {
+	const tui = { requestRender() {}, setFocus() {} } as unknown as TUI;
+	return new LoginDialogComponent(tui, "openai-codex", () => {});
+}
+
+describe("LoginDialogComponent manual code input", () => {
+	beforeAll(async () => {
+		await initTheme();
+	});
+
+	it("captures a pasted fallback redirect URL and resolves on submit", async () => {
+		// Regression for #5339: paste-code providers (Codex) route the fallback
+		// URL through the focused dialog. Without a mounted input, the paste is
+		// dropped and login never completes.
+		const dialog = makeDialog();
+		dialog.showProgress("Waiting for callback");
+
+		const pending = dialog.showManualInput("Paste the authorization code:");
+		expect(dialog.render(80).join("\n")).toContain("Paste the authorization code");
+
+		const url = "http://localhost:1455/auth/callback?code=THECODE&state=abc";
+		dialog.pasteText(url);
+		dialog.handleInput("\r");
+
+		expect(await pending).toBe(url);
+	});
+
+	it("reuses the mounted input across re-prompts instead of stacking duplicates", async () => {
+		// The OAuth callback loop re-invokes onManualCodeInput after an invalid
+		// paste; the second prompt must not append a duplicate input/hint block.
+		const dialog = makeDialog();
+		dialog.showProgress("Waiting for callback");
+
+		const first = dialog.showManualInput("Paste the code:");
+		dialog.handleInput("garbage");
+		dialog.handleInput("\r");
+		expect(await first).toBe("garbage");
+
+		const second = dialog.showManualInput("Paste the code:");
+		const rendered = dialog.render(80).join("\n");
+		expect(rendered.split("Paste the code:").length - 1).toBe(1);
+		// A stale value from the first attempt must not leak into the retry.
+		expect(rendered).not.toContain("garbage");
+
+		const url = "http://localhost:1455/auth/callback?code=OK&state=abc";
+		dialog.pasteText(url);
+		dialog.handleInput("\r");
+		expect(await second).toBe(url);
+	});
+});

package/src/modes/components/login-dialog.ts

@@ -108,12 +108,16 @@ export class LoginDialogComponent extends Container {
 	 * Show input for manual code/URL entry (for callback server providers)
 	 */
 	showManualInput(prompt: string): Promise<string> {
-		this.#contentContainer.addChild(new Spacer(1));
-		this.#contentContainer.addChild(new Text(theme.fg("dim", prompt), 1, 0));
+		// Invalid pastes re-prompt (the OAuth callback loop calls this again), so
+		// reuse the already-mounted input instead of stacking duplicate prompt and
+		// hint lines beneath the dialog. Reset the value so each retry starts clean.
 		if (!this.#contentContainer.children.includes(this.#input)) {
+			this.#contentContainer.addChild(new Spacer(1));
+			this.#contentContainer.addChild(new Text(theme.fg("dim", prompt), 1, 0));
 			this.#contentContainer.addChild(this.#input);
+			this.#contentContainer.addChild(new Text(theme.fg("dim", "(Escape to cancel)"), 1, 0));
 		}
-		this.#contentContainer.addChild(new Text(theme.fg("dim", "(Escape to cancel)"), 1, 0));
+		this.#input.setValue("");
 		this.#tui.requestRender();
 
 		const { promise, resolve, reject } = Promise.withResolvers<string>();

package/src/modes/components/model-hub.ts

@@ -28,6 +28,7 @@ import {
 	visibleWidth,
 } from "@oh-my-pi/pi-tui";
 import type { ModelRegistry } from "../../config/model-registry";
+import { type ModelRoleLookup, type ResolvedModelRoleValue, resolveModelRoleValue } from "../../config/model-resolver";
 import { getKnownRoleIds, getRoleInfo } from "../../config/model-roles";
 import type { Settings } from "../../config/settings";
 import { AUTO_THINKING, type ConfiguredThinkingLevel, getConfiguredThinkingLevelMetadata } from "../../thinking";
@@ -75,11 +76,19 @@ export interface ScopedModelItem {
 	thinkingLevel?: string;
 }
 
+export type ModelRoleSelectionScope = "global" | "project";
+
 export interface ModelHubCallbacks {
 	/** Persist a role assignment. */
-	onAssign: (model: Model, role: string, thinkingLevel: ConfiguredThinkingLevel | undefined, selector: string) => void;
+	onAssign: (
+		model: Model,
+		role: string,
+		thinkingLevel: ConfiguredThinkingLevel | undefined,
+		selector: string,
+		scope?: ModelRoleSelectionScope,
+	) => void;
 	/** Clear a configured role back to auto-selection. */
-	onUnassign: (role: string) => void;
+	onUnassign: (role: string, scope?: ModelRoleSelectionScope) => void;
 	/** Persist a `retry.fallbackChains` entry — keyed by a role, `provider/model-id`, or `provider/*`; an empty chain clears the key. */
 	onFallbackChainChange?: (role: string, chain: string[]) => void;
 	/** Locked provider activation: forward to the /login flow. */
@@ -111,18 +120,20 @@ interface StripChip {
 	/** Pre-styled label body (without selection decoration). */
 	styled: string;
 	role?: string;
-	action: "assign" | "unassign" | "fallback" | "fallbackModel" | "fallbackProvider" | "thinking";
+	action: "assign" | "unassign" | "fallback" | "fallbackModel" | "fallbackProvider" | "scope" | "thinking";
 	thinkingLevel?: ConfiguredThinkingLevel;
+	scope?: ModelRoleSelectionScope;
 }
 
 type StripState =
 	| {
-			kind: "role" | "thinking";
+			kind: "role" | "scope" | "thinking";
 			item: ModelBrowserItem;
 			role?: string;
+			scope?: ModelRoleSelectionScope;
 			chips: StripChip[];
 			index: number;
-			/** Where to land when a thinking strip closes. */
+			/** Where to land when a scope or thinking strip closes. */
 			returnToRoles: boolean;
 	  }
 	| {
@@ -556,6 +567,11 @@ export class ModelHubComponent implements Component {
 		this.#tui.requestRender();
 	}
 
+	/** Re-sync after an asynchronous callback finishes mutating settings. */
+	refreshAfterExternalMutation(): void {
+		this.#refreshAfterMutation();
+	}
+
 	/**
 	 * Recompute per-provider match counts for the active query. Providers
 	 * without matches gray out and the scope hop skips them; a provider scope
@@ -745,23 +761,55 @@ export class ModelHubComponent implements Component {
 		this.#openRoleStrip(item);
 	}
 
+	#roleForScope(role: string, scope: ModelRoleSelectionScope): ResolvedModelRoleValue {
+		const roleValue =
+			scope === "project" ? this.#settings.getProjectModelRole(role) : this.#settings.getGlobalModelRole(role);
+		const allModels =
+			this.#scopedModels.length > 0 ? this.#scopedModels.map(scoped => scoped.model) : this.#registry.getAll();
+		const roleLookup: ModelRoleLookup = {
+			getModelRole: scopedRole =>
+				scope === "project"
+					? (this.#settings.getProjectModelRole(scopedRole) ?? this.#settings.getGlobalModelRole(scopedRole))
+					: this.#settings.getGlobalModelRole(scopedRole),
+		};
+		return resolveModelRoleValue(roleValue, allModels, { settings: this.#settings, roleLookup });
+	}
+
+	#thinkingLevelForScope(role: string, scope: ModelRoleSelectionScope): ConfiguredThinkingLevel {
+		const resolved = this.#roleForScope(role, scope);
+		return resolved.explicitThinkingLevel ? (resolved.thinkingLevel ?? ThinkingLevel.Inherit) : ThinkingLevel.Inherit;
+	}
+
 	/** Persist `role → item`, preserving a still-supported thinking level, then open the thinking strip. */
-	#assignRole(item: ModelBrowserItem, role: string, returnToRoles: boolean): void {
+	#assignRole(item: ModelBrowserItem, role: string, returnToRoles: boolean, scope?: ModelRoleSelectionScope): void {
+		if (this.#settings.get("modelRoleStorage") === "project" && scope === undefined) {
+			this.#openScopeStrip(item, role, returnToRoles);
+			return;
+		}
+
 		const current = this.#roles[role];
 		let level: ConfiguredThinkingLevel = ThinkingLevel.Inherit;
-		if (current && !current.autoSelected) {
-			const supported = this.#thinkingOptionsFor(item.model);
-			level = supported.includes(current.thinkingLevel) ? current.thinkingLevel : ThinkingLevel.Inherit;
-		}
-		this.#callbacks.onAssign(item.model, role, level, item.selector);
+		if (this.#settings.get("modelRoleStorage") === "project" && scope !== undefined) {
+			level = this.#thinkingLevelForScope(role, scope);
+		} else if (current && !current.autoSelected) {
+			level = current.thinkingLevel;
+		}
+		const supported = this.#thinkingOptionsFor(item.model);
+		if (!supported.includes(level)) level = ThinkingLevel.Inherit;
+		this.#callbacks.onAssign(item.model, role, level, item.selector, scope);
 		this.#refreshAfterMutation();
-		this.#openThinkingStrip(item, role, returnToRoles);
+		this.#openThinkingStrip(item, role, returnToRoles, scope);
 	}
 
 	#unassignRole(role: string): void {
 		const assignment = this.#roles[role];
 		if (!assignment || assignment.autoSelected) return;
-		this.#callbacks.onUnassign(role);
+		if (this.#settings.get("modelRoleStorage") === "project") {
+			const source = this.#settings.getModelRoleSource(role);
+			this.#callbacks.onUnassign(role, source === "default" ? undefined : source);
+		} else {
+			this.#callbacks.onUnassign(role);
+		}
 		this.#refreshAfterMutation();
 	}
 
@@ -771,24 +819,32 @@ export class ModelHubComponent implements Component {
 
 	#openRoleStrip(item: ModelBrowserItem): void {
 		const chips: StripChip[] = [];
+		const scopedStorage = this.#settings.get("modelRoleStorage") === "project";
+		const scopes: readonly ModelRoleSelectionScope[] = scopedStorage ? ["project", "global"] : ["global"];
 		for (const role of this.#visibleRoleIds()) {
 			const info = getRoleInfo(role, this.#settings);
 			const assignment = this.#roles[role];
-			const assignedHere =
-				!!assignment &&
-				!assignment.autoSelected &&
-				assignment.model.provider === item.model.provider &&
-				assignment.model.id === item.model.id;
-			const label = (info.tag ?? info.name ?? role).toLowerCase();
-			chips.push({
-				label,
-				styled: assignedHere
-					? theme.fg(info.color ?? "muted", `${theme.status.enabled}${label}`) +
-						theme.fg("dim", ` ${theme.status.success}`)
-					: theme.fg(info.color ?? "muted", label),
-				role,
-				action: assignedHere ? "unassign" : "assign",
-			});
+			for (const scope of scopes) {
+				const scopedModel = scopedStorage
+					? this.#roleForScope(role, scope).model
+					: assignment && !assignment.autoSelected
+						? assignment.model
+						: undefined;
+				const assignedHere =
+					!!scopedModel && scopedModel.provider === item.model.provider && scopedModel.id === item.model.id;
+				const roleLabel = (info.tag ?? info.name ?? role).toLowerCase();
+				const label = scopedStorage ? `${scope} ${roleLabel}` : roleLabel;
+				chips.push({
+					label,
+					styled: assignedHere
+						? theme.fg(info.color ?? "muted", `${theme.status.enabled}${label}`) +
+							theme.fg("dim", ` ${theme.status.success}`)
+						: theme.fg(info.color ?? "muted", label),
+					role,
+					scope,
+					action: assignedHere ? "unassign" : "assign",
+				});
+			}
 		}
 		chips.push({
 			label: `fallbacks:${item.model.id}`,
@@ -804,9 +860,25 @@ export class ModelHubComponent implements Component {
 		this.#strip = { kind: "role", item, chips, index: 0, returnToRoles: false };
 	}
 
-	#openThinkingStrip(item: ModelBrowserItem, role: string, returnToRoles: boolean): void {
+	#openScopeStrip(item: ModelBrowserItem, role: string, returnToRoles: boolean): void {
+		const chips: StripChip[] = [
+			{ label: "project", styled: theme.fg("accent", "project"), action: "scope", scope: "project" },
+			{ label: "global", styled: theme.fg("muted", "global"), action: "scope", scope: "global" },
+		];
+		this.#strip = { kind: "scope", item, role, chips, index: 0, returnToRoles };
+	}
+
+	#openThinkingStrip(
+		item: ModelBrowserItem,
+		role: string,
+		returnToRoles: boolean,
+		scope?: ModelRoleSelectionScope,
+	): void {
 		const options = this.#thinkingOptionsFor(item.model);
-		const current = this.#roles[role]?.thinkingLevel ?? ThinkingLevel.Inherit;
+		const current =
+			this.#settings.get("modelRoleStorage") === "project" && scope !== undefined
+				? this.#thinkingLevelForScope(role, scope)
+				: (this.#roles[role]?.thinkingLevel ?? ThinkingLevel.Inherit);
 		const chips: StripChip[] = options.map(level => {
 			const label = getConfiguredThinkingLevelMetadata(level).label;
 			const glyph = thinkingLevelGlyph(level);
@@ -822,6 +894,7 @@ export class ModelHubComponent implements Component {
 			kind: "thinking",
 			item,
 			role,
+			scope,
 			chips,
 			index: preselect >= 0 ? preselect : 0,
 			returnToRoles,
@@ -832,7 +905,7 @@ export class ModelHubComponent implements Component {
 		const strip = this.#strip;
 		this.#strip = null;
 		this.#chipRanges = [];
-		if (strip?.kind === "thinking" && strip.returnToRoles) {
+		if ((strip?.kind === "scope" || strip?.kind === "thinking") && strip.returnToRoles) {
 			this.#setActiveEntry("roles");
 			this.#focus = "list";
 		}
@@ -847,12 +920,16 @@ export class ModelHubComponent implements Component {
 			case "assign":
 				if (chip.role) {
 					this.#strip = null;
-					this.#assignRole(strip.item, chip.role, false);
+					this.#assignRole(strip.item, chip.role, false, chip.scope);
 				}
 				return;
 			case "unassign":
 				if (chip.role) {
-					this.#callbacks.onUnassign(chip.role);
+					if (this.#settings.get("modelRoleStorage") === "project") {
+						this.#callbacks.onUnassign(chip.role, chip.scope);
+					} else {
+						this.#callbacks.onUnassign(chip.role);
+					}
 					this.#refreshAfterMutation();
 				}
 				this.#closeStrip();
@@ -869,9 +946,21 @@ export class ModelHubComponent implements Component {
 				this.#closeStrip();
 				this.#startAssignFallback(`${strip.item.model.provider}/*`, null);
 				return;
+			case "scope":
+				if (strip.role && chip.scope) {
+					this.#strip = null;
+					this.#assignRole(strip.item, strip.role, strip.returnToRoles, chip.scope);
+				}
+				return;
 			case "thinking":
 				if (strip.role && chip.thinkingLevel !== undefined) {
-					this.#callbacks.onAssign(strip.item.model, strip.role, chip.thinkingLevel, strip.item.selector);
+					this.#callbacks.onAssign(
+						strip.item.model,
+						strip.role,
+						chip.thinkingLevel,
+						strip.item.selector,
+						strip.scope,
+					);
 					this.#refreshAfterMutation();
 				}
 				this.#closeStrip();
@@ -1305,13 +1394,20 @@ export class ModelHubComponent implements Component {
 		if (printable === "t") {
 			const assignment = role ? this.#roles[role] : undefined;
 			if (role && assignment) {
+				const source =
+					this.#settings.get("modelRoleStorage") === "project"
+						? this.#settings.getModelRoleSource(role)
+						: "default";
+				const scope = source === "project" || source === "global" ? source : undefined;
+				const scopedModel = scope ? this.#roleForScope(role, scope).model : assignment.model;
+				if (!scopedModel) return;
 				const item: ModelBrowserItem = {
-					provider: assignment.model.provider,
-					id: assignment.model.id,
-					model: assignment.model,
-					selector: `${assignment.model.provider}/${assignment.model.id}`,
+					provider: scopedModel.provider,
+					id: scopedModel.id,
+					model: scopedModel,
+					selector: `${scopedModel.provider}/${scopedModel.id}`,
 				};
-				this.#openThinkingStrip(item, role, true);
+				this.#openThinkingStrip(item, role, true, scope);
 			}
 			return;
 		}
@@ -1770,9 +1866,9 @@ export class ModelHubComponent implements Component {
 			if (strip.kind === "roleName") {
 				return "Enter create + pick model · Esc cancel";
 			}
-			return strip.kind === "role"
-				? "←/→ choose · Enter assign/clear · Esc cancel"
-				: "←/→ thinking level · Enter apply · Esc keep";
+			if (strip.kind === "role") return "←/→ choose · Enter assign/clear · Esc cancel";
+			if (strip.kind === "scope") return "←/→ save scope · Enter choose · Esc cancel";
+			return "←/→ thinking level · Enter apply · Esc keep";
 		}
 		if (this.#assigning !== null) {
 			switch (this.#assigning.kind) {

package/src/modes/components/plan-review-overlay.ts

@@ -138,6 +138,8 @@ export class PlanReviewOverlay implements Component {
 	#tocCursor = 0;
 	#sidebarShown = false;
 	#pendingScrollToToc = false;
+	/** Last meaningful relative body position, retained while a frame cannot scroll. */
+	#scrollProgress = 0;
 
 	// Click hit-testing, rebuilt every render. Keys are 0-based rendered-line
 	// indices (== screen rows, since the fullscreen overlay paints from row 0).
@@ -196,6 +198,7 @@ export class PlanReviewOverlay implements Component {
 	setPlanContent(planContent: string): void {
 		this.#setSections(planContent);
 		this.#scrollView.scrollToTop();
+		this.#scrollProgress = 0;
 		this.#tocCursor = 0;
 		// A wholesale external-editor swap supersedes prior in-overlay deletions.
 		this.#deleted = [];
@@ -343,6 +346,7 @@ export class PlanReviewOverlay implements Component {
 			if (event.wheel !== null) {
 				// Scroll wheel: three rows per notch.
 				this.#scrollView.scroll(event.wheel * 3);
+				this.#captureScrollProgress();
 				return true;
 			}
 			if (event.release) return true;
@@ -445,13 +449,21 @@ export class PlanReviewOverlay implements Component {
 		// drops into the actions ("next step"); scrolling off the top steps back up
 		// to the ToC.
 		if (matchesSelectUp(data) || matchesKey(data, "k")) {
-			if (this.#scrollView.getScrollOffset() <= 0 && this.#sidebarShown) this.#setFocus("toc");
-			else this.#scrollView.scroll(-1);
+			if (this.#scrollView.getScrollOffset() <= 0 && this.#sidebarShown) {
+				this.#setFocus("toc");
+			} else {
+				this.#scrollView.scroll(-1);
+				this.#captureScrollProgress();
+			}
 			return;
 		}
 		if (matchesSelectDown(data) || matchesKey(data, "j")) {
-			if (this.#scrollView.getScrollOffset() >= this.#scrollView.getMaxScrollOffset()) this.#setFocus("actions");
-			else this.#scrollView.scroll(1);
+			if (this.#scrollView.getScrollOffset() >= this.#scrollView.getMaxScrollOffset()) {
+				this.#setFocus("actions");
+			} else {
+				this.#scrollView.scroll(1);
+				this.#captureScrollProgress();
+			}
 			return;
 		}
 		this.#handleBodyScroll(data);
@@ -464,9 +476,19 @@ export class PlanReviewOverlay implements Component {
 	 * before this runs, so here it only ever sees the paging/fast keys.
 	 */
 	#handleBodyScroll(data: string): void {
-		if (this.#scrollView.handleScrollKey(data)) return;
-		if (data === "g") this.#scrollView.scrollToTop();
-		else if (data === "G") this.#scrollView.scrollToBottom();
+		if (this.#scrollView.handleScrollKey(data)) {
+			if (matchesKey(data, "home")) this.#scrollProgress = 0;
+			else if (matchesKey(data, "end")) this.#scrollProgress = 1;
+			else this.#captureScrollProgress();
+			return;
+		}
+		if (data === "g") {
+			this.#scrollView.scrollToTop();
+			this.#scrollProgress = 0;
+		} else if (data === "G") {
+			this.#scrollView.scrollToBottom();
+			this.#scrollProgress = 1;
+		}
 	}
 
 	#handleToc(data: string): void {
@@ -517,7 +539,10 @@ export class PlanReviewOverlay implements Component {
 		const sectionIndex = this.#toc[this.#tocCursor];
 		if (sectionIndex === undefined) return;
 		const offset = this.#sectionOffsets[sectionIndex];
-		if (offset !== undefined) this.#scrollView.setScrollOffset(offset);
+		if (offset !== undefined) {
+			this.#scrollView.setScrollOffset(offset);
+			this.#captureScrollProgress();
+		}
 	}
 
 	/** Greatest ToC position whose section starts at or above the scroll offset. */
@@ -690,6 +715,23 @@ export class PlanReviewOverlay implements Component {
 		return parts.join(sep);
 	}
 
+	/**
+	 * Retain relative progress across reflow frames. A non-scrollable intermediate
+	 * frame has no meaningful offset, so it must not erase the last scroll position.
+	 */
+	#captureScrollProgress(): void {
+		const maxOffset = this.#scrollView.getMaxScrollOffset();
+		if (maxOffset > 0) this.#scrollProgress = this.#scrollView.getScrollOffset() / maxOffset;
+	}
+
+	#layoutBody(lines: readonly string[], height: number): void {
+		this.#captureScrollProgress();
+		this.#scrollView.setLines(lines);
+		this.#scrollView.setHeight(height);
+		const maxOffset = this.#scrollView.getMaxScrollOffset();
+		if (maxOffset > 0) this.#scrollView.setScrollOffset(Math.round(this.#scrollProgress * maxOffset));
+	}
+
 	/** Build the concatenated body lines and record each section's start row. */
 	#buildBody(bodyContentWidth: number): string[] {
 		const lines: string[] = [];
@@ -807,8 +849,7 @@ export class PlanReviewOverlay implements Component {
 		const regionRows = Math.max(MIN_BODY_ROWS, termHeight - chrome);
 
 		const bodyLines = this.#buildBody(bodyContentWidth);
-		this.#scrollView.setLines(bodyLines);
-		this.#scrollView.setHeight(regionRows);
+		this.#layoutBody(bodyLines, regionRows);
 		if (this.#pendingScrollToToc) {
 			this.#pendingScrollToToc = false;
 			this.#scrubBodyToToc();

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

@@ -760,6 +760,7 @@ export class SessionSelectorComponent extends Container {
 	#globalSessions: SessionInfo[] | null = null;
 	#scope: "folder" | "all" = "folder";
 	#toggling = false;
+	#inputLocked = false;
 	// 0-based line where the session list begins within this component's own
 	// render, captured each frame. The fullscreen picker overlay paints from
 	// screen row 0, so a mouse row maps to `row - #listLineOffset` inside the
@@ -874,6 +875,14 @@ export class SessionSelectorComponent extends Container {
 	setOnRequestRender(callback: () => void): void {
 		this.#onRequestRender = callback;
 	}
+	/** Ignore input after selection while the host resumes the session. */
+	lockInput(): void {
+		this.#inputLocked = true;
+	}
+	/** Re-enable input after a failed resume so the user can pick again. */
+	unlockInput(): void {
+		this.#inputLocked = false;
+	}
 
 	/**
 	 * Dispose the session list explicitly: while the delete-confirmation dialog
@@ -972,6 +981,7 @@ export class SessionSelectorComponent extends Container {
 	}
 
 	handleInput(keyData: string): void {
+		if (this.#inputLocked) return;
 		if (keyData.startsWith("\x1b[<")) {
 			this.#handleMouse(keyData);
 			return;

package/src/modes/components/status-line/component.test.ts

@@ -36,6 +36,7 @@ function makeSessionWithLastMessage(lastMessage: unknown, prewalkArmed: boolean
 		getPrewalkState: () => (prewalkArmed ? { target: { id: "cheap-model", provider: "openai" } } : undefined),
 		getAsyncJobSnapshot: () => undefined,
 		isAdvisorActive: () => false,
+		getAdvisorStatusOverview: () => ({ configured: false, advisors: [] }),
 		isFastModeActive: () => false,
 		configuredThinkingLevel: () => undefined,
 		modelRegistry: {

package/src/modes/components/status-line/component.ts

@@ -1334,10 +1334,8 @@ export class StatusLineComponent implements Component {
 			return [];
 		}
 
-		const sortedStatuses = Array.from(this.#hookStatuses.entries())
+		return Array.from(this.#hookStatuses.entries())
 			.sort(([a], [b]) => a.localeCompare(b))
-			.map(([, text]) => sanitizeStatusText(text));
-		const hookLine = sortedStatuses.join(" ");
-		return [truncateToWidth(hookLine, width)];
+			.map(([, text]) => truncateToWidth(sanitizeStatusText(text), width));
 	}
 }