@iowarp/clio-coder 0.3.9 → 0.4.1

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,19 +66,21 @@ 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;
 				const next = structuredClone(deps.getSettings()) as ClioSettings;
 				const value = `${ref.target}/${ref.model}`;
-				const current = new Set(next.modelSelector?.favorites ?? []);
+				const current = new Set(next.chat.modelPicker?.favorites ?? []);
 				if (favorite) current.add(value);
 				else current.delete(value);
-				next.modelSelector = {
-					...(next.modelSelector ?? { recentLimit: 12, favorites: [] }),
+				next.chat.modelPicker = {
+					...(next.chat.modelPicker ?? { recentLimit: 12, favorites: [] }),
 					favorites: [...current],
 				};
 				deps.writeSettings(next);
@@ -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?.(),
 	};

package/src/interactive/overlay-permission-lifecycle.ts

@@ -36,6 +36,7 @@ interface WorkerEscalationEntry {
 	axis: ApprovalRequestView["axis"];
 	reason: string;
 	target?: string;
+	fallback: "deny" | "fail";
 }
 
 export interface OverlayPermissionLifecycleDeps {
@@ -190,6 +191,7 @@ function workerEscalationEntry(payload: PermissionRequestedPayload, autonomy: st
 		...(typeof payload.target === "string" && payload.target.length > 0
 			? { target: sanitizeCallTargetText(payload.target).slice(0, 200) }
 			: {}),
+		fallback: payload.fallback === "fail" ? "fail" : "deny",
 	};
 }
 
