@iowarp/clio-coder 0.3.8 → 0.4.0

package/src/interactive/overlay-frame.ts

@@ -4,12 +4,14 @@ import {
 	type Component,
 	type OverlayHandle,
 	type OverlayOptions,
+	type OverlayUnfocusOptions,
 	type SelectListTheme,
 	type SettingsListTheme,
 	type TUI,
 	truncateToWidth,
 	visibleWidth,
 } from "../engine/tui.js";
+import { enterModal, type ModalMarkerSink } from "./modal-marker.js";
 import { type ClioToken, clioTheme, padAnsi, screenTitle, selectListTheme, settingsListTheme } from "./theme/index.js";
 
 export const IDENTITY = (text: string): string => text;
@@ -464,6 +466,15 @@ export class ClioOverlayFrame implements Component {
  * screen at 40x12. It learns the terminal height through the `visible`
  * predicate, which the engine evaluates with the live dimensions in the same
  * pass that renders the overlay.
+ *
+ * This is also where the modal marker is claimed and released. Every framed
+ * overlay is modal and every modal is framed: the only two overlays Clio shows
+ * without a frame are the context and task islands, and both pass
+ * `nonCapturing: true` straight to the engine. Hanging the marker here rather
+ * than on the overlay lifecycle therefore covers the nested frames the
+ * lifecycle's single `OverlayState` cannot see, and it cannot drift out of
+ * sync with what actually owns the keyboard, because the same call that takes
+ * the screen takes the marker.
  */
 export function showClioOverlayFrame(
 	tui: TUI,
@@ -473,12 +484,21 @@ export function showClioOverlayFrame(
 		footerHint?: string | ((innerWidth: number) => string | undefined);
 		/** Border and title token; omitted leaves the informational frame. */
 		tone?: OverlayTone;
+		/**
+		 * Stable id for the modal marker, published on the terminal title while
+		 * this overlay owns the keys. Required, and deliberately not defaulted
+		 * from `title`: several titles carry a session id, a decision
+		 * classification, or the active tab, and an id that moves with the
+		 * content is not an identifier. Use `modalMarkerId(...)` where the title
+		 * really is fixed and surface-specific.
+		 */
+		markerId: string;
 	},
 ): OverlayHandle {
-	const { title, footerHint, tone, width, visible, maxHeight, margin, ...overlayOptions } = options;
+	const { title, footerHint, tone, width, visible, maxHeight, margin, markerId, ...overlayOptions } = options;
 	const boxWidth = typeof width === "number" ? width : 0;
 	const frame = new ClioOverlayFrame(child, title, footerHint, boxWidth, frameAlignForAnchor(options.anchor), tone);
-	return tui.showOverlay(frame, {
+	const handle = tui.showOverlay(frame, {
 		...overlayOptions,
 		...(margin !== undefined ? { margin } : {}),
 		width: "100%",
@@ -493,6 +513,42 @@ export function showClioOverlayFrame(
 			return shown;
 		},
 	});
+	const marker = enterModal(markerId, modalMarkerSink(tui));
+	return {
+		hide(): void {
+			marker.release();
+			handle.hide();
+		},
+		setHidden(hidden: boolean): void {
+			marker.setActive(!hidden);
+			handle.setHidden(hidden);
+		},
+		isHidden: (): boolean => handle.isHidden(),
+		focus(): void {
+			marker.raise();
+			handle.focus();
+		},
+		// A pure passthrough on purpose. The engine hands focus to the next
+		// visible capturing overlay, which is another modal, so the stack is
+		// unchanged; the surface that gives the keyboard back to the composer
+		// does it by hiding, which `setHidden` already reports.
+		unfocus: (unfocusOptions?: OverlayUnfocusOptions): void =>
+			unfocusOptions ? handle.unfocus(unfocusOptions) : handle.unfocus(),
+		isFocused: (): boolean => handle.isFocused(),
+	};
+}
+
+/**
+ * The title sink behind a TUI, or null when there is none.
+ *
+ * The engine's `Terminal` declares `setTitle`, but the stub TUIs the overlay
+ * tests mount against are structural casts that carry only what the overlay
+ * under test reads. Probing for the method keeps the marker inert on those
+ * rather than throwing inside a render path.
+ */
+function modalMarkerSink(tui: TUI): ModalMarkerSink | null {
+	const terminal: Partial<ModalMarkerSink> | undefined = tui.terminal;
+	return typeof terminal?.setTitle === "function" ? (terminal as ModalMarkerSink) : null;
 }
 
 /** Rows from an overlay size value, matching how the engine reads one. */

package/src/interactive/overlay-general-openers.ts

@@ -12,6 +12,7 @@ import {
 	proposeMemoryPromotion,
 } from "../domains/memory/index.js";
 import type { ObservabilityContract } from "../domains/observability/index.js";
+import { foregroundStreamUsage } from "../domains/providers/index.js";
 import type { ContextLedger } from "../domains/session/context-ledger.js";
 import type { SessionMeta } from "../domains/session/index.js";
 import { foldSessionArtifacts } from "../domains/session/session-artifacts.js";
@@ -147,6 +148,11 @@ export function createOverlayGeneralOpeners(deps: OverlayGeneralOpenersDeps): Ov
 		deps.transitions.state = "cost";
 		deps.transitions.handle = openCostOverlayFactory(deps.tui, deps.observability, {
 			sessionId: deps.getSessionId?.() ?? null,
+			...(deps.readSessionEntries
+				? {
+						getSessionEntries: () => deps.readSessionEntries?.() ?? [],
+					}
+				: {}),
 		});
 		deps.requestRender();
 	};
@@ -328,6 +334,7 @@ export function createOverlayGeneralOpeners(deps: OverlayGeneralOpenersDeps): Ov
 		deps.transitions.state = "dispatch-board";
 		deps.dispatchBoard.resetSelection();
 		deps.transitions.handle = showOverlayFrameFactory(deps.tui, deps.dispatchBoard, {
+			markerId: "dispatch-board",
 			title: "Fleet Runs",
 			footerHint: dispatchBoardHint,
 			anchor: "center",
@@ -429,10 +436,20 @@ export function createOverlayGeneralOpeners(deps: OverlayGeneralOpenersDeps): Ov
 				};
 				const resolution = deps.dispatch.preview?.(request);
 				if (!resolution) return null;
+				const foregroundHeld =
+					resolution.endpoint === undefined ? 0 : (foregroundStreamUsage()[resolution.endpoint.key] ?? 0);
 				return {
 					targetId: resolution.targetId,
 					wireModelId: resolution.wireModelId,
 					nodeId: resolution.node.id,
+					...(resolution.endpoint !== undefined
+						? {
+								endpoint: {
+									...resolution.endpoint,
+									...(foregroundHeld > 0 ? { foregroundHeld } : {}),
+								},
+							}
+						: {}),
 				};
 			},
 		});

