@iowarp/clio-coder 0.3.9 → 0.4.1

package/src/interactive/interactive-application.ts

@@ -12,6 +12,8 @@ import type { ExtensionsContract } from "../domains/extensions/index.js";
 import type { InteropContract } from "../domains/interop/index.js";
 import type { TaskMemoryOperatorStatus } from "../domains/memory/index.js";
 import { openDetachedBatchViews } from "../domains/middleware/index.js";
+import type { MuxContract } from "../domains/mux/index.js";
+import type { PanesOperations, PanesWatchController } from "../domains/mux/operations.js";
 import type { ObservabilityContract } from "../domains/observability/index.js";
 import type { ProvidersContract, ThinkingLevel } from "../domains/providers/index.js";
 import type { ResourcesContract } from "../domains/resources/index.js";
@@ -40,8 +42,10 @@ import { createProcessInteractiveShell, getActiveRenderTrace } from "./interacti
 import { createInteractiveSlashRuntime, resolveAvailableThinkingLevels } from "./interactive-slash-runtime.js";
 import { createInteractiveSubscriptions } from "./interactive-subscriptions.js";
 import { createInteractiveTickers } from "./interactive-tickers.js";
+import type { createMuxBridge } from "./mux-bridge.js";
 import { createOverlayLifecycle, type OverlayLifecycleController, type OverlayState } from "./overlay-lifecycle.js";
 import { interopOverlaySurface } from "./overlays/interop.js";
+import { paneWatchDecision } from "./pane-policy.js";
 import { writeInputWedgeDump } from "./render-trace.js";
 import { settleChatBeforeSessionSwitch } from "./session-switch-settlement.js";
 import { createSessionTranscript } from "./session-transcript.js";
@@ -49,11 +53,14 @@ import type {
 	ContextClearCommandOptions,
 	InitCommandOptions,
 	RunIo,
+	SettingsAreaId,
 	TaskMemorySeedCommandResult,
 } from "./slash-commands.js";
 import { processAutoPacingAllowed, resolveSmoothStreamingMode } from "./stream-pacing-policy.js";
 import type { TerminalLease } from "./terminal-lease.js";
+import type { createWatchPaneController } from "./watch-pane.js";
 import { createWorkspaceFacts } from "./workspace-facts.js";
