@iowarp/clio-coder 0.3.1 → 0.3.2

package/src/interactive/export-html/tool-renderer.ts

@@ -0,0 +1,54 @@
+/**
+ * Adapt Clio's shared TUI transcript projection to semantic HTML tool rows.
+ * pi-coding-agent 0.84.0 uses the same TUI-render-then-ANSI-convert pattern in
+ * `dist/core/export-html/tool-renderer.js`; Clio keeps its own transcript model
+ * and tool renderers, so the adaptation operates on their rendered lines.
+ */
+import { stripTerminalSequences } from "../../engine/tui.js";
+import { ansiLinesToHtml, escapeHtml } from "./ansi-to-html.js";
+
+interface TranscriptBlock {
+	kind: "tool" | "transcript";
+	toolName?: string;
+	lines: string[];
+}
+
+function toolNameFromHeader(line: string): string | null {
+	const plain = stripTerminalSequences(line);
+	return /^\s*▸\s+([^\s(]+)/u.exec(plain)?.[1] ?? null;
+}
+
+function isToolBodyLine(line: string): boolean {
+	return /^\s*[│╰]/u.test(stripTerminalSequences(line));
+}
+
+function blocksFromLines(lines: ReadonlyArray<string>): TranscriptBlock[] {
+	const blocks: TranscriptBlock[] = [];
+	for (const line of lines) {
+		const name = toolNameFromHeader(line);
+		if (name !== null) {
+			blocks.push({ kind: "tool", toolName: name, lines: [line] });
+			continue;
+		}
+		const previous = blocks[blocks.length - 1];
+		if (previous?.kind === "tool" && isToolBodyLine(line)) {
+			previous.lines.push(line);
+			continue;
+		}
+		if (previous?.kind === "transcript") previous.lines.push(line);
+		else blocks.push({ kind: "transcript", lines: [line] });
+	}
+	return blocks;
+}
+
+export function renderTranscriptHtml(lines: ReadonlyArray<string>): string {
+	return blocksFromLines(lines)
+		.map((block) => {
+			const body = ansiLinesToHtml(block.lines);
+			if (block.kind === "tool") {
+				return `<section class="tool-row" data-tool="${escapeHtml(block.toolName ?? "unknown")}">${body}</section>`;
+			}
+			return `<div class="transcript-row">${body}</div>`;
+		})
+		.join("\n");
+}

package/src/interactive/footer/dashboard.ts

@@ -112,6 +112,8 @@ export interface FooterDashboardDeps {
 	getNotifications?: () => ReadonlyArray<Notification>;
 	/** Whether the Ctrl+G leader is armed and waiting for its next key. */
 	getLeaderArmed?: () => boolean;
+	/** Whether a Ctrl+C armed the double tap and its window is still open. */
+	getShutdownArmed?: () => boolean;
 	dismissKeyLabel?: string;
 	now?: () => number;
 	resolveCurrentBranch?: (cwd: string) => Promise<string | null>;
@@ -172,6 +174,7 @@ function renderFooterCompactLines(state: FooterDashboardRenderState, width: numb
 			state.sessionCost,
 			state.session.outputVerbosity,
 			state.session.leaderArmed ?? false,
+			state.session.shutdownArmed ?? false,
 		),
 	].map((line) => fitDashboardLine(line, safeWidth));
 }
@@ -435,6 +438,7 @@ export function buildFooterDashboard(deps: FooterDashboardDeps): FooterDashboard
 				toolProfile,
 				outputVerbosity: settings?.terminal.outputVerbosity ?? "default",
 				leaderArmed: deps.getLeaderArmed?.() ?? false,
