@iowarp/clio-coder 0.3.1 → 0.3.3

package/src/interactive/interactive-application.ts

@@ -14,14 +14,16 @@ 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";
 import type { FleetNodeSnapshot } from "../domains/scheduling/cluster.js";
+import type { DecisionLedgerEntry } from "../domains/session/entries.js";
 import type { SessionContract, SessionEntry, TaskBoardSnapshot } from "../domains/session/index.js";
 import type { ShareContract } from "../domains/share/index.js";
+import type { UserTasksStore } from "../domains/user-tasks/store.js";
 import { createAgentProgress } from "../engine/tui.js";
 import type { ImageContent } from "../engine/types.js";
 import type { AskUserHandler } from "../tools/ask-user.js";
 import type { ToolRegistry } from "../tools/registry.js";
 import { APPLICATION_DOUBLE_TAP_MS, type ApplicationController } from "./application-controller.js";
-import type { ChatLoop } from "./chat-loop.js";
+import type { ChatLoop, ChatLoopEvent } from "./chat-loop.js";
 import { emitCommandNotice } from "./command-fallbacks.js";
 import { appendNotice } from "./command-output.js";
 import { createDispatchSteering } from "./dispatch-steering.js";
@@ -29,12 +31,13 @@ import { createEditorSubmitController } from "./editor-submit.js";
 import { createInteractiveEventProjection } from "./interactive-event-projection.js";
 import { createInteractiveInputRuntime } from "./interactive-input-runtime.js";
 import { createInteractivePresentation } from "./interactive-presentation.js";
-import { createProcessInteractiveShell } from "./interactive-shell.js";
+import { createProcessInteractiveShell, getActiveRenderTrace } from "./interactive-shell.js";
 import { createInteractiveSlashRuntime, resolveAvailableThinkingLevels } from "./interactive-slash-runtime.js";
 import { createInteractiveSubscriptions } from "./interactive-subscriptions.js";
 import { createInteractiveTickers } from "./interactive-tickers.js";
 import { createOverlayLifecycle, type OverlayLifecycleController, type OverlayState } from "./overlay-lifecycle.js";
 import { interopOverlaySurface } from "./overlays/interop.js";
