@iowarp/clio-coder 0.3.0 → 0.3.2

package/src/interactive/interactive-event-projection.ts

@@ -0,0 +1,385 @@
+import {
+	BusChannels,
+	type ConfigReloadFailedPayload,
+	type ContextPrunedPayload,
+	type ContextWarningPayload,
+	type LoopBlockedPayload,
+	type RuntimeNoticePayload,
+	type ToolBudgetExceededPayload,
+} from "../core/bus-events.js";
+import type { ClioSettings } from "../core/config.js";
+import type { SafeEventBus } from "../core/event-bus.js";
+import { routingChangeNotices } from "../core/session-routing.js";
+import { visibleWidth } from "../engine/tui.js";
+import {
+	budgetAlertNotice,
+	middlewareHookFailedSessionNotice,
+	restartRequiredNotice,
+	safetyBlockedNotice,
+} from "./bus-notices.js";
+import type { ChatCancelOptions, ChatLoopEvent, QueuedChatMessage } from "./chat-loop.js";
+import { classifyNoticeLevel } from "./footer/notifications.js";
+import {
+	loopBlockedAuditReason,
+	loopBlockedStopReason,
+	toolBudgetAuditReason,
+	toolBudgetStopReason,
+} from "./loop-guard-interrupt.js";
+import {
+	type AgentStatus,
+	INLINE_STATUS_INDENT_COLS,
+	resolveInlineVerb,
+	type StatusPhase,
+	spinnerFrame,
+	type TurnSummary,
+	type VerbRender,
+} from "./status/index.js";
+
+export type InteractiveProjectionNoticeLevel = "info" | "success" | "warning" | "error";
+export type InteractiveTranscriptNoticeLevel = "info" | "success" | "warn" | "error";
+
+export interface InteractiveStatusLine {
+	phase: StatusPhase;
+	verb: string;
+	toneHint: VerbRender["toneHint"];
+}
+
+export interface InteractiveEventProjectionDeps {
+	bus: SafeEventBus;
+	chat: {
+		onEvent(handler: (event: ChatLoopEvent) => void): () => void;
+		cancel(options?: ChatCancelOptions): void;
+	};
+	status: {
+		subscribe(listener: (status: AgentStatus) => void): () => void;
+	};
+	initialNotices?: ReadonlyArray<string>;
+	getSettings?: () => Readonly<ClioSettings>;
+	getTerminalColumns: () => number;
+	now?: () => number;
+	/** Canonical synchronous ingress hook, before any projection branch consumes the event. */
+	onChatEventIngress?: (event: ChatLoopEvent) => void;
+	applyChatEvent: (event: ChatLoopEvent) => void;
+	setFollowUpMessages: (messages: QueuedChatMessage[]) => void;
+	isAskUserWaiting: () => boolean;
+	closeAskUserSession: () => void;
+	resetAskUserCancellation: () => void;
+	recordToolStart: (toolName: string, toolCallId: string) => void;
+	recordToolEnd: (toolName: string, toolCallId: string, isError: boolean, truncated: boolean) => void;
+	setStatusLine: (line: InteractiveStatusLine | null) => void;
+	setLastTurnSummary: (summary: TurnSummary) => void;
+	startTerminalProgress: () => void;
+	stopTerminalProgress: () => void;
+	refreshLiveWorkspaceGit: (force: boolean) => void;
+	refreshFooter: () => void;
+	requestRender: () => void;
+	notify: (level: InteractiveProjectionNoticeLevel, text: string, key?: string) => void;
+	dismissNotification: (key: string) => void;
+	appendTranscriptNotice: (level: InteractiveTranscriptNoticeLevel, text: string) => void;
+	refreshSettingsOverlay: () => void;
+	onConfigHotReload?: (settings: Readonly<ClioSettings>) => void;
+}
+
+export interface InteractiveEventProjection {
+	/** Unsubscribe the primary chat and status projections before disposing the status controller. */
+	disposePrimary(): void;
+	/** Unsubscribe progress and bus projections after disposing the status controller. */
+	disposeRemaining(): void;
+	dispose(): void;
+}
+
+function recordObject(value: unknown): Record<string, unknown> | null {
+	return typeof value === "object" && value !== null && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: null;
+}
+
+function askUserInterviewClosedByToolResult(event: {
+	toolName?: unknown;
+	isError?: unknown;
+	result?: unknown;
+}): boolean {
+	if (event.toolName !== "ask_user" || event.isError === true) return false;
+	const result = recordObject(event.result);
+	const details = recordObject(result?.details);
+	const interview = recordObject(details?.interview);
+	return interview?.status === "complete" || interview?.status === "cancelled";
+}
+
+/**
+ * Project chat, status, and operator-facing bus events onto interactive UI
+ * collaborators. Event delivery is synchronous, so handler statement order is
+ * the rendering contract and intentionally matches the former composition-root
+ * subscriptions.
+ */
+export function createInteractiveEventProjection(deps: InteractiveEventProjectionDeps): InteractiveEventProjection {
+	const now = deps.now ?? Date.now;
+
+	for (const notice of deps.initialNotices ?? []) {
+		const text = notice.trim();
+		if (text.length === 0) continue;
+		const key = text.toLowerCase().includes("keybinding notice") ? "startup:keybinding-notice" : text;
+		deps.notify(classifyNoticeLevel(text), text, key);
+	}
+
+	const primaryUnsubscribers: Array<() => void> = [];
+	const remainingUnsubscribers: Array<() => void> = [];
+	primaryUnsubscribers.push(
+		deps.chat.onEvent((event) => {
+			deps.onChatEventIngress?.(event);
+			if (event.type === "notice") {
+				if (event.surface === "transcript") {
+					deps.applyChatEvent(event);
+					return;
+				}
+				deps.notify(event.level, event.text, event.key);
+				return;
+			}
+			if (event.type === "queue_update") {
+				deps.setFollowUpMessages(event.messages);
+				deps.requestRender();
+				return;
+			}
+			if (deps.isAskUserWaiting() && event.type === "message_update") {
+				const assistantEvent = event.assistantMessageEvent as { type?: unknown };
+				if (assistantEvent.type === "text_delta" || assistantEvent.type === "thinking_delta") {
+					deps.closeAskUserSession();
+				}
+			}
+			if (event.type === "agent_end") {
+				deps.closeAskUserSession();
+				deps.resetAskUserCancellation();
+			}
+			if (event.type === "tool_execution_start") {
+				if (event.toolName.toLowerCase() === "dispatch") {
+					deps.applyChatEvent(event);
+					return;
+				}
+				deps.recordToolStart(event.toolName, event.toolCallId);
+				deps.refreshFooter();
+			} else if (event.type === "tool_execution_end") {
+				if (event.toolName.toLowerCase() === "dispatch") {
+					deps.applyChatEvent(event);
+					return;
+				}
+				if (askUserInterviewClosedByToolResult(event)) {
+					deps.closeAskUserSession();
+					deps.resetAskUserCancellation();
+				}
+				const summary = (event as { resultSummary?: { truncated?: unknown } }).resultSummary;
+				deps.recordToolEnd(event.toolName, event.toolCallId, event.isError, summary?.truncated === true);
+				deps.refreshFooter();
+			}
+			deps.applyChatEvent(event);
+		}),
+	);
+
+	let statusInlineFrame = 0;
+	primaryUnsubscribers.push(
+		deps.status.subscribe((status) => {
+			if (status.phase === "idle") {
+				deps.setStatusLine(null);
+			} else if (status.phase === "ended") {
+				deps.setStatusLine(null);
+				if (status.summary) deps.setLastTurnSummary(status.summary);
+			} else {
+				const cols = deps.getTerminalColumns();
+				const frame = cols < 30 ? "" : `${spinnerFrame(statusInlineFrame)} `;
+				const verb = resolveInlineVerb(status, now(), cols, INLINE_STATUS_INDENT_COLS + visibleWidth(frame));
+				if (verb) {
+					deps.setStatusLine({ phase: status.phase, verb: `${frame}${verb.text}`, toneHint: verb.toneHint });
+					statusInlineFrame = (statusInlineFrame + 1) % 10;
+				} else {
+					deps.setStatusLine(null);
+				}
+			}
+			deps.refreshFooter();
+			deps.requestRender();
+		}),
+	);
+
+	remainingUnsubscribers.push(
+		deps.chat.onEvent((event) => {
+			const showProgress = deps.getSettings?.().terminal.showTerminalProgress ?? false;
+			if (event.type === "agent_start" && showProgress) deps.startTerminalProgress();
+			else if (event.type === "agent_end") deps.stopTerminalProgress();
+		}),
+		deps.bus.on(BusChannels.RunAborted, () => {
+			deps.stopTerminalProgress();
+		}),
+		deps.chat.onEvent((event) => {
+			if (event.type !== "message_end" && event.type !== "agent_end") return;
+			if (event.type === "agent_end") deps.refreshLiveWorkspaceGit(true);
+			deps.refreshFooter();
+			deps.requestRender();
+		}),
+		deps.bus.on(BusChannels.ContextWarning, (payload) => {
+			const event = payload as ContextWarningPayload | null | undefined;
+			if (event && typeof event === "object" && "warning" in event) {
+				if (event.warning !== null) deps.notify("warning", event.warning, "context-low-warning");
+				else deps.dismissNotification("context-low-warning");
+			}
+			deps.refreshFooter();
+			deps.requestRender();
+		}),
+		deps.bus.on(BusChannels.ContextPruned, (payload) => {
+			const event = payload as ContextPrunedPayload | null | undefined;
+			if (
+				event &&
+				typeof event === "object" &&
+				typeof event.tokensBefore === "number" &&
+				typeof event.tokensAfter === "number"
+			) {
+				deps.notify(
+					"info",
+					`[Compaction] Reclaimed context: ${event.tokensBefore} -> ${event.tokensAfter} tokens (${event.stage})`,
+					"compaction-notice",
+				);
+			}
+			deps.refreshFooter();
+			deps.requestRender();
+		}),
+		deps.bus.on(BusChannels.RuntimeNotice, (payload) => {
+			const event = payload as RuntimeNoticePayload | null | undefined;
+			if (!event || typeof event !== "object" || typeof event.message !== "string" || typeof event.kind !== "string") {
+				return;
+			}
+			deps.notify(event.level, event.message, `runtime-notice:${event.kind}:${event.targetId}`);
+			deps.refreshFooter();
+			deps.requestRender();
+		}),
+	);
+
+	remainingUnsubscribers.push(
+		deps.bus.on(BusChannels.LoopBlocked, (payload) => {
+			const event = payload as LoopBlockedPayload | null | undefined;
+			if (!event || typeof event !== "object" || typeof event.tool !== "string" || typeof event.repeatCount !== "number") {
+				return;
+			}
+			if (event.disposition === "stop") {
+				deps.chat.cancel({
+					reason: loopBlockedStopReason(event),
+					source: "loop_guard",
+					auditReason: loopBlockedAuditReason(event),
+				});
+			} else if (event.disposition === "lockout") {
+				deps.appendTranscriptNotice(
+					"warn",
+					`[loop-guard] ${event.tool} looped ${event.repeatCount}x; tools disabled for the rest of this turn — the model is answering from what it gathered.`,
+				);
+			} else {
+				deps.appendTranscriptNotice(
+					"warn",
+					`[loop-guard] blocked ${event.tool}: identical call repeated ${event.repeatCount}x in window (block ${event.blocksThisTurn}/${event.budget} this turn).`,
+				);
+			}
+			deps.requestRender();
+		}),
+		deps.bus.on(BusChannels.ToolBudgetExceeded, (payload) => {
+			const event = payload as ToolBudgetExceededPayload | null | undefined;
+			if (
+				!event ||
+				typeof event !== "object" ||
+				typeof event.tool !== "string" ||
+				typeof event.callsThisTurn !== "number"
+			) {
+				return;
+			}
+			if (event.interrupted) {
+				deps.chat.cancel({
+					reason: toolBudgetStopReason(event),
+					source: "loop_guard",
+					auditReason: toolBudgetAuditReason(event),
+				});
+			} else {
+				deps.appendTranscriptNotice(
+					"warn",
+					`[loop-guard] tool-call budget reached: ${event.callsThisTurn} calls this turn (soft budget ${event.softBudget}); ${event.tool} blocked, model asked to re-plan.`,
+				);
+			}
+			deps.requestRender();
+		}),
+		deps.bus.on(BusChannels.ConfigNextTurn, (payload) => {
+			const event = payload as { diff?: { nextTurn?: string[] }; settings?: Readonly<ClioSettings> } | null | undefined;
+			const effective = deps.getSettings?.();
+			if (!effective || !event?.settings || !Array.isArray(event.diff?.nextTurn)) return;
+			for (const notice of routingChangeNotices(event.diff.nextTurn, event.settings, effective, { commandHints: true })) {
+				deps.notify(
+					notice.level,
+					notice.text,
+					notice.kind === "external-divergence" ? "config:routing-divergence" : "config:target-removed",
+				);
+			}
+			deps.refreshSettingsOverlay();
+			deps.refreshFooter();
+			deps.requestRender();
+		}),
+		deps.bus.on(BusChannels.ConfigHotReload, (payload) => {
+			deps.onConfigHotReload?.(payload.settings);
+			deps.refreshSettingsOverlay();
+		}),
+		deps.bus.on(BusChannels.ConfigReloadFailed, (payload) => {
+			const event = payload as ConfigReloadFailedPayload | null | undefined;
+			if (!event || typeof event !== "object" || !("message" in event)) return;
+			// The domain already folded this to one line with a remedy; the frame
+			// only ever sees a notice, never an error object or a stack.
+			if (typeof event.message === "string" && event.message.length > 0) {
+				deps.notify("error", `[config] settings reload rejected: ${event.message}`, "config:reload-failed");
+			} else if (event.message === null) {
+				deps.dismissNotification("config:reload-failed");
+			}
+			deps.refreshFooter();
+			deps.requestRender();
+		}),
+		deps.bus.on(BusChannels.ConfigRestartRequired, (payload) => {
+			const text = restartRequiredNotice(payload);
+			if (text === null) return;
+			deps.notify("warning", text, "config:restart-required");
+			deps.refreshFooter();
+			deps.requestRender();
+		}),
+		deps.bus.on(BusChannels.BudgetAlert, (payload) => {
+			const notice = budgetAlertNotice(payload);
+			if (notice === null) return;
+			deps.appendTranscriptNotice(notice.level, notice.text);
+			deps.requestRender();
+		}),
+		deps.bus.on(BusChannels.SafetyBlocked, (payload) => {
+			const notice = safetyBlockedNotice(payload);
+			if (notice === null) return;
+			deps.appendTranscriptNotice(notice.level, notice.text);
+			deps.requestRender();
+		}),
+	);
+
+	const seenMiddlewareBudgetWarnings = new Set<string>();
+	remainingUnsubscribers.push(
+		deps.bus.on(BusChannels.MiddlewareHookFailed, (payload) => {
+			const notice = middlewareHookFailedSessionNotice(payload, seenMiddlewareBudgetWarnings);
+			if (notice === null) return;
+			deps.appendTranscriptNotice(notice.level, notice.text);
+			deps.requestRender();
+		}),
+	);
+
+	let primaryDisposed = false;
+	let remainingDisposed = false;
+	const disposePrimary = (): void => {
+		if (primaryDisposed) return;
+		primaryDisposed = true;
+		for (const unsubscribe of primaryUnsubscribers) unsubscribe();
+	};
+	const disposeRemaining = (): void => {
+		if (remainingDisposed) return;
+		remainingDisposed = true;
+		for (const unsubscribe of remainingUnsubscribers) unsubscribe();
+	};
+	return {
+		disposePrimary,
+		disposeRemaining,
+		dispose(): void {
+			disposePrimary();
+			disposeRemaining();
+		},
+	};
+}