@@ -207,42 +209,87 @@ function workerApprovalRequestView(entry: WorkerEscalationEntry): ApprovalReques
 
 export function createOverlayPermissionLifecycle(deps: OverlayPermissionLifecycleDeps): OverlayPermissionLifecycle {
 	let pendingPermission: { call: ClassifierCall; decision: SafetyDecision; meta?: PermissionRequiredMeta } | null = null;
-	let pendingWorker: Pick<WorkerEscalationEntry, "agentId" | "requestId" | "runId"> | null = null;
+	let pendingWorker: WorkerEscalationEntry | null = null;
 	const workerQueue: WorkerEscalationEntry[] = [];
 	const announcedRequestIds = new Set<string>();
 	/** Worker escalations already surfaced, so one request parks the operator once. */
 	const announcedWorkerRequestIds = new Set<string>();
+	/** Expiry notices already printed, including a decision that lost the terminal-state race. */
+	const expiredWorkerRequestIds = new Set<string>();
 	let confirmed = false;
 	let stopping = false;
+	let withdrawingWorker = false;
 
-	const openWorker = (entry: WorkerEscalationEntry): void => {
-		if (deps.getOverlayState() !== "closed") return;
-		if (!deps.openPermissionOverlay(workerApprovalRequestView(entry))) return;
-		pendingWorker = { runId: entry.runId, requestId: entry.requestId, agentId: entry.agentId };
+	const openWorker = (entry: WorkerEscalationEntry): boolean => {
+		if (!deps.openPermissionOverlay(workerApprovalRequestView(entry))) return false;
+		pendingWorker = entry;
 		pendingPermission = null;
 		confirmed = false;
+		return true;
 	};
 	const maybeOpenWorker = (): void => {
-		if (deps.getOverlayState() !== "closed") return;
-		const next = workerQueue.shift();
-		if (next) openWorker(next);
+		const next = workerQueue[0];
+		if (next && openWorker(next)) workerQueue.shift();
 	};
 	const retryPending = (): void => {
 		maybeOpenWorker();
-		if (deps.getOverlayState() === "closed" && deps.toolRegistry?.hasParkedCalls()) {
+		if (deps.getOverlayState() !== "permission-confirm" && deps.toolRegistry?.hasParkedCalls()) {
 			deps.toolRegistry.renotifyHead();
 		}
 	};
+	const announceWorkerExpiry = (
+		entry: WorkerEscalationEntry,
+		fallback: "deny" | "fail",
+		cause: "timeout" | "terminal" | "late-answer",
+	): void => {
+		if (!markPermissionRequestSurfaced(expiredWorkerRequestIds, entry.requestId)) return;
+		const why =
+			cause === "timeout"
+				? "expired after its escalation timeout"
+				: cause === "terminal"
+					? "expired when its run ended"
+					: "expired before the operator decision arrived";
+		deps.appendNotice(
+			"warn",
+			`Worker approval request ${entry.requestId} for ${entry.agentId} (${entry.runId}) ${why}; fallback ${fallback} applied.`,
+		);
+	};
+	const removeQueuedWorkers = (matches: (entry: WorkerEscalationEntry) => boolean): WorkerEscalationEntry[] => {
+		const removed: WorkerEscalationEntry[] = [];
+		for (let index = workerQueue.length - 1; index >= 0; index -= 1) {
+			const entry = workerQueue[index];
+			if (entry === undefined || !matches(entry)) continue;
+			removed.unshift(entry);
+			workerQueue.splice(index, 1);
+		}
+		return removed;
+	};
+	const withdrawWorkers = (
+		matches: (entry: WorkerEscalationEntry) => boolean,
+		cause: "timeout" | "terminal",
+		fallback?: "deny" | "fail",
+	): void => {
+		const active = pendingWorker !== null && matches(pendingWorker) ? pendingWorker : null;
+		const expired = [...(active === null ? [] : [active]), ...removeQueuedWorkers(matches)];
+		if (expired.length === 0) return;
+		if (active !== null) {
+			pendingWorker = null;
+			confirmed = false;
+			withdrawingWorker = true;
+			deps.closeOverlay();
+		}
+		for (const entry of expired) announceWorkerExpiry(entry, fallback ?? entry.fallback, cause);
+		deps.requestRender();
+	};
 
 	const unsubscribePermission =
 		deps.toolRegistry?.onPermissionRequired((call, decision, meta) => {
 			const autonomy = deps.getAutonomy();
 			const view = mainApprovalRequestView(call, decision, meta, autonomy, deps.toolRegistry?.parkedCount());
-			// The dialog states the tool, the target, the action class, the axis
-			// that asked, and the keys that answer it. While it is on screen the
-			// notice repeats all of that one line above the transcript, so it is
-			// emitted only when no dialog could open (another overlay holds the
-			// screen), which is the case where it is the operator's only signal.
+			// The dialog states the tool, target, action class, asking axis, and
+			// decision keys. Another modal is interrupted so this prompt can take
+			// focus. The notice remains for a second queued approval or a frame that
+			// could not mount, when it is the operator's only additional signal.
 			const announceParked = (): void => {
 				if (!markPermissionRequestSurfaced(announcedRequestIds, meta.requestId)) return;
 				const notice = approvalParkedNotice(call.tool, decision, autonomy);
@@ -256,10 +303,6 @@ export function createOverlayPermissionLifecycle(deps: OverlayPermissionLifecycl
 					view,
 				});
 			}
-			if (deps.getOverlayState() !== "closed") {
-				announceParked();
-				return;
-			}
 			if (!deps.openPermissionOverlay(view, mainMutationInspector(call, view))) {
 				announceParked();
 				return;
@@ -280,6 +323,18 @@ export function createOverlayPermissionLifecycle(deps: OverlayPermissionLifecycl
 		workerQueue.push(entry);
 		maybeOpenWorker();
 	});
+	const unsubscribeWorkerResolution = deps.bus.on(BusChannels.PermissionResolved, (payload) => {
+		if (typeof payload.requestId !== "string") return;
+		if (payload.decidedBy !== "timeout" && payload.status !== "expired") return;
+		const fallback = payload.fallback === "fail" ? "fail" : "deny";
+		withdrawWorkers((entry) => entry.requestId === payload.requestId, "timeout", fallback);
+	});
+	const withdrawTerminalRun = (payload: { runId?: unknown }): void => {
+		if (typeof payload.runId !== "string") return;
+		withdrawWorkers((entry) => entry.runId === payload.runId, "terminal");
+	};
+	const unsubscribeWorkerCompleted = deps.bus.on(BusChannels.DispatchCompleted, withdrawTerminalRun);
+	const unsubscribeWorkerFailed = deps.bus.on(BusChannels.DispatchFailed, withdrawTerminalRun);
 
 	const unsubscribeAutonomy =
 		deps.toolRegistry?.onAutonomyDenied((_call, decision, level) => {
@@ -289,6 +344,12 @@ export function createOverlayPermissionLifecycle(deps: OverlayPermissionLifecycl
 		}) ?? (() => {});
 
 	const onPermissionOverlayClosed = (): void => {
+		if (withdrawingWorker) {
+			withdrawingWorker = false;
+			confirmed = false;
+			retryPending();
+			return;
+		}
 		const permission = pendingPermission;
 		const worker = pendingWorker;
 		pendingPermission = null;
@@ -299,10 +360,14 @@ export function createOverlayPermissionLifecycle(deps: OverlayPermissionLifecycl
 			try {
 				deps.dispatch.resolveWorkerPermission?.(worker.runId, worker.requestId, wasConfirmed ? "approve" : "deny");
 			} catch (error) {
-				deps.appendNotice(
-					"warn",
-					`Could not deliver permission decision to run ${worker.runId}: ${error instanceof Error ? error.message : String(error)}`,
-				);
+				const message = error instanceof Error ? error.message : String(error);
+				if (
+					/run or assignment '.+' is not active|run '.+' is (?:aborting|terminating)|no longer accepts input/u.test(message)
+				) {
+					announceWorkerExpiry(worker, worker.fallback, "late-answer");
+				} else {
+					deps.appendNotice("warn", `Could not deliver permission decision to run ${worker.runId}: ${message}`);
+				}
 			}
 		} else if (wasConfirmed && permission) {
 			deps.bus.emit(BusChannels.PermissionResolved, {
@@ -384,6 +449,9 @@ export function createOverlayPermissionLifecycle(deps: OverlayPermissionLifecycl
 		dispose: () => {
 			unsubscribePermission();
 			unsubscribeWorker();
+			unsubscribeWorkerResolution();
+			unsubscribeWorkerCompleted();
+			unsubscribeWorkerFailed();
 			unsubscribeAutonomy();
 		},
 	};

package/src/interactive/overlay-transitions.ts

@@ -20,12 +20,15 @@ export interface OverlayTransitionsDeps {
 export interface OverlayTransitions {
 	state: OverlayState;
 	handle: OverlayHandle | null;
+	/** Raise a permission prompt while preserving the modal it interrupted. */
+	showPermission(handle: OverlayHandle): boolean;
 	close(): void;
 }
 
 export function createOverlayTransitions(deps: OverlayTransitionsDeps): OverlayTransitions {
 	let state: OverlayState = "closed";
 	let handle: OverlayHandle | null = null;
+	let interrupted: { state: OverlayState; handle: OverlayHandle | null } | null = null;
 
 	return {
 		get state() {
@@ -44,6 +47,13 @@ export function createOverlayTransitions(deps: OverlayTransitionsDeps): OverlayT
 		set handle(next) {
 			handle = next;
 		},
+		showPermission(nextHandle) {
+			if (state === "permission-confirm") return false;
+			interrupted = state === "closed" ? null : { state, handle };
+			state = "permission-confirm";
+			handle = nextHandle;
+			return true;
+		},
 		close,
 	};
 
@@ -55,12 +65,16 @@ export function createOverlayTransitions(deps: OverlayTransitionsDeps): OverlayT
 			return;
 		}
 		const leaving = state;
-		state = "closed";
-		deps.stopDispatchBoardTicker();
-		handle?.hide();
-		handle = null;
+		const leavingHandle = handle;
+		const restoring = leaving === "permission-confirm" ? interrupted : null;
+		interrupted = null;
+		state = restoring?.state ?? "closed";
+		handle = restoring?.handle ?? null;
+		if (restoring === null) deps.stopDispatchBoardTicker();
+		leavingHandle?.hide();
 		if (leaving === "permission-confirm") deps.onPermissionOverlayClosed();
 		else deps.onOverlayClosed?.();
+		restoring?.handle?.focus();
 		deps.renderContextIsland();
 		deps.renderTaskIsland();
 		deps.requestRender();

package/src/interactive/overlays/agents.ts

@@ -34,7 +34,7 @@ export function openAgentsOverlay(tui: TUI, ctx: SlashCommandContext, onClose: (
 	const delegationItems: ListOverlayItem[] = delegationAgents.map((agent) => {
 		const fullCmd = [agent.command, ...agent.args].join(" ");
 		const label = `${agent.id.padEnd(18)}${fullCmd}`;
-		const meta = `governance=${agent.toolGovernance ?? "clio-policy"}`;
+		const meta = `governance=${agent.toolGovernance ?? "clio-coder-policy"}`;
 		return {
 			id: agent.id,
 			label,
@@ -44,7 +44,7 @@ export function openAgentsOverlay(tui: TUI, ctx: SlashCommandContext, onClose: (
 				const lines = [
 					`# ACP Delegation Agent: ${agent.id}`,
 					`**Command:** \`${fullCmd}\``,
-					`**Governance:** ${agent.toolGovernance ?? "clio-policy"}`,
+					`**Governance:** ${agent.toolGovernance ?? "clio-coder-policy"}`,
 				];
 				if (agent.labels && Object.keys(agent.labels).length > 0) {
 					lines.push(`**Labels:**`);
@@ -60,6 +60,7 @@ export function openAgentsOverlay(tui: TUI, ctx: SlashCommandContext, onClose: (
 	const items = [...fleetItems, ...delegationItems];
 
 	return openListOverlay(tui, {
+		markerId: "agents",
 		title: "Agents Reference",
 		items,
 		filterable: true,