package/src/interactive/overlay-key-routing.ts

@@ -1,5 +1,6 @@
 import type { ClioKeybinding } from "../domains/config/keybindings.js";
 import { isKeyRelease, matchesKey } from "../engine/tui.js";
+import { MUTATION_PREVIEW_KEY } from "./permission-hint.js";
 
 export type OverlayState =
 	| "closed"
@@ -14,6 +15,7 @@ export type OverlayState =
 	| "memory"
 	| "view"
 	| "model"
+	| "model-scope"
 	| "settings"
 	| "resume"
 	| "tree"
@@ -47,6 +49,11 @@ export interface PermissionOverlayKeyDeps {
 	 * the call. Only the deletion keys in `isDraftEditKey` arrive here.
 	 */
 	editDraft?: (data: string) => void;
+	/** Whether this card has a mutation the operator can read locally (issue #254). */
+	canInspectMutation?: () => boolean;
+	isInspectingMutation?: () => boolean;
+	toggleMutationInspection?: () => void;
+	scrollMutationInspection?: (delta: number) => void;
 }
 
 export interface DispatchBoardOverlayKeyDeps {
@@ -57,6 +64,12 @@ export interface DispatchBoardOverlayKeyDeps {
 	cancelSelectedDispatch: () => void;
 	/** Open or close the selected run's worker-progress detail. */
 	toggleSelectedDispatchDetail: () => void;
+	/**
+	 * Open or retarget the watch pane for the selected run. True when the pane
+	 * layer took the key; false hands Enter back to the inline detail toggle,
+	 * which is the whole behavior when panes are off or the run is terminal.
+	 */
+	watchSelectedDispatch: () => boolean;
 }
 
 interface CloseOverlayKeyDeps {
@@ -85,6 +98,18 @@ function isDraftEditKey(data: string): boolean {
 	return !isKeyRelease(data) && DRAFT_EDIT_KEYS.some((key) => matchesKey(data, key));
 }
 
+/** Rows one page key moves the open mutation. Matches the window the card renders. */
+const MUTATION_PAGE_ROWS = 16;
+
+/** How far a key scrolls the open mutation, or 0 when the key is not a scroll key. */
+function mutationScrollDelta(data: string): number {
+	if (matchesKey(data, "up")) return -1;
+	if (matchesKey(data, "down")) return 1;
+	if (matchesKey(data, "pageUp")) return -MUTATION_PAGE_ROWS;
+	if (matchesKey(data, "pageDown")) return MUTATION_PAGE_ROWS;
+	return 0;
+}
+
 /** Pure permission overlay key router: returns true when the input was consumed. */
 export function routePermissionOverlayKey(data: string, deps: PermissionOverlayKeyDeps): boolean {
 	if (matchesKey(data, "enter") && !isKeyRelease(data)) {
@@ -98,6 +123,26 @@ export function routePermissionOverlayKey(data: string, deps: PermissionOverlayK
 		deps.editDraft(data);
 		return true;
 	}
+	// Reading the mutation is the one thing this dialog does that is not an
+	// answer, so it toggles rather than navigating away: Enter, `s`, and Esc keep
+	// their meanings the whole time the mutation is on screen, and `v` is what
+	// puts it away. A card with nothing local to inspect leaves the key inert.
+	if (
+		matchesKey(data, MUTATION_PREVIEW_KEY) &&
+		!isKeyRelease(data) &&
+		(deps.canInspectMutation?.() ?? false) &&
+		deps.toggleMutationInspection
+	) {
+		deps.toggleMutationInspection();
+		return true;
+	}
+	if ((deps.isInspectingMutation?.() ?? false) && deps.scrollMutationInspection && !isKeyRelease(data)) {
+		const delta = mutationScrollDelta(data);
+		if (delta !== 0) {
+			deps.scrollMutationInspection(delta);
+			return true;
+		}
+	}
 	if (isEscapeKey(data)) {
 		deps.cancelPermission();
 		return true;
@@ -135,10 +180,11 @@ export function routeDispatchBoardOverlayKey(data: string, deps: DispatchBoardOv
 		deps.cancelSelectedDispatch();
 		return true;
 	}
-	// Worker progress is expanded detail the operator asks for. The default list
-	// stays compact so a fan-out of scouts costs one card each.
+	// Enter on a live run enters it: the watch pane opens (or retargets) and
+	// renders the run's stream beside the board. Where panes are off, absent,
+	// or the run is terminal, Enter keeps its inline worker-progress detail.
 	if (matchesKey(data, "enter")) {
-		deps.toggleSelectedDispatchDetail();
+		if (!deps.watchSelectedDispatch()) deps.toggleSelectedDispatchDetail();
 		return true;
 	}
 	return false;
@@ -242,6 +288,9 @@ export function routeOverlayKey(
 	if (overlayState === "memory") return false;
 	if (overlayState === "view") return false;
 	if (overlayState === "model") return routeModelOverlayKey(data, deps);
+	// The scope dialog owns Esc itself: cancelling it must leave the model where
+	// it was, and a router-level close cannot say that to the caller waiting on it.
+	if (overlayState === "model-scope") return false;
 	// Settings owns Esc itself: its stack is sections → rows → detail, and a
 	// router-level close made every Esc leave the overlay from wherever the
 	// operator was, so a cancelled picker and a finished visit looked the same.

package/src/interactive/overlay-lifecycle.ts

@@ -12,6 +12,7 @@ import { createOverlayTransitions } from "./overlay-transitions.js";
 import {
 	createPermissionOverlayBody,
 	PERMISSION_OVERLAY_WIDTH,
+	type PermissionOverlayBodyHandle,
 	permissionOverlayHint,
 	permissionOverlayPlacement,
 	permissionOverlayTitle,
@@ -21,6 +22,7 @@ import {
 export * from "./overlay-key-routing.js";
 
 import type { OverlayState } from "./overlay-key-routing.js";
+import type { PendingModelScope } from "./overlays/model-scope.js";
 import type { SettingsCenterRowId, SettingsSectionId } from "./overlays/settings.js";
 
 // Runtime lifecycle construction lives beside the pure modal key router so the
@@ -47,6 +49,7 @@ export type OverlayLifecycleApplicationDeps = Pick<
 	| "onNewSession"
 	| "onResumeSession"
 	| "onSelectModel"
+	| "onSetThinkingLevel"
 	| "providers"
 	| "readSessionEntries"
 	| "registerAskUserHandler"
@@ -107,6 +110,7 @@ export interface OverlayLifecycleRuntimeDeps {
 	openAuthDialog?: typeof import("./overlays/auth-dialog.js").openAuthDialog;
 	openAskUserOverlay?: typeof import("./overlays/ask-user.js").openAskUserOverlay;
 	openModelOverlay?: typeof import("./overlays/model-selector.js").openModelOverlay;
+	openModelScopeOverlay?: typeof import("./overlays/model-scope.js").openModelScopeOverlay;
 	openSettingsOverlay?: typeof import("./overlays/settings.js").openSettingsOverlay;
 	openSessionOverlay?: typeof import("./overlays/session-selector.js").openSessionOverlay;
 	openTreeOverlay?: typeof import("./overlays/tree-selector.js").openTreeOverlay;
@@ -150,6 +154,8 @@ export interface OverlayLifecycleController {
 	startHandoffState(goal: string): void;
 	startFleetRunState(name: string, vars: Readonly<Record<string, string>>): void;
 	openModelOverlayState(): void;
+	/** `/model <pattern>` and the picker both land here: choose session or global before anything applies. */
+	openModelScopeState(ref: PendingModelScope): void;
 	openSettingsOverlayState(section?: SettingsSectionId, rowId?: SettingsCenterRowId): void;
 	openResumeOverlayState(): void;
 	openTreeOverlayState(): void;
@@ -163,6 +169,12 @@ export interface OverlayLifecycleController {
 	toggleDispatchBoardOverlay(): void;
 	confirmPermission(): void;
 	stopTurnFromPermission(): void;
+	/** Whether the live permission card has a mutation the operator can read here. */
+	canInspectMutation(): boolean;
+	/** Whether that mutation is currently open. */
+	isInspectingMutation(): boolean;
+	toggleMutationInspection(): void;
+	scrollMutationInspection(delta: number): void;
 	cancelAskUser(): void;
 	dispose(): void;
 }
@@ -189,6 +201,7 @@ export function createOverlayLifecycle(deps: OverlayLifecycleRuntimeDeps): Overl
 		openAuthDialog: openAuthDialogFactory,
 		openAskUserOverlay: openAskUserOverlayFactory,
 		openModelOverlay: openModelOverlayFactory,
+		openModelScopeOverlay: openModelScopeOverlayFactory,
 		openSettingsOverlay: openSettingsOverlayFactory,
 		openSessionOverlay: openSessionOverlayFactory,
 		openTreeOverlay: openTreeOverlayFactory,
@@ -210,6 +223,16 @@ export function createOverlayLifecycle(deps: OverlayLifecycleRuntimeDeps): Overl
 	} = deps;
 	let overlayPermission: OverlayPermissionLifecycle | null = null;
 	let overlayAskUser: OverlayAskUserLifecycle | null = null;
+	/**
+	 * The live permission card's body, held only while its dialog is on screen.
+	 * The mutation text it can show lives here and nowhere else, so dropping the
+	 * reference when the dialog closes drops the text with it.
+	 */
+	let permissionBody: PermissionOverlayBodyHandle | null = null;
+	const inspectionHint = (): import("./permission-hint.js").PermissionInspectionHint => {
+		if (permissionBody === null || !permissionBody.canInspect()) return "none";
+		return permissionBody.isInspecting() ? "open" : "closed";
+	};
 	const overlayTransitions = createOverlayTransitions({
 		stopDispatchBoardTicker: () => interactiveTickers.stopDispatchBoardTicker(),
 		renderContextIsland: () => interactiveTickers.renderContextIsland(),
@@ -217,7 +240,10 @@ export function createOverlayLifecycle(deps: OverlayLifecycleRuntimeDeps): Overl
 		requestRender: () => tui.requestRender(),
 		cancelPendingAskUser: () => overlayAskUser?.cancelPending() ?? false,
 		finishAuth: (dismiss) => overlayAuth.finish(dismiss),
-		onPermissionOverlayClosed: () => overlayPermission?.onPermissionOverlayClosed(),
+		onPermissionOverlayClosed: () => {
+			permissionBody = null;
+			overlayPermission?.onPermissionOverlayClosed();
+		},
 		onOverlayClosed: () => overlayPermission?.retryPending(),
 	});
 	const closeOverlay = overlayTransitions.close;
@@ -248,18 +274,28 @@ export function createOverlayLifecycle(deps: OverlayLifecycleRuntimeDeps): Overl
 		dispatch: deps.app.dispatch,
 		getAutonomy: () => deps.app.getSettings?.().autonomy ?? "auto-edit",
 		getOverlayState: () => overlayTransitions.state,
-		openPermissionOverlay: (view) => {
-			if (overlayTransitions.state !== "closed") return false;
-			overlayTransitions.state = "permission-confirm";
-			overlayTransitions.handle = showOverlayFrame(tui, createPermissionOverlayBody(view), {
+		openPermissionOverlay: (view, inspect) => {
+			if (overlayTransitions.state === "permission-confirm") return false;
+			const body = createPermissionOverlayBody(view, inspect);
+			permissionBody = body;
+			const handle = showOverlayFrame(tui, body, {
 				...permissionOverlayPlacement(tui, editor, footer.view),
 				width: PERMISSION_OVERLAY_WIDTH,
+				// Not derived from the title: that one is classified per decision
+				// axis and is one of five strings for the same modal.
+				markerId: "permission-confirm",
 				title: permissionOverlayTitle(view),
 				tone: permissionOverlayTone(view),
 				// Read per frame: the footer names what Enter does right now, and
-				// that depends on whether the composer holds a draft.
-				footerHint: (innerWidth) => permissionOverlayHint(innerWidth, editor.getText().length > 0),
+				// that depends on whether the composer holds a draft and on whether
+				// the mutation is open.
+				footerHint: (innerWidth) => permissionOverlayHint(innerWidth, editor.getText().length > 0, inspectionHint()),
 			});
+			if (!overlayTransitions.showPermission(handle)) {
+				handle.hide();
+				permissionBody = null;
+				return false;
+			}
 			tui.requestRender();
 			return true;
 		},
@@ -308,10 +344,12 @@ export function createOverlayLifecycle(deps: OverlayLifecycleRuntimeDeps): Overl
 		...(deps.app.writeSettings ? { writeSettings: deps.app.writeSettings } : {}),
 		...(deps.app.commitSetting ? { commitSetting: deps.app.commitSetting } : {}),
 		...(deps.app.onSelectModel ? { onSelectModel: deps.app.onSelectModel } : {}),
+		...(deps.app.onSetThinkingLevel ? { onSetThinkingLevel: deps.app.onSetThinkingLevel } : {}),
 		...(deps.app.getFleetNodes ? { getFleetNodes: deps.app.getFleetNodes } : {}),
 		connectTarget: (targetId) => overlayAuth.openConnectFlow(targetId),
 		...(deps.app.interop ? { getInteropProposals: interopProposalsFor(deps.app.interop) } : {}),
 		...(openModelOverlayFactory ? { openModelOverlay: openModelOverlayFactory } : {}),
+		...(openModelScopeOverlayFactory ? { openModelScopeOverlay: openModelScopeOverlayFactory } : {}),
 		...(openSettingsOverlayFactory ? { openSettingsOverlay: openSettingsOverlayFactory } : {}),
 	});
 
@@ -443,6 +481,7 @@ export function createOverlayLifecycle(deps: OverlayLifecycleRuntimeDeps): Overl
 		startFleetRunState,
 		startHandoffState,
 		openModelOverlayState: overlayModelSelectors.openModelOverlayState,
+		openModelScopeState: overlayModelSelectors.openModelScopeState,
 		openSettingsOverlayState: overlayModelSelectors.openSettingsOverlayState,
 		openResumeOverlayState,
 		openTreeOverlayState,
@@ -464,6 +503,16 @@ export function createOverlayLifecycle(deps: OverlayLifecycleRuntimeDeps): Overl
 			footer.refresh();
 			tui.requestRender();
 		},
+		canInspectMutation: () => permissionBody?.canInspect() ?? false,
+		isInspectingMutation: () => permissionBody?.isInspecting() ?? false,
+		toggleMutationInspection: () => {
+			permissionBody?.toggleInspect();
+			tui.requestRender();
+		},
+		scrollMutationInspection: (delta) => {
+			permissionBody?.scrollInspect(delta);
+			tui.requestRender();
+		},
 		cancelAskUser: overlayAskUser.cancel,
 		dispose: () => {
 			overlayPermission?.dispose();

package/src/interactive/overlay-model-selectors.ts

@@ -1,4 +1,5 @@
 import type { ClioSettings } from "../core/config.js";
+import type { ThinkingLevel } from "../core/defaults.js";
 import type { SafeEventBus } from "../core/event-bus.js";
 import type { InteropProposal } from "../domains/interop/index.js";
 import type { ProvidersContract } from "../domains/providers/index.js";
@@ -7,6 +8,12 @@ import type { TUI } from "../engine/tui.js";
 import type { FooterDashboardPanel } from "./footer/dashboard.js";
 import type { InteractiveNoticeLevel } from "./interactive-subscriptions.js";
 import type { OverlayTransitions } from "./overlay-transitions.js";
+import {
+	formatPendingModelScope,
+	type ModelScopeChoice,
+	openModelScopeOverlay,
+	type PendingModelScope,
+} from "./overlays/model-scope.js";
 import { openModelOverlay } from "./overlays/model-selector.js";
 import { openSettingsOverlay, type SettingsCenterRowId, type SettingsSectionId } from "./overlays/settings.js";
 
@@ -21,7 +28,9 @@ export interface OverlayModelSelectorsDeps {
 	getSettings?: () => Readonly<ClioSettings>;
 	writeSettings?: (next: ClioSettings) => void;
 	commitSetting?: (id: string, next: ClioSettings, scope: "session" | "global") => void;
-	onSelectModel?: (ref: { target: string; model: string }) => void;
+	onSelectModel?: (ref: { target: string; model: string }, scope: ModelScopeChoice) => void;
+	/** Applied with the chosen scope when the swap named a thinking level. */
+	onSetThinkingLevel?: (level: ThinkingLevel, scope?: ModelScopeChoice) => void;
 	/** Settings → Fleet shows live node placement health when the scheduler exposes it. */
 	getFleetNodes?: () => ReadonlyArray<FleetNodeSnapshot>;
 	/** Settings → Targets "connect" runs the auth flow over the open settings overlay. */
@@ -29,17 +38,21 @@ export interface OverlayModelSelectorsDeps {
 	/** Settings → Advanced offers detected agents on the delegation.agents row. */
 	getInteropProposals?: () => ReadonlyArray<InteropProposal>;
 	openModelOverlay?: typeof openModelOverlay;
+	openModelScopeOverlay?: typeof openModelScopeOverlay;
 	openSettingsOverlay?: typeof openSettingsOverlay;
 }
 
 export interface OverlayModelSelectors {
 	openModelOverlayState(): void;
+	/** Ask where a resolved swap lands, then apply it. Nothing changes until the operator answers. */
+	openModelScopeState(ref: PendingModelScope): void;
 	openSettingsOverlayState(section?: SettingsSectionId, rowId?: SettingsCenterRowId): void;
 	refreshSettingsOverlay(): void;
 }
 
 export function createOverlayModelSelectors(deps: OverlayModelSelectorsDeps): OverlayModelSelectors {
 	const openModel = deps.openModelOverlay ?? openModelOverlay;
+	const openModelScope = deps.openModelScopeOverlay ?? openModelScopeOverlay;
 	const openSettings = deps.openSettingsOverlay ?? openSettingsOverlay;
 	let settingsOverlayRefresh: (() => void) | null = null;
 
@@ -53,9 +66,11 @@ export function createOverlayModelSelectors(deps: OverlayModelSelectorsDeps): Ov
 			...(deps.getSettings ? { getSettings: deps.getSettings } : {}),
 			providers: deps.providers,
 			bus: deps.bus,
+			// The picker resolves what to run; the scope dialog resolves where it
+			// lands. Closing this overlay first keeps one modal on screen at a time.
 			onSelect: (ref) => {
-				deps.onSelectModel?.(ref);
-				deps.refreshFooter();
+				deps.closeOverlay();
+				openModelScopeState(ref);
 			},
 			onToggleFavorite: (ref, favorite) => {
 				if (!deps.getSettings || !deps.writeSettings) return;
@@ -76,6 +91,27 @@ export function createOverlayModelSelectors(deps: OverlayModelSelectorsDeps): Ov
 		deps.tui.requestRender();
 	};
 
+	const openModelScopeState = (ref: PendingModelScope): void => {
+		if (deps.transitions.state !== "closed") return;
+		deps.transitions.state = "model-scope";
+		deps.transitions.handle = openModelScope(deps.tui, {
+			ref,
+			onChoose: (scope) => {
+				deps.closeOverlay();
+				deps.onSelectModel?.({ target: ref.target, model: ref.model }, scope);
+				if (ref.thinkingLevel) deps.onSetThinkingLevel?.(ref.thinkingLevel, scope);
+				const swap = formatPendingModelScope(ref);
+				deps.notify("success", scope === "global" ? `active and saved globally: ${swap}` : `active this session: ${swap}`);
+				deps.refreshFooter();
+			},
+			onCancel: () => {
+				deps.closeOverlay();
+				deps.notify("info", "model unchanged");
+			},
+		});
+		deps.tui.requestRender();
+	};
+
 	const openSettingsOverlayState = (section?: SettingsSectionId, rowId?: SettingsCenterRowId): void => {
 		if (deps.transitions.state !== "closed" || !deps.getSettings || !deps.writeSettings) return;
 		deps.transitions.state = "settings";
@@ -121,6 +157,7 @@ export function createOverlayModelSelectors(deps: OverlayModelSelectorsDeps): Ov
 
 	return {
 		openModelOverlayState,
+		openModelScopeState,
 		openSettingsOverlayState,
 		refreshSettingsOverlay: () => settingsOverlayRefresh?.(),
 	};