+				shutdownArmed: deps.getShutdownArmed?.() ?? false,
 				memoryIntervention: taskMemory
 					? {
 							enabled: taskMemory.enabled,

package/src/interactive/footer/notifications.ts

@@ -266,7 +266,7 @@ export function formatNotificationPanel(
 	const lines: string[] = [rule(theme, width, { left: "notices" })];
 	for (const entry of entries.slice(0, maxRows)) {
 		const glyph = theme.fg(notificationToken(entry.level), notificationGlyph(entry.level));
-		lines.push(fitFooterText(`${glyph} ${theme.fg("muted", entry.text)}`, width));
+		lines.push(fitFooterText(`${glyph} ${theme.fg("muted", entry.text)}`, width, GLYPH.ellipsis));
 	}
 	const overflow = entries.length - maxRows;
 	const hint = overflow > 0 ? `+${overflow} more · ${dismiss} dismiss` : `${dismiss} dismiss`;

package/src/interactive/footer/widgets.ts

@@ -72,6 +72,13 @@ export interface SessionFacts {
 	 * it against.
 	 */
 	leaderArmed?: boolean;
+	/**
+	 * A Ctrl+C landed on an idle empty prompt and the 500ms window that quits is
+	 * open. Shown for the same reason as the leader above: the arming press left
+	 * the frame identical to the idle frame, so the operator had no way to learn
+	 * that a second press quits, and no way to tell the first press registered.
+	 */
+	shutdownArmed?: boolean;
 	/** Proactive-memory status; kept as one atomic fact row in the expanded dashboard. */
 	memoryIntervention?: {
 		enabled: boolean;
@@ -373,6 +380,7 @@ export function compactSecondaryLine(
 	sessionCost: CostAggregate | null = null,
 	outputVerbosity?: OutputVerbosity | null,
 	leaderArmed = false,
+	shutdownArmed = false,
 ): string {
 	const safeWidth = Math.max(1, Math.floor(width));
 	const barCells = compactContextBarWidth(safeWidth);
@@ -402,6 +410,7 @@ export function compactSecondaryLine(
 		compactMetricChipLimit(safeWidth),
 		outputVerbosity,
 		leaderArmed,
+		shutdownArmed,
 	);
 	// At the smallest widths the context meter consumes the entire secondary
 	// row, so keep a compact mode marker on the left instead of silently hiding
@@ -1106,6 +1115,7 @@ export function buildHarnessStatePill(
  * detail used to spend all of it, so a session holding 9.7k measured tokens
  * showed none of them.
  */
+const CHIP_RANK_SHUTDOWN = -2;
 const CHIP_RANK_LEADER = -1;
 const CHIP_RANK_TOTALS = 0;
 const CHIP_RANK_DETAIL = 1;
@@ -1155,12 +1165,13 @@ export function buildMetricStrip(
 	maxChipsCount = 6,
 	outputVerbosity?: OutputVerbosity | null,
 	leaderArmed = false,
+	shutdownArmed = false,
 ): string {
 	const safeMaxWidth = Math.max(0, Math.floor(maxWidth));
 	if (safeMaxWidth <= 0) return "";
 	const isStreaming = status.phase !== "idle" && status.phase !== "ended";
 	const meaningfulVerbosity = outputVerbosity && outputVerbosity !== "default" ? outputVerbosity : null;
-	if (!isStreaming && !lastTurn && !meaningfulVerbosity && !leaderArmed) return "";
+	if (!isStreaming && !lastTurn && !meaningfulVerbosity && !leaderArmed && !shutdownArmed) return "";
 
 	const candidates: Array<string | null> = [];
 	/** Per-turn detail that ranks below the session totals when the strip is cut. */
@@ -1236,7 +1247,14 @@ export function buildMetricStrip(
 	const chipLimit = Math.max(0, Math.floor(maxChipsCount));
 	const chips: RankedChip[] = [];
 	// Ranked above every measurement: the strip is cut by dropping the
-	// lowest-ranked chip, and this one is the answer to "did that key register".
+	// lowest-ranked chip, and these two are the answer to "did that key
+	// register". The quit hint outranks the leader because its window is
+	// 500ms wide and the leader's is open until the next keystroke.
+	// Two rungs rather than one: the strip drops a chip it cannot fit whole, and
+	// a terminal narrow enough to lose the sentence is exactly the one where the
+	// operator most needs to be told the press registered.
+	const shutdownHint = safeMaxWidth >= 20 ? "Ctrl+C again to quit" : "Ctrl+C again";
+	pushChip(chips, shutdownArmed ? theme.fg("warning", shutdownHint) : null, CHIP_RANK_SHUTDOWN);
 	pushChip(chips, leaderArmed ? theme.fg("accent", "leader armed") : null, CHIP_RANK_LEADER);
 	for (const chip of candidates) pushChip(chips, chip, CHIP_RANK_DETAIL);
 	pushChip(chips, totalChip, CHIP_RANK_TOTALS);

package/src/interactive/footer-panel.ts

@@ -95,9 +95,9 @@ export interface FooterPanel {
 	refresh(): void;
 }
 
-export function fitFooterText(text: string, width: number): string {
+export function fitFooterText(text: string, width: number, ellipsis = ""): string {
 	const safeWidth = Math.max(1, Math.floor(width));
-	return visibleWidth(text) > safeWidth ? truncateToWidth(text, safeWidth, "", true) : text;
+	return visibleWidth(text) > safeWidth ? truncateToWidth(text, safeWidth, ellipsis, true) : text;
 }
 
 const CONTEXT_PERCENT_FIELD_WIDTH = 6;

package/src/interactive/format-time.ts

@@ -35,8 +35,20 @@ let dateFormatter = new Intl.DateTimeFormat("en-CA", DATE_OPTIONS);
 function syncZone(): void {
 	if (process.env.TZ === builtForZone) return;
 	builtForZone = process.env.TZ;
-	clockFormatter = new Intl.DateTimeFormat("en-GB", CLOCK_OPTIONS);
-	dateFormatter = new Intl.DateTimeFormat("en-CA", DATE_OPTIONS);
+	// The zone is passed explicitly, not left for Intl to pick up from
+	// process.env.TZ implicitly, because it doesn't reliably do so: under a
+	// shared test process that constructs many formatters across many zones,
+	// a rebuilt formatter was observed to resolve to America/Chicago while
+	// process.env.TZ read Asia/Kolkata at the exact moment of construction
+	// and of the .format() call right after (issue #84, tests/contracts
+	// instrumentation traced it to Intl's own zone resolution, not a stale
+	// env var). An explicit timeZone option bypasses whatever cached default
+	// resolution goes stale there, so this is correct regardless of whether
+	// that turns out to be a V8/ICU bug that ever gets fixed. Do not "simplify"
+	// this back to relying on process.env.TZ implicitly.
+	const zone = builtForZone === undefined ? undefined : { timeZone: builtForZone };
+	clockFormatter = new Intl.DateTimeFormat("en-GB", { ...CLOCK_OPTIONS, ...zone });
+	dateFormatter = new Intl.DateTimeFormat("en-CA", { ...DATE_OPTIONS, ...zone });
 }
 
 function toEpochMs(instant: Instant): number | null {

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(),
@@ -477,6 +570,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 +585,21 @@ 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"),
+		},
+		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 +622,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 +652,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 +673,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 +683,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 +715,7 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		openContextViewOverlayState,
 		openContextResetOverlayState,
 		openTasksOverlayState,
+		openDecisionsOverlayState,
 		openMemoryOverlayState,
 		openViewOverlayState,
 		openModelOverlayState,
@@ -633,17 +750,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 +806,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 +842,9 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		onLeaderStateChange: (pending) => {
 			leaderArmed = pending;
 		},
+		onShutdownArmedChange: (armed) => {
+			shutdownArmed = armed;
+		},
 		dispatchBoard,
 		steerSelectedDispatch,
 		cancelSelectedDispatch,
@@ -732,7 +855,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 +886,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

@@ -57,6 +57,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;
@@ -75,6 +77,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 +126,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);
@@ -310,7 +314,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) => {