+import type { createYaziBridge, YaziBridge } from "./yazi-bridge.js";
 
 export {
 	IDLE_LEADER_STATE,
@@ -85,20 +92,6 @@ export {
 	type SlashCommandKind,
 } from "./slash-commands.js";
 
-export function shouldAnnouncePermissionRequest(
-	seenRequestIds: Set<string>,
-	requestId: string,
-	maxSize = 2048,
-): boolean {
-	if (seenRequestIds.has(requestId)) return false;
-	seenRequestIds.add(requestId);
-	if (seenRequestIds.size > maxSize) {
-		const oldest = seenRequestIds.values().next().value;
-		if (oldest !== undefined) seenRequestIds.delete(oldest);
-	}
-	return true;
-}
-
 export function isLiveWorkerEscalationRequest(payload: PermissionRequestedPayload): boolean {
 	if (typeof payload.requestId !== "string") return false;
 	if (payload.escalation !== true) return false;
@@ -130,6 +123,36 @@ export interface InteractiveDeps {
 	extensions?: ExtensionsContract;
 	interop?: InteropContract;
 	share?: ShareContract;
+	/**
+	 * Pane layer. A `none` contract still reaches the interactive surface so the
+	 * files preset can use its terminal chooser; every mux operation remains
+	 * best-effort and never reaches a dispatch or a turn.
+	 */
+	mux?: MuxContract;
+	/**
+	 * Pane-layer operations behind `/panes` and the `panes` tool. Built by the
+	 * composition root so the tool registry and this surface drive one instance.
+	 */
+	panes?: PanesOperations;
+	/**
+	 * Factory seam for the dispatch-to-pane bridge, so a contract test can drive
+	 * it without a TUI. Production leaves it unset and gets `createMuxBridge`.
+	 */
+	createMuxBridge?: typeof createMuxBridge;
+	/** Bind the file-pane return path after the composer and TUI exist. */
+	attachYaziBridge?: (bridge: YaziBridge) => () => void;
+	/**
+	 * Watch-pane factory from the `--with-panes` composition root; absent on a
+	 * plain boot. The controller it builds backs Enter in the workers view.
+	 */
+	createWatchPane?: typeof createWatchPaneController;
+	/** Bind the watch controller into the shared PanesOperations for `/panes show`. */
+	attachWatchPane?: (controller: PanesWatchController) => () => void;
+	/**
+	 * File-pane factory. Supplied by the `--with-panes` composition root (or a
+	 * contract test); absent on a plain boot, which therefore loads no yazi code.
+	 */
+	createYaziBridge?: typeof createYaziBridge;
 	/**
 	 * Shared tool registry. When wired, the permission overlay opens automatically
 	 * whenever a tool call is parked waiting for operator confirmation, and the
@@ -173,12 +196,19 @@ export interface InteractiveDeps {
 	registerAskUserHandler?: (handler: AskUserHandler) => () => void;
 	/** Live CLIO-CODER.md and memory state for the footer Context quadrant. */
 	getContextState?: (cwd?: string) => ContextState;
-	/** Persist a thinking level set by `/thinking <level>` or `/model <pattern>:<level>`. */
-	onSetThinkingLevel?: (level: ThinkingLevel) => void;
+	/**
+	 * Persist a thinking level set by `/thinking <level>` or `/model <pattern>:<level>`.
+	 * Scope "session" leaves settings.yaml alone; omitted means the historical
+	 * write-through, which is what the Shift+Tab cycle and `/thinking` still want.
+	 */
+	onSetThinkingLevel?: (level: ThinkingLevel, scope?: "session" | "global") => void;
 	/** Persist the next thinking level when Shift+Tab is pressed. */
 	onCycleThinking?: () => void;
-	/** Persist the orchestrator target selected in /model. */
-	onSelectModel?: (ref: { target: string; model: string }) => void;
+	/**
+	 * Apply the orchestrator target selected in /model at the scope the operator
+	 * chose. "session" routes this session only and never touches settings.yaml.
+	 */
+	onSelectModel?: (ref: { target: string; model: string }, scope: "session" | "global") => void;
 	/** Write handler the /settings overlay uses to persist cycled values. */
 	writeSettings?: (next: ClioSettings) => void;
 	/**
@@ -200,7 +230,7 @@ export interface InteractiveDeps {
 	onForkSession?: (parentTurnId: string) => void;
 	/**
 	 * Run `/context compact` for the current session. Resolves the compaction model
-	 * (settings.compaction.model with fallback to the orchestrator target),
+	 * (settings.context.compaction.model with fallback to the chat target),
 	 * reads session entries, streams a summary via the session compaction
 	 * engine, and persists a compactionSummary entry.
 	 */
@@ -239,7 +269,7 @@ export interface InteractiveSubmitExpansion {
 	pendingSkillRequests: PendingSkillRequest[];
 }
 
-export async function expandInteractiveSubmitAsync(
+async function expandInteractiveSubmitAsync(
 	text: string,
 	resources: ResourcesContract | undefined,
 	cwd = process.cwd(),
@@ -271,7 +301,7 @@ function availableInteractiveThinkingLevels(deps: InteractiveDeps): ReadonlyArra
 export interface KeyBindingDeps {
 	/**
 	 * Keybinding lookup injected by startInteractive. Defaults come from
-	 * CLIO_KEYBINDINGS; user overrides from settings.keybindings. Tests may
+	 * CLIO_KEYBINDINGS; user overrides from settings.interface.keybindings. Tests may
 	 * substitute a narrower matcher via createKeybindingManagerForTesting.
 	 */
 	matches: (data: string, id: ClioKeybinding) => boolean;
@@ -322,73 +352,73 @@ export function resolveCtrlCAction(deps: CtrlCActionDeps): CtrlCAction {
 	return "arm-shutdown";
 }
 
-export function dispatchInteractiveAction(id: ClioKeybinding, deps: KeyBindingDeps): boolean {
+function dispatchInteractiveAction(id: ClioKeybinding, deps: KeyBindingDeps): boolean {
 	switch (id) {
-		case "clio.notifications.dismiss":
+		case "clio-coder.notifications.dismiss":
 			deps.dismissNotifications();
 			return true;
-		case "clio.tool.expand":
+		case "clio-coder.tool.expand":
 			deps.toggleToolExpansion();
 			return true;
-		case "clio.tool.expandAll":
+		case "clio-coder.tool.expandAll":
 			deps.toggleAllToolExpansion();
 			return true;
-		case "clio.tool.liveOutput":
+		case "clio-coder.tool.liveOutput":
 			deps.toggleLiveToolOutput();
 			return true;
-		case "clio.editor.external":
+		case "clio-coder.editor.external":
 			deps.openExternalEditor();
 			return true;
-		case "clio.message.followUp":
+		case "clio-coder.message.followUp":
 			deps.queueFollowUp();
 			return true;
-		case "clio.message.interrupt":
+		case "clio-coder.message.interrupt":
 			deps.interruptWithMessage();
 			return true;
-		case "clio.message.dequeue":
+		case "clio-coder.message.dequeue":
 			deps.restoreQueuedFollowUps();
 			return true;
-		case "clio.thinking.expand":
+		case "clio-coder.thinking.expand":
 			deps.toggleThinkingExpansion();
 			return true;
-		case "clio.thinking.expandAll":
+		case "clio-coder.thinking.expandAll":
 			deps.toggleAllThinkingExpansion();
 			return true;
-		case "clio.status.toggle":
+		case "clio-coder.status.toggle":
 			deps.toggleStatus();
 			return true;
-		case "clio.thinking.cycle":
+		case "clio-coder.thinking.cycle":
 			deps.cycleThinking();
 			return true;
-		case "clio.session.tree":
+		case "clio-coder.session.tree":
 			deps.openTree();
 			return true;
-		case "clio.dispatchBoard.toggle":
+		case "clio-coder.dispatchBoard.toggle":
 			deps.toggleDispatchBoard();
 			return true;
-		case "clio.tasks.open":
+		case "clio-coder.tasks.open":
 			deps.openTasks();
 			return true;
-		case "clio.decisions.open":
+		case "clio-coder.decisions.open":
 			deps.openDecisions();
 			return true;
-		case "clio.dispatch.background":
+		case "clio-coder.dispatch.background":
 			deps.backgroundDispatch();
 			return true;
-		case "clio.model.select":
+		case "clio-coder.model.select":
 			deps.openModelSelector();
 			return true;
-		case "clio.model.cycleBackward":
+		case "clio-coder.model.cycleBackward":
 			deps.cycleScopedModelBackward();
 			return true;
-		case "clio.model.cycleForward":
+		case "clio-coder.model.cycleForward":
 			deps.cycleScopedModelForward();
 			return true;
-		case "clio.exit":
+		case "clio-coder.exit":
 			if (deps.canExit && !deps.canExit()) return false;
 			deps.requestShutdown();
 			return true;
-		case "clio.leader":
+		case "clio-coder.leader":
 			return false;
 	}
 }
@@ -396,20 +426,20 @@ export function dispatchInteractiveAction(id: ClioKeybinding, deps: KeyBindingDe
 /** Pure key router: returns true when the input was consumed. */
 export function routeInteractiveKey(data: string, deps: KeyBindingDeps): boolean {
 	const order: ClioKeybinding[] = [
-		"clio.status.toggle",
-		"clio.thinking.cycle",
-		"clio.session.tree",
-		"clio.dispatchBoard.toggle",
-		"clio.tasks.open",
-		"clio.decisions.open",
-		"clio.dispatch.background",
-		"clio.model.select",
+		"clio-coder.status.toggle",
+		"clio-coder.thinking.cycle",
+		"clio-coder.session.tree",
+		"clio-coder.dispatchBoard.toggle",
+		"clio-coder.tasks.open",
+		"clio-coder.decisions.open",
+		"clio-coder.dispatch.background",
+		"clio-coder.model.select",
 		// Match cycleBackward before cycleForward so a user rebind where one key
 		// is a prefix of the other resolves to the more specific binding first.
 		// The defaults (alt+k / alt+j) do not prefix-match each other.
-		"clio.model.cycleBackward",
-		"clio.model.cycleForward",
-		"clio.exit",
+		"clio-coder.model.cycleBackward",
+		"clio-coder.model.cycleForward",
+		"clio-coder.exit",
 	];
 	for (const id of order) {
 		if (deps.matches(data, id)) return dispatchInteractiveAction(id, deps);
@@ -418,13 +448,13 @@ export function routeInteractiveKey(data: string, deps: KeyBindingDeps): boolean
 }
 
 export async function createInteractiveApplication(deps: InteractiveDeps): Promise<number> {
-	const initialSmoothStreaming = resolveSmoothStreamingMode(deps.getSettings?.().terminal.smoothStreaming ?? "off");
+	const initialSmoothStreaming = resolveSmoothStreamingMode(deps.getSettings?.().interface.smoothStreaming ?? "off");
 	const initialAutoPacingAllowed = processAutoPacingAllowed(false);
 	const lease = deps.terminalLease;
 	const shell =
 		lease?.shell ??
 		createProcessInteractiveShell({
-			tuiMode: deps.getSettings?.().terminal.tuiMode ?? "regular",
+			tuiMode: deps.getSettings?.().interface.mode ?? "regular",
 			streamPacingActive:
 				initialSmoothStreaming === "on" || (initialSmoothStreaming === "auto" && initialAutoPacingAllowed),
 			...(deps.onFirstFrameCommit ? { onFirstFrameCommit: deps.onFirstFrameCommit } : {}),
@@ -567,6 +597,31 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		chatRenderer,
 		io,
 	} = presentation;
+	// The factory arrives only from an active `--with-panes` boot (or a test); a
+	// plain session has no deps.panes and no factory, and loads no yazi code.
+	const yaziBridge =
+		deps.panes && deps.createYaziBridge
+			? deps.createYaziBridge({
+					...(deps.mux ? { mux: deps.mux } : {}),
+					getDraft: () => editor.getText(),
+					setDraft: (text) => editor.setText(text),
+					requestRender: () => tui.requestRender(),
+					notice: (level, text) => notify(level, text, `yazi:${level}`),
+					getCwd: () => process.cwd(),
+					getSettings: () =>
+						deps.getSettings?.().interface.panes.files ?? {
+							mode: "companion",
+							profile: "managed",
+							followCwd: true,
+						},
+					stopUi: () => tui.stop(),
+					startUi: () => {
+						tui.start();
+						tui.requestRender(true);
+					},
+				})
+			: null;
+	const detachYaziBridge = yaziBridge ? deps.attachYaziBridge?.(yaziBridge) : undefined;
 	refreshPresentationFooter = () => footer.refresh();
 	const agentProgress = createAgentProgress(terminal);
 	// Desktop notifications are a protocol write on the terminal owner, issued
@@ -575,7 +630,7 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 	// `CLIO_CODER_INTERACTIVE=1` forced the interactive surface on.
 	const desktopNotifications = createInteractiveDesktopNotifications({
 		write: (data) => terminal.write(data),
-		enabled: () => deps.getSettings?.().terminal.notify ?? false,
+		enabled: () => deps.getSettings?.().interface.desktopNotifications ?? false,
 		interactiveTty: () => process.stdout.isTTY === true,
 		getOpenBatches: () => openDetachedBatchViews(deps.dispatch),
 	});
@@ -617,7 +672,7 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		appendTranscriptNotice: (level, text) => appendNotice(level, text, busNoticeSink),
 		refreshSettingsOverlay: () => overlayLifecycle.refreshSettingsOverlay(),
 		onConfigHotReload: (settings) => {
-			const mode = resolveSmoothStreamingMode(settings.terminal.smoothStreaming);
+			const mode = resolveSmoothStreamingMode(settings.interface.smoothStreaming);
 			const autoAllowed = processAutoPacingAllowed(shell.hasObservedBackpressure());
 			chatRenderer.setSmoothStreamingMode(mode);
 			shell.setStreamPacingActive(mode === "on" || (mode === "auto" && autoAllowed));
@@ -674,6 +729,7 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		openSideQuestion: (question) => openSideQuestionOverlayState(question),
 		startHandoff: (goal) => startHandoffState(goal),
 		startFleetRun: (name, vars) => startFleetRunState(name, vars),
+		openFleetRuns: () => toggleDispatchBoardOverlay(),
 		...(toolRegistry ? { runCouncilDispatch: (args) => dispatchCouncilThroughRegistry(toolRegistry, args) } : {}),
 		openContextView: () => openContextViewOverlayState(),
 		openTasks: () => openTasksOverlayState(),
@@ -681,8 +737,25 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		openMemory: () => openMemoryOverlayState(),
 		...(deps.seedTaskMemory ? { seedTaskMemory: deps.seedTaskMemory } : {}),
 		openView: (filter) => openViewOverlayState(filter),
+		...(deps.panes ? { panes: deps.panes } : {}),
 		openModel: () => openModelOverlayState(),
-		openSettings: (section, rowId) => openSettingsOverlayState(section, rowId),
+		openModelScope: (ref) => openModelScopeState(ref),
+		openSettings: (area, group) => {
+			if (!area) return openSettingsOverlayState();
+			// Compatibility adapter until the seven-area Settings shell replaces
+			// the legacy section ids. Slash grammar never exposes these old names.
+			if (area === "chat" && group === "model-picker") return openSettingsOverlayState("models", "scope");
+			const section = {
+				chat: "orchestrator",
+				fleet: "fleet",
+				targets: "targets",
+				context: "compaction",
+				safety: "safety",
+				interface: "terminal",
+				integrations: "advanced",
+			} satisfies Record<SettingsAreaId, Parameters<typeof openSettingsOverlayState>[0]>;
+			openSettingsOverlayState(section[area]);
+		},
 		openResume: () => openResumeOverlayState(),
 		startNewSession: () => startNewSession(),
 		openTree: () => openTreeOverlayState(),
@@ -789,6 +862,7 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		openMemoryOverlayState,
 		openViewOverlayState,
 		openModelOverlayState,
+		openModelScopeState,
 		openSettingsOverlayState,
 		openResumeOverlayState,
 		openTreeOverlayState,
@@ -799,6 +873,7 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		openPromptsOverlayState,
 		openExtensionsOverlayState,
 		openInteropOverlayState,
+		toggleDispatchBoardOverlay,
 	} = overlayLifecycle;
 
 	const dispatchSteering = createDispatchSteering({
@@ -866,6 +941,80 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		};
 		notify(outcome.ok ? "success" : "info", outcome.message, "dispatch:background");
 	};
+	// Built only when a pane host answered detection, so a session with no
+	// panes subscribes to nothing and the bus handlers do not exist at all.
+	// The factories arrive from the `--with-panes` composition root (or a
+	// test); a plain session loads none of the bridge code.
+	const mux = deps.mux;
+	const muxBridge =
+		mux && mux.mode !== "none" && deps.createMuxBridge
+			? deps.createMuxBridge({
+					bus: deps.bus,
+					mux,
+					notificationsPolicy: () => deps.getSettings?.().interface.panes.notifications ?? "failures",
+					log: (level, message) => {
+						if (level === "warning") notify("warning", message, "mux:bridge");
+					},
+					notice: (level, text) => appendNotice(level, text, busNoticeSink),
+				})
+			: null;
+	// The workers-view watch pane: opened on Enter over a live run, retargeted
+	// by arrow keys through its selection file. `/panes show` and the panes
+	// tool drive the same controller through the shared operations object.
+	const watchPane =
+		mux && mux.mode !== "none" && deps.createWatchPane
+			? deps.createWatchPane({
+					mux,
+					getCwd: () => process.cwd(),
+					getWorkersRatio: () => deps.getSettings?.().interface.panes.workers.ratio ?? 0.34,
+				})
+			: null;
+	const detachWatchPane = watchPane ? deps.attachWatchPane?.(watchPane) : undefined;
+	// Boot composition per `interface.panes.layout`: `workers` opens the workers
+	// dock parked on "no selection"; `cockpit` adds the files dock. Fire and
+	// forget, and only against a live pane host: a boot must never fall through
+	// to the in-terminal chooser or block the first paint on socket traffic.
+	{
+		const bootSettings = deps.getSettings?.();
+		const layout = bootSettings?.interface.panes.layout ?? "off";
+		if (layout !== "off" && mux?.available()) {
+			void watchPane?.ensureOpen();
+			if (layout === "cockpit" && bootSettings?.interface.panes.files.enabled) void yaziBridge?.open();
+		}
+	}
+	const selectedWatchableRun = (): { runId: string; agentId: string } | null => {
+		if (!watchPane) return null;
+		const row = dispatchBoard.selectedRow();
+		if (!row) return null;
+		const decision = paneWatchDecision({ source: "workers-view", runStatus: row.status });
+		return decision.open ? { runId: row.runId, agentId: row.agentId } : null;
+	};
+	/**
+	 * Enter in the workers view. True means the watch pane took the key; false
+	 * (panes off, nothing watchable under the policy) falls back to the inline
+	 * worker-progress detail, so a terminal run's Enter still expands its card.
+	 */
+	const watchSelectedDispatch = (): boolean => {
+		const selected = selectedWatchableRun();
+		if (!watchPane || !selected) return false;
+		void watchPane.watch(selected.runId).then((result) => {
+			if (result.status === "watching") {
+				if (result.opened) {
+					notify("success", `watching ${selected.agentId} (${selected.runId}) in a pane`, "panes:watch");
+				}
+			} else {
+				notify("warning", result.reason, "panes:watch");
+			}
+			tui.requestRender();
+		});
+		return true;
+	};
+	/** Arrow keys: the watch pane follows the cursor, but only once it exists. */
+	const followBoardSelection = (): void => {
+		if (!watchPane?.isOpen()) return;
+		const selected = selectedWatchableRun();
+		if (selected) watchPane.follow(selected.runId);
+	};
 	const interactiveSubscriptions = createInteractiveSubscriptions({
 		bus: deps.bus,
 		refreshFooter: () => footer.refresh(),
@@ -916,7 +1065,18 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		onShutdownArmedChange: (armed) => {
 			shutdownArmed = armed;
 		},
-		dispatchBoard,
+		dispatchBoard: {
+			selectPrevious: () => {
+				dispatchBoard.selectPrevious();
+				followBoardSelection();
+			},
+			selectNext: () => {
+				dispatchBoard.selectNext();
+				followBoardSelection();
+			},
+			toggleDetail: () => dispatchBoard.toggleDetail(),
+		},
+		watchSelectedDispatch,
 		steerSelectedDispatch,
 		cancelSelectedDispatch,
 		cancelActiveEditorBash: () => editorSubmit.cancelActiveEditorBash(),
@@ -955,7 +1115,14 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 			disposeOverlay: overlayLifecycle.dispose,
 			stopAgentProgress: agentProgress.stop,
 			disposeChat: () => deps.chat.dispose(),
-			disposeSubscriptions: interactiveSubscriptions.dispose,
+			disposeSubscriptions: () => {
+				detachYaziBridge?.();
+				yaziBridge?.dispose();
+				detachWatchPane?.();
+				watchPane?.dispose();
+				muxBridge?.dispose();
+				interactiveSubscriptions.dispose();
+			},
 		},
 		beforeStopUi: (() => {
 			let settlement: Promise<void> | null = null;

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

@@ -218,7 +218,7 @@ export function createInteractiveEventProjection(deps: InteractiveEventProjectio
 
 	remainingUnsubscribers.push(
 		deps.chat.onEvent((event) => {
-			const showProgress = deps.getSettings?.().terminal.showTerminalProgress ?? false;
+			const showProgress = deps.getSettings?.().interface.terminalProgress ?? false;
 			if (event.type === "agent_start" && showProgress) deps.startTerminalProgress();
 			else if (event.type === "agent_end") {
 				deps.stopTerminalProgress();

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

@@ -82,6 +82,8 @@ export interface InteractiveInputRuntimeDeps {
 		selectNext(): void;
 		toggleDetail(): void;
 	};
+	/** Enter in the workers view; false falls through to the detail toggle. */
+	watchSelectedDispatch: () => boolean;
 	steerSelectedDispatch: () => void;
 	cancelSelectedDispatch: () => void;
 	cancelActiveEditorBash: () => boolean;
@@ -183,7 +185,7 @@ export function createInteractiveInputRuntime(deps: InteractiveInputRuntimeDeps)
 		restoreQueuedFollowUps: deps.editorSubmit.restoreQueuedFollowUpsToEditor,
 	});
 	const leaderKeys = createLeaderKeyController({
-		matchesLeader: (input) => deps.keybindings.matches(input, "clio.leader"),
+		matchesLeader: (input) => deps.keybindings.matches(input, "clio-coder.leader"),
 		leaderTargets: () => deps.keybindings.leaderTargets(),
 		dispatchAction: (id) => deps.dispatchAction(id, keyActionDeps()),
 		isRelease: isKeyRelease,
@@ -238,6 +240,11 @@ export function createInteractiveInputRuntime(deps: InteractiveInputRuntimeDeps)
 						deps.dispatchBoard.toggleDetail();
 						deps.requestRender();
 					},
+					watchSelectedDispatch: () => {
+						const handled = deps.watchSelectedDispatch();
+						if (handled) deps.requestRender();
+						return handled;
+					},
 					steerSelectedDispatch: deps.steerSelectedDispatch,
 					cancelSelectedDispatch: deps.cancelSelectedDispatch,
 					cancelAskUser: () => deps.overlay.cancelAskUser(),
@@ -295,7 +302,7 @@ export function createInteractiveInputRuntime(deps: InteractiveInputRuntimeDeps)
 			deps.reportShutdownFailure ??
 			((step, error) => {
 				process.stderr.write(
-					`[clio:interactive] ${step} failed: ${error instanceof Error ? error.message : String(error)}\n`,
+					`[clio-coder:interactive] ${step} failed: ${error instanceof Error ? error.message : String(error)}\n`,
 				);
 			}),
 	});

package/src/interactive/interactive-presentation.ts

@@ -1,5 +1,6 @@
 import { performance } from "node:perf_hooks";
 import type { ClioSettings } from "../core/config.js";
+import { DEFAULT_SETTINGS } from "../core/defaults.js";
 import type { SafeEventBus } from "../core/event-bus.js";
 import type { ContextState } from "../domains/context/index.js";
 import type { DispatchContract } from "../domains/dispatch/contract.js";
@@ -209,7 +210,7 @@ export function createInteractivePresentation(deps: InteractivePresentationDeps)
 	const getCwd = deps.getCwd ?? (() => process.cwd());
 	const now = deps.now ?? performance.now.bind(performance);
 	const requestRender = (): void => deps.tui.requestRender();
-	const settings = deps.getSettings?.() ?? ({ keybindings: {} } as ClioSettings);
+	const settings = deps.getSettings?.() ?? structuredClone(DEFAULT_SETTINGS);
 	const keybindings = deps.keybindings ?? factories.createKeybindings(settings);
 	const { getExtensionStats, getLiveWorkspaceSnapshot, getWorkspaceSnapshot, refreshLiveWorkspaceGit } =
 		deps.workspaceFacts;
@@ -229,15 +230,15 @@ export function createInteractivePresentation(deps: InteractivePresentationDeps)
 	const renderTrace = getActiveRenderTrace();
 	const chatPanel = factories.createChatPanel({
 		getToolExpandKey: () => {
-			const first = keybindings.getKeys("clio.tool.expand")[0];
+			const first = keybindings.getKeys("clio-coder.tool.expand")[0];
 			return typeof first === "string" && first.length > 0 ? first : undefined;
 		},
-		getOutputVerbosity: () => deps.getSettings?.().terminal.outputVerbosity ?? "default",
+		getOutputVerbosity: () => deps.getSettings?.().interface.outputDetail ?? "default",
 		...(renderTrace ? { onRenderMetrics: (metrics) => renderTrace.recordPanelRender(metrics) } : {}),
 	});
 	const followUpQueuePanel = factories.createFollowUpQueuePanel({
 		getDequeueKey: () => {
-			const first = keybindings.getKeys("clio.message.dequeue")[0];
+			const first = keybindings.getKeys("clio-coder.message.dequeue")[0];
 			return typeof first === "string" && first.length > 0 ? first : undefined;
 		},
 	});
@@ -320,8 +321,8 @@ export function createInteractivePresentation(deps: InteractivePresentationDeps)
 			outputTokens,
 			durationMs,
 			ttftMs: Math.max(0, liveThroughput.firstDeltaAt - liveThroughput.startedAt),
-			providerId: settings?.orchestrator?.target ?? "",
-			modelId: settings?.orchestrator?.model ?? "",
+			providerId: settings?.chat?.target ?? "",
+			modelId: settings?.chat?.model ?? "",
 			recordedAt: Date.now(),
 		};
 	};
@@ -337,7 +338,11 @@ export function createInteractivePresentation(deps: InteractivePresentationDeps)
 	};
 	const dismissContextBootstrapNotices = (): void => {
 		for (const notice of notifications.list()) {
-			if (/^clio: (No CLIO\.md detected|malformed CLIO\.md ignored|Imported agent context changed)/.test(notice.text)) {
+			if (
+				/^(?:clio-coder|clio): (No CLIO(?:-CODER)?\.md detected|malformed CLIO(?:-CODER)?\.md ignored|Imported agent context changed)/.test(
+					notice.text,
+				)
+			) {
 				notifications.dismiss(notice.id);
 			}
 		}
@@ -390,7 +395,7 @@ export function createInteractivePresentation(deps: InteractivePresentationDeps)
 		},
 		getLastTurnSummary: () => lastTurnSummary,
 		getNotifications: () => notifications.list(),
-		dismissKeyLabel: formatKeyLabel(keybindings.getKeys("clio.notifications.dismiss")[0]),
+		dismissKeyLabel: formatKeyLabel(keybindings.getKeys("clio-coder.notifications.dismiss")[0]),
 	};
 	footer = factories.buildFooter(footerDeps);
 	const unsubscribeObservability = deps.observability.subscribe((snapshot) => {
@@ -403,18 +408,18 @@ export function createInteractivePresentation(deps: InteractivePresentationDeps)
 		getModelLabel: () => {
 			const current = deps.getSettings?.();
 			// The rail is the narrowest of the three, so it drops the spaces.
-			return formatTargetLabel(current?.orchestrator?.target, current?.orchestrator?.model, { separator: "·" });
+			return formatTargetLabel(current?.chat?.target, current?.chat?.model, { separator: "·" });
 		},
 		getThinkingLabel: () => {
 			const current = deps.getSettings?.();
 			return (
 				resolveModelRuntimeCapabilitiesForProviders(
 					deps.providers,
-					current?.orchestrator?.target,
-					current?.orchestrator?.model,
-					current?.orchestrator?.thinkingLevel ?? "off",
+					current?.chat?.target,
+					current?.chat?.model,
+					current?.chat?.thinkingLevel ?? "off",
 				)?.thinking.display ??
-				current?.orchestrator?.thinkingLevel ??
+				current?.chat?.thinkingLevel ??
 				"off"
 			);
 		},
@@ -447,7 +452,7 @@ export function createInteractivePresentation(deps: InteractivePresentationDeps)
 			? {
 					streamIngress: deps.resolveStreamIngress,
 					getSmoothStreamingMode: () => {
-						const mode = resolveSmoothStreamingMode(deps.getSettings?.().terminal.smoothStreaming ?? "off");
+						const mode = resolveSmoothStreamingMode(deps.getSettings?.().interface.smoothStreaming ?? "off");
 						const autoAllowed = processAutoPacingAllowed(deps.hasObservedBackpressure?.() ?? false);
 						deps.onSmoothStreamingMode?.(mode, mode === "on" || (mode === "auto" && autoAllowed));
 						return mode;
@@ -487,8 +492,8 @@ export function createInteractivePresentation(deps: InteractivePresentationDeps)
 			footer: footer.view,
 		},
 		{
-			mode: settings.terminal?.tuiMode ?? "regular",
-			fullscreenScrollbar: settings.terminal?.fullscreenScrollbar ?? "auto",
+			mode: settings.interface?.mode ?? "regular",
+			fullscreenScrollbar: settings.interface?.fullscreenScrollbar ?? "auto",
 		},
 	);
 	deps.mount?.(root, editor);