+import { settleChatBeforeSessionSwitch } from "./session-switch-settlement.js";
 import { createSessionTranscript } from "./session-transcript.js";
 import type {
 	ContextClearCommandOptions,
@@ -42,6 +45,8 @@ import type {
 	RunIo,
 	TaskMemorySeedCommandResult,
 } from "./slash-commands.js";
+import { processAutoPacingAllowed, resolveSmoothStreamingMode } from "./stream-pacing-policy.js";
+import type { TerminalLease } from "./terminal-lease.js";
 import { createWorkspaceFacts } from "./workspace-facts.js";
 
 export {
@@ -105,6 +110,12 @@ export interface InteractiveDeps {
 	agents?: AgentsContract;
 	observability: ObservabilityContract;
 	chat: ChatLoop;
+	/** Fired once after the first real TUI render transaction issued all of its terminal writes. */
+	onFirstFrameCommit?: (frameId: number) => void;
+	/** Existing Stage 0 owner to hydrate in place. */
+	terminalLease?: TerminalLease;
+	/** Fired after the first committed frame containing the hydrated Stage 1 root. */
+	onHydratedFrameCommit?: (frameId: number | null) => void;
 	/** Startup notices collected before the TUI is ready; rendered in the transcript. */
 	initialNotices?: ReadonlyArray<string>;
 	resources?: ResourcesContract;
@@ -124,6 +135,12 @@ export interface InteractiveDeps {
 	readSessionEntries?: () => ReadonlyArray<SessionEntry>;
 	/** Live session task board for the footer tasks row and the /tasks overlay. */
 	getTaskBoard?: () => TaskBoardSnapshot | null;
+	/** Settled interview snapshots folded from the active session branch. */
+	getDecisionBoard?: () => ReadonlyArray<DecisionLedgerEntry>;
+	/** Append an acknowledged operator-authored decision revision. */
+	supersedeDecision?: (interviewId: string, key: string, correction?: string) => unknown;
+	/** Project-scoped operator task inbox used by `/tasks` subcommands. */
+	userTasks?: UserTasksStore;
 	/** Live, read-only task-memory state for status surfaces and the /memory overlay. */
 	getTaskMemoryStatus?: () => TaskMemoryOperatorStatus;
 	/** Newest structured handoff available for an opt-in seed, when enabled. */
@@ -174,7 +191,7 @@ export interface InteractiveDeps {
 	 */
 	onForkSession?: (parentTurnId: string) => void;
 	/**
-	 * Run /compact for the current session. Resolves the compaction model
+	 * Run `/context compact` for the current session. Resolves the compaction model
 	 * (settings.compaction.model with fallback to the orchestrator target),
 	 * reads session entries, streams a summary via the session compaction
 	 * engine, and persists a compactionSummary entry.
@@ -256,6 +273,8 @@ export interface KeyBindingDeps {
 	requestShutdown: () => void;
 	toggleStatus: () => void;
 	toggleDispatchBoard: () => void;
+	openTasks: () => void;
+	openDecisions: () => void;
 	backgroundDispatch: () => void;
 	openModelSelector: () => void;
 	openTree: () => void;
@@ -269,6 +288,7 @@ export interface KeyBindingDeps {
 	toggleAllThinkingExpansion: () => void;
 	openExternalEditor: () => void;
 	queueFollowUp: () => void;
+	interruptWithMessage: () => void;
 	restoreQueuedFollowUps: () => void;
 }
 
@@ -314,6 +334,9 @@ export function dispatchInteractiveAction(id: ClioKeybinding, deps: KeyBindingDe
 		case "clio.message.followUp":
 			deps.queueFollowUp();
 			return true;
+		case "clio.message.interrupt":
+			deps.interruptWithMessage();
+			return true;
 		case "clio.message.dequeue":
 			deps.restoreQueuedFollowUps();
 			return true;
@@ -335,6 +358,12 @@ export function dispatchInteractiveAction(id: ClioKeybinding, deps: KeyBindingDe
 		case "clio.dispatchBoard.toggle":
 			deps.toggleDispatchBoard();
 			return true;
+		case "clio.tasks.open":
+			deps.openTasks();
+			return true;
+		case "clio.decisions.open":
+			deps.openDecisions();
+			return true;
 		case "clio.dispatch.background":
 			deps.backgroundDispatch();
 			return true;
@@ -363,6 +392,8 @@ export function routeInteractiveKey(data: string, deps: KeyBindingDeps): boolean
 		"clio.thinking.cycle",
 		"clio.session.tree",
 		"clio.dispatchBoard.toggle",
+		"clio.tasks.open",
+		"clio.decisions.open",
 		"clio.dispatch.background",
 		"clio.model.select",
 		// Match cycleBackward before cycleForward so a user rebind where one key
@@ -379,8 +410,48 @@ export function routeInteractiveKey(data: string, deps: KeyBindingDeps): boolean
 }
 
 export async function createInteractiveApplication(deps: InteractiveDeps): Promise<number> {
-	const shell = createProcessInteractiveShell();
+	const initialSmoothStreaming = resolveSmoothStreamingMode(deps.getSettings?.().terminal.smoothStreaming ?? "off");
+	const initialAutoPacingAllowed = processAutoPacingAllowed(false);
+	const lease = deps.terminalLease;
+	const shell =
+		lease?.shell ??
+		createProcessInteractiveShell({
+			tuiMode: deps.getSettings?.().terminal.tuiMode ?? "regular",
+			streamPacingActive:
+				initialSmoothStreaming === "on" || (initialSmoothStreaming === "auto" && initialAutoPacingAllowed),
+			...(deps.onFirstFrameCommit ? { onFirstFrameCommit: deps.onFirstFrameCommit } : {}),
+		});
 	const { terminal, tui } = shell;
+	const renderTrace = getActiveRenderTrace();
+	const visibleEventIngress = new WeakMap<
+		object,
+		{ sequence: number; traceSequence: number; generation: number; ingressAt: number }
+	>();
+	let visibleEventSequence = 0;
+	let visibleEventGeneration = 0;
+	const recordChatEventIngress = (event: ChatLoopEvent): void => {
+		if (event.type === "agent_start") {
+			visibleEventGeneration += 1;
+			renderTrace?.beginGeneration();
+			return;
+		}
+		if (event.type !== "text_delta" && event.type !== "thinking_delta") return;
+		visibleEventSequence += 1;
+		const ingress = {
+			sequence: visibleEventSequence,
+			traceSequence: visibleEventSequence,
+			generation: visibleEventGeneration,
+			ingressAt: performance.now(),
+		};
+		visibleEventIngress.set(event, ingress);
+		if (renderTrace) {
+			ingress.traceSequence = renderTrace.recordVisibleEvent({
+				kind: event.type === "text_delta" ? "text" : "thinking",
+				contentIndex: event.contentIndex,
+				delta: event.delta,
+			});
+		}
+	};
 	let applicationController: ApplicationController;
 	const workspaceFacts = createWorkspaceFacts({
 		cwd: process.cwd(),
@@ -406,9 +477,20 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 	 * the footer reads it and the input runtime that flips it is built later.
 	 */
 	let leaderArmed = false;
+	/**
+	 * A Ctrl+C armed the double tap and its 500ms window is still open. Owned
+	 * here for the same reason as the leader flag above.
+	 */
+	let shutdownArmed = false;
 	const presentation = createInteractivePresentation({
 		bus: deps.bus,
 		getLeaderArmed: () => leaderArmed,
+		getShutdownArmed: () => shutdownArmed,
+		resolveVisibleEventSequence: (event) => visibleEventIngress.get(event)?.traceSequence ?? null,
+		resolveStreamIngress: (event) => visibleEventIngress.get(event) ?? null,
+		commitFrame: (reason) => shell.commitCurrentFrame(reason === "teardown" ? 300 : 30_000),
+		hasObservedBackpressure: () => shell.hasObservedBackpressure(),
+		onSmoothStreamingMode: (_mode, pacingActive) => shell.setStreamPacingActive(pacingActive),
 		providers: deps.providers,
 		dispatch: deps.dispatch,
 		observability: deps.observability,
@@ -417,7 +499,14 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		sessionTranscript,
 		tui,
 		terminal,
-		mount: (root, editor) => shell.mount(root, editor),
+		...(!lease ? { mount: (root, editor) => shell.mount(root, editor) } : {}),
+		...(lease
+			? {
+					editor: lease.editor,
+					keybindings: lease.keybindings,
+					bootPending: lease.pending,
+				}
+			: {}),
 		...(deps.getSettings ? { getSettings: deps.getSettings } : {}),
 		...(deps.resources ? { resources: deps.resources } : {}),
 		...(deps.session ? { session: deps.session } : {}),
@@ -448,8 +537,8 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 	const agentProgress = createAgentProgress(terminal);
 	const busNoticeSink = {
 		appendReplayBlock: (renderBlock: Parameters<typeof chatPanel.appendReplayBlock>[0]) =>
-			chatPanel.appendReplayBlock(renderBlock),
-		requestRender: () => tui.requestRender(),
+			chatRenderer.mutate(() => chatPanel.appendReplayBlock(renderBlock), "bus-notice"),
+		requestRender: () => {},
 	};
 	const eventProjection = createInteractiveEventProjection({
 		bus: deps.bus,
@@ -458,6 +547,10 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		...(deps.initialNotices ? { initialNotices: deps.initialNotices } : {}),
 		...(deps.getSettings ? { getSettings: deps.getSettings } : {}),
 		getTerminalColumns: () => terminal.columns,
+		onChatEventIngress: (event) => {
+			recordChatEventIngress(event);
+			presentation.recordChatEvent(event);
+		},
 		applyChatEvent: (event) => chatRenderer.applyEvent(event),
 		setFollowUpMessages: (messages) => followUpQueuePanel.setMessages(messages),
 		isAskUserWaiting: () => overlayLifecycle.isAskUserWaiting(),
@@ -467,6 +560,7 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		recordToolEnd: (_toolName, toolCallId, isError, truncated) =>
 			presentation.recordToolEnd({ toolCallId, isError, truncated }),
 		setStatusLine: (line) => chatPanel.setStatusLine(line),
+		setLiveReasoning: (view) => chatPanel.setLiveReasoning(view),
 		setLastTurnSummary: (summary) => presentation.setLastTurnSummary(summary),
 		startTerminalProgress: () => agentProgress.start(),
 		stopTerminalProgress: () => agentProgress.stop(),
@@ -477,6 +571,12 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		dismissNotification: (key) => notifications.dismiss(key),
 		appendTranscriptNotice: (level, text) => appendNotice(level, text, busNoticeSink),
 		refreshSettingsOverlay: () => overlayLifecycle.refreshSettingsOverlay(),
+		onConfigHotReload: (settings) => {
+			const mode = resolveSmoothStreamingMode(settings.terminal.smoothStreaming);
+			const autoAllowed = processAutoPacingAllowed(shell.hasObservedBackpressure());
+			chatRenderer.setSmoothStreamingMode(mode);
+			shell.setStreamPacingActive(mode === "on" || (mode === "auto" && autoAllowed));
+		},
 	});
 	// The overlay reads the report this process already produced at boot; it
 	// never probes on a keystroke.
@@ -486,14 +586,22 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		io,
 		bus: deps.bus,
 		dispatch: deps.dispatch,
+		...(deps.session ? { session: deps.session } : {}),
 		providers: deps.providers,
 		chat: deps.chat,
-		chatPanel,
+		chatPanel: {
+			appendReplayBlock: (...args) => chatRenderer.mutate(() => chatPanel.appendReplayBlock(...args), "slash-output"),
+			appendUser: (text) => chatRenderer.mutate(() => chatPanel.appendUser(text), "user-submit"),
+			clearFoldOverrides: () => chatRenderer.mutate(() => chatPanel.clearFoldOverrides(), "output-detail"),
+		},
+		beforeSemanticSubmit: () => chatRenderer.flush(),
+		settleVisibleFrame: (reason) => chatRenderer.flushAndCommit(reason),
 		...(deps.resources ? { resources: deps.resources } : {}),
 		...(deps.extensions ? { extensions: deps.extensions } : {}),
 		...(interopSurface ? { interop: interopSurface } : {}),
 		...(deps.agents ? { agents: deps.agents } : {}),
 		...(deps.share ? { share: deps.share } : {}),
+		...(deps.userTasks ? { userTasks: deps.userTasks } : {}),
 		...(deps.getSettings ? { getSettings: deps.getSettings } : {}),
 		...(deps.writeSettings ? { writeSettings: deps.writeSettings } : {}),
 		...(deps.commitSetting ? { commitSetting: deps.commitSetting } : {}),
@@ -516,6 +624,7 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		openCost: () => openCostOverlayState(),
 		openContextView: () => openContextViewOverlayState(),
 		openTasks: () => openTasksOverlayState(),
+		openDecisions: () => openDecisionsOverlayState(),
 		openMemory: () => openMemoryOverlayState(),
 		...(deps.seedTaskMemory ? { seedTaskMemory: deps.seedTaskMemory } : {}),
 		openView: (filter) => openViewOverlayState(filter),
@@ -545,8 +654,14 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		dispatch: deps.dispatch,
 		...(deps.session ? { session: deps.session } : {}),
 		sessionTranscript,
-		chatPanel,
+		chatPanel: {
+			appendReplayBlock: (...args) =>
+				chatRenderer.mutate(() => chatPanel.appendReplayBlock(...args), "editor-command-output"),
+		},
+		beforeSemanticBoundary: () => chatRenderer.flush(),
+		settleVisibleFrame: (reason) => chatRenderer.flushAndCommit(reason),
 		dispatchCommand: slashRuntime.dispatchCommand,
+		dispatchCommandAsync: slashRuntime.admitCommand,
 		collapseLaunchpadBeforeSubmit: () => presentation.collapseWelcomeDashboard(),
 		expandSubmit: (text) => expandInteractiveSubmitAsync(text, deps.resources),
 		notify,
@@ -560,6 +675,7 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		contextActivityStore,
 		getOverlayState: () => overlayLifecycle?.getState() ?? "closed",
 		isFooterExpanded: () => footer.isExpanded(),
+		...(deps.getTaskBoard ? { getTaskBoard: deps.getTaskBoard } : {}),
 	});
 	/**
 	 * The one transcript reset. The chat panel and the worker fold are two views
@@ -569,8 +685,10 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 	 * because the subscriptions that own the fold are built below.
 	 */
 	const resetTranscript = (): void => {
-		chatPanel.reset();
-		interactiveSubscriptions.workers.reset();
+		chatRenderer.reset(() => {
+			chatPanel.reset();
+			interactiveSubscriptions.workers.reset();
+		});
 	};
 	overlayLifecycle = createOverlayLifecycle({
 		app: deps,
@@ -599,6 +717,7 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		openContextViewOverlayState,
 		openContextResetOverlayState,
 		openTasksOverlayState,
+		openDecisionsOverlayState,
 		openMemoryOverlayState,
 		openViewOverlayState,
 		openModelOverlayState,
@@ -633,17 +752,20 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 			const current = editor.getText();
 			editor.setText([restored.join("\n\n"), current].filter((part) => part.trim().length > 0).join("\n\n"));
 		}
+		chatRenderer.flush();
 		deps.chat.cancel();
 		deps.toolRegistry?.cancelParkedCalls("run cancelled by operator");
 		footer.refresh();
 		tui.requestRender();
 	};
 
-	const startNewSession = (): void => {
+	const startNewSession = async (): Promise<void> => {
 		if (!deps.onNewSession) {
 			emitCommandNotice(slashRuntime.notice, "error", "new", "session contract unavailable");
 			return;
 		}
+		const settlement = settleChatBeforeSessionSwitch(deps.chat);
+		if (settlement) await settlement;
 		deps.onNewSession();
 		deps.observability.resetSession();
 		presentation.resetForNewSession();
@@ -686,7 +808,7 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		// The reducer mutates one state object per assignment, so the panel is
 		// handed that object rather than a copy: a streamed delta reaches the
 		// screen by invalidating a cached render, not by rebuilding the entry.
-		applyWorkerState: (state) => chatPanel.applyWorkerState(state),
+		applyWorkerState: (state) => chatRenderer.mutate(() => chatPanel.applyWorkerState(state), "worker-state"),
 		recordWorkerRun: (fields) => {
 			// A `/run` is an operator action that produced durable state, so it
 			// opens a session the same way a local `!bash` line does. Persistence
@@ -722,6 +844,9 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		onLeaderStateChange: (pending) => {
 			leaderArmed = pending;
 		},
+		onShutdownArmedChange: (armed) => {
+			shutdownArmed = armed;
+		},
 		dispatchBoard,
 		steerSelectedDispatch,
 		cancelSelectedDispatch,
@@ -732,7 +857,25 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		editorSubmit,
 		requestRender: () => tui.requestRender(),
 		notifications,
-		chatPanel,
+		chatPanel: {
+			toggleLastToolExpanded: () => chatPanel.toggleLastToolExpanded(),
+			toggleAllToolsExpanded: () => chatPanel.toggleAllToolsExpanded(),
+			toggleLiveToolOutput: () => chatPanel.toggleLiveToolOutput(),
+			toggleLastThinking: () => {
+				let changed = false;
+				chatRenderer.mutate(() => {
+					changed = chatPanel.toggleLastThinking();
+				}, "thinking-visibility");
+				return changed;
+			},
+			toggleAllThinking: () => {
+				let changed = false;
+				chatRenderer.mutate(() => {
+					changed = chatPanel.toggleAllThinking();
+				}, "thinking-visibility");
+				return changed;
+			},
+		},
 		shutdown: {
 			stopTickers: presentation.stopTickers,
 			disposeInteractiveTickers: interactiveTickers.dispose,
@@ -745,11 +888,54 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 			disposeChat: () => deps.chat.dispose(),
 			disposeSubscriptions: interactiveSubscriptions.dispose,
 		},
-		stopUi: () => shell.stop(),
+		beforeStopUi: (() => {
+			let settlement: Promise<void> | null = null;
+			return () => {
+				settlement ??= chatRenderer.flushAndCommit("teardown").finally(() => chatRenderer.dispose());
+				return settlement;
+			};
+		})(),
+		stopUi: () => {
+			if (lease) void lease.close();
+			else shell.stop();
+		},
 		cancelParkedCalls: (reason) => deps.toolRegistry?.cancelParkedCalls(reason),
-		onShutdown: deps.onShutdown,
-		registerInputListener: (listener) => tui.addInputListener(listener),
+		onShutdown: async () => {
+			try {
+				await deps.onShutdown();
+			} finally {
+				if (lease) await lease.close();
+				else await shell.settle();
+			}
+		},
+		registerInputListener: (listener) => {
+			if (lease) lease.registerApplicationInput(listener);
+			else tui.addInputListener(listener);
+		},
+		...(lease
+			? {
+					signals: lease.applicationSignals,
+					// The lease registered its exactly-once drain before hydration.
+					registerTerminalTeardown: () => {},
+				}
+			: {}),
+		...(renderTrace
+			? {
+					onInputIngress: (action, data) =>
+						renderTrace.recordInputIngress(action, Buffer.byteLength(data, "utf8"), action !== "no-visual-change"),
+				}
+			: {}),
 	});
 
+	if (lease) {
+		const adopted = lease.adopt({
+			root: presentation.root,
+			editorChrome: presentation.editorChrome,
+			admitSubmission: (submission) => editorSubmit.admitCapturedText(submission.rawText, lease.abortSignal),
+			...(deps.onHydratedFrameCommit ? { onHydratedFrame: deps.onHydratedFrameCommit } : {}),
+		});
+		if (!adopted) void applicationController.shutdown();
+	}
+
 	return applicationController.run;
 }

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

@@ -28,6 +28,8 @@ import {
 import {
 	type AgentStatus,
 	INLINE_STATUS_INDENT_COLS,
+	type ReasoningUsageView,
+	reasoningFromTally,
 	resolveInlineVerb,
 	type StatusPhase,
 	spinnerFrame,
@@ -57,6 +59,8 @@ export interface InteractiveEventProjectionDeps {
 	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;
@@ -65,6 +69,11 @@ export interface InteractiveEventProjectionDeps {
 	recordToolStart: (toolName: string, toolCallId: string) => void;
 	recordToolEnd: (toolName: string, toolCallId: string, isError: boolean, truncated: boolean) => void;
 	setStatusLine: (line: InteractiveStatusLine | null) => void;
+	/**
+	 * Publish the live turn's reasoning projection to the transcript. Optional so
+	 * a host without a chat panel still gets every other projection.
+	 */
+	setLiveReasoning?: (view: ReasoningUsageView | null) => void;
 	setLastTurnSummary: (summary: TurnSummary) => void;
 	startTerminalProgress: () => void;
 	stopTerminalProgress: () => void;
@@ -75,6 +84,7 @@ export interface InteractiveEventProjectionDeps {
 	dismissNotification: (key: string) => void;
 	appendTranscriptNotice: (level: InteractiveTranscriptNoticeLevel, text: string) => void;
 	refreshSettingsOverlay: () => void;
+	onConfigHotReload?: (settings: Readonly<ClioSettings>) => void;
 }
 
 export interface InteractiveEventProjection {
@@ -123,6 +133,7 @@ export function createInteractiveEventProjection(deps: InteractiveEventProjectio
 	const remainingUnsubscribers: Array<() => void> = [];
 	primaryUnsubscribers.push(
 		deps.chat.onEvent((event) => {
+			deps.onChatEventIngress?.(event);
 			if (event.type === "notice") {
 				if (event.surface === "transcript") {
 					deps.applyChatEvent(event);
@@ -173,6 +184,11 @@ export function createInteractiveEventProjection(deps: InteractiveEventProjectio
 	let statusInlineFrame = 0;
 	primaryUnsubscribers.push(
 		deps.status.subscribe((status) => {
+			// One projection of the run tally reaches the transcript, so the live
+			// line, the turn receipt, and the footer state the same number.
+			deps.setLiveReasoning?.(
+				status.phase === "idle" || status.phase === "ended" ? null : reasoningFromTally(status.runTally),
+			);
 			if (status.phase === "idle") {
 				deps.setStatusLine(null);
 			} else if (status.phase === "ended") {
@@ -310,7 +326,8 @@ export function createInteractiveEventProjection(deps: InteractiveEventProjectio
 			deps.refreshFooter();
 			deps.requestRender();
 		}),
-		deps.bus.on(BusChannels.ConfigHotReload, () => {
+		deps.bus.on(BusChannels.ConfigHotReload, (payload) => {
+			deps.onConfigHotReload?.(payload.settings);
 			deps.refreshSettingsOverlay();
 		}),
 		deps.bus.on(BusChannels.ConfigReloadFailed, (payload) => {

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

@@ -1,6 +1,6 @@
 import { getTerminationCoordinator } from "../core/termination.js";
 import type { ClioKeybinding } from "../domains/config/keybindings.js";
-import { isKeyRelease } from "../engine/tui.js";
+import { isKeyRelease, type Keybinding } from "../engine/tui.js";
 import {
 	type ApplicationClock,
 	type ApplicationController,
@@ -12,6 +12,7 @@ import {
 } 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;
@@ -20,6 +21,8 @@ export interface InteractiveInputKeyActionDeps {
 	requestShutdown: () => void;
 	toggleStatus: () => void;
 	toggleDispatchBoard: () => void;
+	openTasks: () => void;
+	openDecisions: () => void;
 	backgroundDispatch: () => void;
 	openModelSelector: () => void;
 	openTree: () => void;
@@ -33,12 +36,13 @@ export interface InteractiveInputKeyActionDeps {
 	toggleAllThinkingExpansion: () => void;
 	openExternalEditor: () => void;
 	queueFollowUp: () => void;
+	interruptWithMessage: () => void;
 	restoreQueuedFollowUps: () => void;
 }
 
 export interface InteractiveInputRuntimeDeps {
 	keybindings: {
-		matches(data: string, id: ClioKeybinding): boolean;
+		matches(data: string, id: Keybinding): boolean;
 		leaderTargets(): ReadonlyArray<LeaderTarget>;
 	};
 	dispatchAction: (id: ClioKeybinding, deps: InteractiveInputKeyActionDeps) => boolean;
@@ -61,10 +65,14 @@ export interface InteractiveInputRuntimeDeps {
 		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;
@@ -78,6 +86,7 @@ export interface InteractiveInputRuntimeDeps {
 	editorSubmit: {
 		openExternalEditorForInput(): void;
 		queueFollowUpFromEditor(): void;
+		interruptFromEditor(): void;
 		restoreQueuedFollowUpsToEditor(): void;
 	};
 	requestRender: () => void;
@@ -106,12 +115,14 @@ export interface InteractiveInputRuntimeDeps {
 		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) => void;
+	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;
@@ -133,6 +144,8 @@ export function createInteractiveInputRuntime(deps: InteractiveInputRuntimeDeps)
 		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,
@@ -161,6 +174,7 @@ export function createInteractiveInputRuntime(deps: InteractiveInputRuntimeDeps)
 		},
 		openExternalEditor: deps.editorSubmit.openExternalEditorForInput,
 		queueFollowUp: deps.editorSubmit.queueFollowUpFromEditor,
+		interruptWithMessage: deps.editorSubmit.interruptFromEditor,
 		restoreQueuedFollowUps: deps.editorSubmit.restoreQueuedFollowUpsToEditor,
 	});
 	const leaderKeys = createLeaderKeyController({
@@ -212,6 +226,9 @@ export function createInteractiveInputRuntime(deps: InteractiveInputRuntimeDeps)
 				},
 				(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,
@@ -220,6 +237,13 @@ export function createInteractiveInputRuntime(deps: InteractiveInputRuntimeDeps)
 		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),
@@ -242,6 +266,7 @@ export function createInteractiveInputRuntime(deps: InteractiveInputRuntimeDeps)
 			() => deps.shutdown.disposeSubscriptions(),
 		],
 		stopUi: deps.stopUi,
+		...(deps.beforeStopUi ? { beforeStopUi: deps.beforeStopUi } : {}),
 		cancelParkedCalls: deps.cancelParkedCalls,
 		onShutdown: deps.onShutdown,
 		registerTerminalTeardown:
@@ -256,6 +281,27 @@ export function createInteractiveInputRuntime(deps: InteractiveInputRuntimeDeps)
 				);
 			}),
 	});
-	deps.registerInputListener(controller.handleInput);
+	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";
+}