package/src/interactive/interactive-input-runtime.ts

@@ -0,0 +1,307 @@
+import { getTerminationCoordinator } from "../core/termination.js";
+import type { ClioKeybinding } from "../domains/config/keybindings.js";
+import { isKeyRelease, type Keybinding } from "../engine/tui.js";
+import {
+	type ApplicationClock,
+	type ApplicationController,
+	type ApplicationInputResult,
+	type ApplicationIntervalCoordinator,
+	type ApplicationIntervalHandle,
+	type ApplicationSignalCoordinator,
+	createApplicationController,
+} from "./application-controller.js";
+import { createLeaderKeyController, type LeaderTarget } from "./leader-key.js";
+import { type OverlayState, routeOverlayKey } from "./overlay-lifecycle.js";
+import type { RenderInputAction } from "./render-trace.js";
+
+export interface InteractiveInputKeyActionDeps {
+	matches: (data: string, id: ClioKeybinding) => boolean;
+	canExit: () => boolean;
+	cycleThinking: () => void;
+	requestShutdown: () => void;
+	toggleStatus: () => void;
+	toggleDispatchBoard: () => void;
+	openTasks: () => void;
+	openDecisions: () => void;
+	backgroundDispatch: () => void;
+	openModelSelector: () => void;
+	openTree: () => void;
+	cycleScopedModelForward: () => void;
+	cycleScopedModelBackward: () => void;
+	dismissNotifications: () => void;
+	toggleToolExpansion: () => void;
+	toggleAllToolExpansion: () => void;
+	toggleLiveToolOutput: () => void;
+	toggleThinkingExpansion: () => void;
+	toggleAllThinkingExpansion: () => void;
+	openExternalEditor: () => void;
+	queueFollowUp: () => void;
+	interruptWithMessage: () => void;
+	restoreQueuedFollowUps: () => void;
+}
+
+export interface InteractiveInputRuntimeDeps {
+	keybindings: {
+		matches(data: string, id: Keybinding): boolean;
+		leaderTargets(): ReadonlyArray<LeaderTarget>;
+	};
+	dispatchAction: (id: ClioKeybinding, deps: InteractiveInputKeyActionDeps) => boolean;
+	actions: {
+		canExit(): boolean;
+		availableThinkingLevels(): ReadonlyArray<string>;
+		onCycleThinking(): void;
+		cycleScopedModelForward(): void;
+		cycleScopedModelBackward(): void;
+		/** Convert the newest attached dispatch into a detached batch and notice the outcome. */
+		backgroundActiveDispatch(): void;
+	};
+	overlay: {
+		getState(): OverlayState;
+		closeOverlay(): void;
+		confirmPermission(): void;
+		stopTurnFromPermission(): void;
+		cancelAskUser(): void;
+		toggleFooterDashboardState(): void;
+		toggleDispatchBoardOverlay(): void;
+		openModelOverlayState(): void;
+		openTreeOverlayState(): void;
+		openTasksOverlayState(): void;
+		openDecisionsOverlayState(): void;
+	};
+	refreshFooter: () => void;
+	/** Armed/disarmed transitions of the Ctrl+G leader, for the footer indicator. */
+	onLeaderStateChange?: (pending: boolean) => void;
+	/** Armed/disarmed transitions of the Ctrl+C double tap, for the same indicator row. */
+	onShutdownArmedChange?: (armed: boolean) => void;
+	dispatchBoard: {
+		selectPrevious(): void;
+		selectNext(): void;
+	};
+	steerSelectedDispatch: () => void;
+	cancelSelectedDispatch: () => void;
+	cancelActiveEditorBash: () => boolean;
+	isStreaming: () => boolean;
+	cancelActiveRun: () => void;
+	editor: { getText(): string; setText(text: string): void };
+	editorSubmit: {
+		openExternalEditorForInput(): void;
+		queueFollowUpFromEditor(): void;
+		interruptFromEditor(): void;
+		restoreQueuedFollowUpsToEditor(): void;
+	};
+	requestRender: () => void;
+	notifications: {
+		list(): ReadonlyArray<{ id: string }>;
+		dismiss(id: string): void;
+		dismissAll(): void;
+	};
+	chatPanel: {
+		toggleLastToolExpanded(): boolean;
+		toggleAllToolsExpanded(): boolean;
+		toggleLiveToolOutput(): void;
+		toggleLastThinking(): boolean;
+		toggleAllThinking(): boolean;
+	};
+	shutdown: {
+		stopTickers(): void;
+		disposeInteractiveTickers(): void;
+		disposeBeforeStatus(): void;
+		disposeProjectionPrimary(): void;
+		disposeStatus(): void;
+		disposeProjectionRemaining(): void;
+		disposeOverlay(): void;
+		stopAgentProgress(): void;
+		disposeChat(): void;
+		disposeSubscriptions(): void;
+	};
+	stopUi: () => void;
+	beforeStopUi?: () => Promise<void>;
+	cancelParkedCalls: (reason: string) => void;
+	onShutdown: () => Promise<void>;
+	reportShutdownFailure?: (step: string, error: unknown) => void;
+	/** Defaults to the process termination coordinator's drain phase. */
+	registerTerminalTeardown?: (teardown: () => void | Promise<void>) => void;
+	registerInputListener: (listener: (data: string) => ApplicationInputResult) => void;
+	onInputIngress?: (action: RenderInputAction, data: string) => void;
+	intervalsToClear?: ReadonlyArray<ApplicationIntervalHandle>;
+	clock?: ApplicationClock;
+	signals?: ApplicationSignalCoordinator;
+	intervals?: ApplicationIntervalCoordinator;
+}
+
+/** Compose the main-editor input boundary without booting a terminal or provider. */
+export function createInteractiveInputRuntime(deps: InteractiveInputRuntimeDeps): ApplicationController {
+	let controller: ApplicationController;
+	const keyActionDeps = (): InteractiveInputKeyActionDeps => ({
+		matches: (input, id) => deps.keybindings.matches(input, id),
+		canExit: deps.actions.canExit,
+		cycleThinking: () => {
+			const available = deps.actions.availableThinkingLevels();
+			if (!(available.length === 1 && available[0] === "off")) deps.actions.onCycleThinking();
+			deps.refreshFooter();
+			deps.requestRender();
+		},
+		requestShutdown: () => void controller.shutdown(),
+		toggleStatus: deps.overlay.toggleFooterDashboardState,
+		toggleDispatchBoard: deps.overlay.toggleDispatchBoardOverlay,
+		openTasks: deps.overlay.openTasksOverlayState,
+		openDecisions: deps.overlay.openDecisionsOverlayState,
+		backgroundDispatch: deps.actions.backgroundActiveDispatch,
+		openModelSelector: deps.overlay.openModelOverlayState,
+		openTree: deps.overlay.openTreeOverlayState,
+		cycleScopedModelForward: () => {
+			deps.actions.cycleScopedModelForward();
+			deps.refreshFooter();
+			deps.requestRender();
+		},
+		cycleScopedModelBackward: () => {
+			deps.actions.cycleScopedModelBackward();
+			deps.refreshFooter();
+			deps.requestRender();
+		},
+		dismissNotifications: () => controller.dismissNotifications(),
+		toggleToolExpansion: () => controller.toggleToolExpansion(),
+		toggleAllToolExpansion: () => {
+			if (deps.chatPanel.toggleAllToolsExpanded()) deps.requestRender();
+		},
+		toggleLiveToolOutput: () => {
+			deps.chatPanel.toggleLiveToolOutput();
+			deps.requestRender();
+		},
+		toggleThinkingExpansion: () => controller.toggleThinkingExpansion(),
+		toggleAllThinkingExpansion: () => {
+			if (deps.chatPanel.toggleAllThinking()) deps.requestRender();
+		},
+		openExternalEditor: deps.editorSubmit.openExternalEditorForInput,
+		queueFollowUp: deps.editorSubmit.queueFollowUpFromEditor,
+		interruptWithMessage: deps.editorSubmit.interruptFromEditor,
+		restoreQueuedFollowUps: deps.editorSubmit.restoreQueuedFollowUpsToEditor,
+	});
+	const leaderKeys = createLeaderKeyController({
+		matchesLeader: (input) => deps.keybindings.matches(input, "clio.leader"),
+		leaderTargets: () => deps.keybindings.leaderTargets(),
+		dispatchAction: (id) => deps.dispatchAction(id, keyActionDeps()),
+		isRelease: isKeyRelease,
+		onStateChange: (pending) => {
+			deps.onLeaderStateChange?.(pending);
+			deps.refreshFooter();
+			deps.requestRender();
+		},
+	});
+
+	controller = createApplicationController({
+		clock: deps.clock ?? { now: Date.now },
+		signals: deps.signals ?? {
+			takeInterruptOwnership: () => getTerminationCoordinator().releaseInterruptOwnership(),
+			on: (signal, listener) => void process.on(signal, listener),
+			off: (signal, listener) => void process.off(signal, listener),
+		},
+		intervals: deps.intervals ?? {
+			setInterval: (callback, delayMs) => setInterval(callback, delayMs),
+			clearInterval: (handle) => clearInterval(handle as NodeJS.Timeout),
+		},
+		intervalsToClear: deps.intervalsToClear ?? [],
+		leaderKeys,
+		getOverlayState: () => deps.overlay.getState(),
+		routeOverlayKey: (data) =>
+			routeOverlayKey(
+				data,
+				deps.overlay.getState(),
+				{
+					cancelPermission: () => deps.overlay.closeOverlay(),
+					confirmPermission: () => deps.overlay.confirmPermission(),
+					stopTurnFromPermission: () => deps.overlay.stopTurnFromPermission(),
+					closeOverlay: () => deps.overlay.closeOverlay(),
+					selectPreviousDispatch: () => {
+						deps.dispatchBoard.selectPrevious();
+						deps.requestRender();
+					},
+					selectNextDispatch: () => {
+						deps.dispatchBoard.selectNext();
+						deps.requestRender();
+					},
+					steerSelectedDispatch: deps.steerSelectedDispatch,
+					cancelSelectedDispatch: deps.cancelSelectedDispatch,
+					cancelAskUser: () => deps.overlay.cancelAskUser(),
+				},
+				(input, id) => deps.keybindings.matches(input, id),
+			),
+		matchesEditorHistory: (data) =>
+			deps.keybindings.matches(data, "tui.editor.historyPrevious") ||
+			deps.keybindings.matches(data, "tui.editor.historyNext"),
+		matchesAction: (data, id) => deps.keybindings.matches(data, id),
+		dispatchAction: (id) => deps.dispatchAction(id, keyActionDeps()),
+		cancelActiveEditorBash: deps.cancelActiveEditorBash,
+		isStreaming: deps.isStreaming,
+		cancelActiveRun: deps.cancelActiveRun,
+		getEditorText: () => deps.editor.getText(),
+		clearEditor: () => deps.editor.setText(""),
+		requestRender: deps.requestRender,
+		// The footer pulls the flag when it refreshes, so the refresh has to land
+		// before the controller asks for the frame. The controller owns the render
+		// request on this path, which is why this hook does not make one.
+		onShutdownArmedChange: (armed) => {
+			deps.onShutdownArmedChange?.(armed);
+			deps.refreshFooter();
+		},
+		closeOverlay: () => deps.overlay.closeOverlay(),
+		listNotifications: () => deps.notifications.list(),
+		dismissNotification: (id) => deps.notifications.dismiss(id),
+		dismissAllNotifications: () => deps.notifications.dismissAll(),
+		toggleLastToolExpanded: () => deps.chatPanel.toggleLastToolExpanded(),
+		toggleAllToolsExpanded: () => deps.chatPanel.toggleAllToolsExpanded(),
+		toggleLastThinking: () => deps.chatPanel.toggleLastThinking(),
+		toggleAllThinking: () => deps.chatPanel.toggleAllThinking(),
+		shutdownDisposers: [
+			() => deps.shutdown.stopTickers(),
+			() => leaderKeys.dispose(),
+			() => deps.shutdown.disposeInteractiveTickers(),
+			() => deps.shutdown.disposeBeforeStatus(),
+			() => deps.shutdown.disposeProjectionPrimary(),
+			() => deps.shutdown.disposeStatus(),
+			() => deps.shutdown.disposeProjectionRemaining(),
+			() => deps.shutdown.disposeOverlay(),
+			() => deps.shutdown.stopAgentProgress(),
+			() => deps.shutdown.disposeChat(),
+			() => deps.shutdown.disposeSubscriptions(),
+		],
+		stopUi: deps.stopUi,
+		...(deps.beforeStopUi ? { beforeStopUi: deps.beforeStopUi } : {}),
+		cancelParkedCalls: deps.cancelParkedCalls,
+		onShutdown: deps.onShutdown,
+		registerTerminalTeardown:
+			deps.registerTerminalTeardown ?? ((teardown) => getTerminationCoordinator().onDrain(teardown)),
+		// stderr for the same reason src/core/termination.ts uses it for a failed
+		// hook: by the time teardown fails there is no UI left to carry a notice.
+		reportShutdownFailure:
+			deps.reportShutdownFailure ??
+			((step, error) => {
+				process.stderr.write(
+					`[clio:interactive] ${step} failed: ${error instanceof Error ? error.message : String(error)}\n`,
+				);
+			}),
+	});
+	deps.registerInputListener((data) => {
+		deps.onInputIngress?.(classifyInputAction(data, deps), data);
+		return controller.handleInput(data);
+	});
+	return controller;
+}
+
+function classifyInputAction(data: string, deps: InteractiveInputRuntimeDeps): RenderInputAction {
+	if (data.length === 0 || isKeyRelease(data)) return "no-visual-change";
+	if (deps.keybindings.matches(data, "tui.input.submit")) return "submit";
+	const sgrMousePrefix = `${String.fromCharCode(27)}[<`;
+	if (
+		data.startsWith(`${sgrMousePrefix}64;`) ||
+		data.startsWith(`${sgrMousePrefix}65;`) ||
+		deps.keybindings.matches(data, "tui.altScreen.pageUp") ||
+		deps.keybindings.matches(data, "tui.altScreen.pageDown") ||
+		deps.keybindings.matches(data, "tui.editor.pageUp") ||
+		deps.keybindings.matches(data, "tui.editor.pageDown")
+	) {
+		return "scroll";
+	}
+	if (deps.overlay.getState() !== "closed") return "overlay";
+	return "editor";
+}