@iowarp/clio-coder 0.3.1 → 0.3.2

package/src/interactive/overlay-general-openers.ts

@@ -4,6 +4,10 @@ import { loadMemoryRecordsSync, type MemoryRecord } from "../domains/memory/inde
 import type { ObservabilityContract } from "../domains/observability/index.js";
 import type { ContextLedger } from "../domains/session/context-ledger.js";
 import type { SessionMeta } from "../domains/session/index.js";
+import { foldSessionArtifacts } from "../domains/session/session-artifacts.js";
+import { foldSessionTaskHistory } from "../domains/session/task-board.js";
+import { filterEntriesToActivePath } from "../domains/session/tree/active-path.js";
+import type { UserTasksStore } from "../domains/user-tasks/store.js";
 import type { TUI } from "../engine/tui.js";
 import { type OpenContextOverlayOptions, openContextOverlay } from "./context-overlay.js";
 import { openCostOverlay } from "./cost-overlay.js";
@@ -20,7 +24,8 @@ import {
 	contextResetOptions,
 	openContextResetOverlay,
 } from "./overlays/context-reset.js";
-import type { ContextClearCommandOptions } from "./slash-commands.js";
+import { formatDecisionCorrectionTurn, openDecisionsOverlay } from "./overlays/decisions.js";
+import { type ContextClearCommandOptions, formatUserTaskHandoff } from "./slash-commands.js";
 import { openTasksOverlay } from "./tasks-overlay.js";
 import { type ArtifactProviderDeps, createDefaultArtifactProviders } from "./view/artifacts.js";
 import { openViewOverlay } from "./view/view-overlay.js";
@@ -40,6 +45,10 @@ export interface OverlayGeneralOpenersDeps {
 	renderTaskIsland: () => void;
 	requestRender: () => void;
 	getTaskBoard?: Parameters<typeof openTasksOverlay>[1];
+	userTasks?: UserTasksStore;
+	getDecisionBoard?: Parameters<typeof openDecisionsOverlay>[1];
+	supersedeDecision?: (interviewId: string, key: string, correction?: string) => unknown;
+	submitChat: (text: string) => void;
 	getTaskMemoryStatus?: Parameters<typeof openMemoryOverlay>[1];
 	dataDir: string;
 	notify: (level: "info" | "success" | "warning" | "error", text: string, key?: string) => void;
@@ -56,6 +65,7 @@ export interface OverlayGeneralOpenersDeps {
 	openContextOverlay?: typeof openContextOverlay;
 	openContextResetOverlay?: typeof openContextResetOverlay;
 	openTasksOverlay?: typeof openTasksOverlay;
+	openDecisionsOverlay?: typeof openDecisionsOverlay;
 	openMemoryOverlay?: typeof openMemoryOverlay;
 	openViewOverlay?: typeof openViewOverlay;
 }
@@ -66,6 +76,7 @@ export interface OverlayGeneralOpeners {
 	openContextReset(): void;
 	toggleFooter(): void;
 	openTasks(): void;
+	openDecisions(): void;
 	openMemory(): void;
 	openView(initialFilter?: string): void;
 	toggleDispatchBoard(): void;
@@ -76,6 +87,7 @@ export function createOverlayGeneralOpeners(deps: OverlayGeneralOpenersDeps): Ov
 	const openContextOverlayFactory = deps.openContextOverlay ?? openContextOverlay;
 	const openContextResetOverlayFactory = deps.openContextResetOverlay ?? openContextResetOverlay;
 	const openTasksOverlayFactory = deps.openTasksOverlay ?? openTasksOverlay;
+	const openDecisionsOverlayFactory = deps.openDecisionsOverlay ?? openDecisionsOverlay;
 	const openMemoryOverlayFactory = deps.openMemoryOverlay ?? openMemoryOverlay;
 	const openViewOverlayFactory = deps.openViewOverlay ?? openViewOverlay;
 	const showOverlayFrameFactory = deps.showOverlayFrame ?? showClioOverlayFrame;
@@ -137,6 +149,50 @@ export function createOverlayGeneralOpeners(deps: OverlayGeneralOpenersDeps): Ov
 		deps.transitions.state = "tasks";
 		deps.transitions.handle = openTasksOverlayFactory(deps.tui, () => deps.getTaskBoard?.() ?? null, {
 			onClose: deps.closeOverlay,
+			getSessionSnapshot: () => {
+				const meta = deps.getSessionMeta();
+				const entries = filterEntriesToActivePath(deps.readSessionEntries?.() ?? [], meta?.pinnedLeafTurnId ?? undefined);
+				const workspace = meta?.cwd ?? process.cwd();
+				return {
+					history: foldSessionTaskHistory(entries),
+					artifacts: foldSessionArtifacts(entries, { workspace }),
+				};
+			},
+			...(deps.userTasks
+				? {
+						getUserTasks: () => deps.userTasks?.snapshot() ?? [],
+						onAddUserTask: (title: string) => void deps.userTasks?.add(title),
+						onHandUserTask: (id: string) => {
+							const task = deps.userTasks?.hand(id, deps.getSessionId?.() ?? undefined);
+							if (!task) throw new Error("operator task inbox is unavailable");
+							deps.submitChat(formatUserTaskHandoff(task));
+						},
+						onDoneUserTask: (id: string) => void deps.userTasks?.done(id),
+						onDropUserTask: (id: string) => void deps.userTasks?.drop(id),
+					}
+				: {}),
+			onOpenArtifact: (path: string) => openView(`workspace:${path}`),
+			requestRender: deps.requestRender,
+			workspace: deps.getSessionMeta()?.cwd ?? process.cwd(),
+		});
+		deps.requestRender();
+	};
+
+	const openDecisions = (): void => {
+		if (deps.transitions.state !== "closed") return;
+		deps.transitions.state = "decisions";
+		deps.transitions.handle = openDecisionsOverlayFactory(deps.tui, () => deps.getDecisionBoard?.() ?? [], {
+			onSupersede: (selection) => {
+				if (!deps.supersedeDecision) throw new Error("decision board is unavailable in this session");
+				deps.supersedeDecision(selection.interviewId, selection.key);
+			},
+			onCorrection: (selection, correction) => {
+				if (!deps.supersedeDecision) throw new Error("decision board is unavailable in this session");
+				deps.supersedeDecision(selection.interviewId, selection.key, correction);
+				deps.closeOverlay();
+				deps.submitChat(formatDecisionCorrectionTurn(selection, correction));
+			},
+			onClose: deps.closeOverlay,
 		});
 		deps.requestRender();
 	};
@@ -210,6 +266,7 @@ export function createOverlayGeneralOpeners(deps: OverlayGeneralOpenersDeps): Ov
 		openContextReset,
 		toggleFooter,
 		openTasks,
+		openDecisions,
 		openMemory,
 		openView,
 		toggleDispatchBoard,

package/src/interactive/overlay-key-routing.ts

@@ -10,6 +10,7 @@ export type OverlayState =
 	| "context-view"
 	| "context-reset"
 	| "tasks"
+	| "decisions"
 	| "memory"
 	| "view"
 	| "model"
@@ -158,6 +159,7 @@ export function routeOverlayKey(
 	if (overlayState === "closed") return false;
 	if (
 		(overlayState === "dispatch-board" && matches(data, "clio.dispatchBoard.toggle")) ||
+		(overlayState === "tasks" && matches(data, "clio.tasks.open")) ||
 		(overlayState === "tree" && matches(data, "clio.session.tree")) ||
 		(overlayState === "model" && matches(data, "clio.model.select")) ||
 		(overlayState === "help" && matches(data, "clio.leader"))
@@ -180,6 +182,7 @@ export function routeOverlayKey(
 	}
 	if (overlayState === "context-reset") return false;
 	if (overlayState === "tasks") return false;
+	if (overlayState === "decisions") return false;
 	if (overlayState === "memory") return false;
 	if (overlayState === "view") return false;
 	if (overlayState === "model") return routeModelOverlayKey(data, deps);

package/src/interactive/overlay-lifecycle.ts

@@ -33,6 +33,8 @@ export type OverlayLifecycleApplicationDeps = Pick<
 	| "getSessionId"
 	| "getSettings"
 	| "getTaskBoard"
+	| "userTasks"
+	| "getDecisionBoard"
 	| "getTaskMemoryStatus"
 	| "interop"
 	| "observability"
@@ -46,6 +48,7 @@ export type OverlayLifecycleApplicationDeps = Pick<
 	| "resources"
 	| "session"
 	| "stateDir"
+	| "supersedeDecision"
 	| "toolRegistry"
 	| "writeSettings"
 >;
@@ -94,6 +97,7 @@ export interface OverlayLifecycleRuntimeDeps {
 	openContextOverlay?: typeof import("./context-overlay.js").openContextOverlay;
 	openContextResetOverlay?: typeof import("./overlays/context-reset.js").openContextResetOverlay;
 	openTasksOverlay?: typeof import("./tasks-overlay.js").openTasksOverlay;
+	openDecisionsOverlay?: typeof import("./overlays/decisions.js").openDecisionsOverlay;
 	openMemoryOverlay?: typeof import("./memory-overlay.js").openMemoryOverlay;
 	openViewOverlay?: typeof import("./view/view-overlay.js").openViewOverlay;
 	openHelpOverlay?: typeof import("./overlays/help-reference.js").openHelpOverlay;
@@ -118,6 +122,7 @@ export interface OverlayLifecycleController {
 	openContextResetOverlayState(): void;
 	toggleFooterDashboardState(): void;
 	openTasksOverlayState(): void;
+	openDecisionsOverlayState(): void;
 	openMemoryOverlayState(): void;
 	openViewOverlayState(initialFilter?: string): void;
 	openModelOverlayState(): void;
@@ -169,6 +174,7 @@ export function createOverlayLifecycle(deps: OverlayLifecycleRuntimeDeps): Overl
 		openContextOverlay: openContextOverlayFactory,
 		openContextResetOverlay: openContextResetOverlayFactory,
 		openTasksOverlay: openTasksOverlayFactory,
+		openDecisionsOverlay: openDecisionsOverlayFactory,
 		openMemoryOverlay: openMemoryOverlayFactory,
 		openViewOverlay: openViewOverlayFactory,
 		openHelpOverlay: openHelpOverlayFactory,
@@ -334,6 +340,10 @@ export function createOverlayLifecycle(deps: OverlayLifecycleRuntimeDeps): Overl
 		renderTaskIsland: () => interactiveTickers.renderTaskIsland(),
 		requestRender: () => tui.requestRender(),
 		...(deps.app.getTaskBoard ? { getTaskBoard: deps.app.getTaskBoard } : {}),
+		...(deps.app.userTasks ? { userTasks: deps.app.userTasks } : {}),
+		...(deps.app.getDecisionBoard ? { getDecisionBoard: deps.app.getDecisionBoard } : {}),
+		...(deps.app.supersedeDecision ? { supersedeDecision: deps.app.supersedeDecision } : {}),
+		submitChat: (text) => deps.getSlashContext().submitChat(text),
 		...(deps.app.getTaskMemoryStatus ? { getTaskMemoryStatus: deps.app.getTaskMemoryStatus } : {}),
 		dataDir: deps.app.dataDir,
 		notify,
@@ -350,6 +360,7 @@ export function createOverlayLifecycle(deps: OverlayLifecycleRuntimeDeps): Overl
 		...(openContextOverlayFactory ? { openContextOverlay: openContextOverlayFactory } : {}),
 		...(openContextResetOverlayFactory ? { openContextResetOverlay: openContextResetOverlayFactory } : {}),
 		...(openTasksOverlayFactory ? { openTasksOverlay: openTasksOverlayFactory } : {}),
+		...(openDecisionsOverlayFactory ? { openDecisionsOverlay: openDecisionsOverlayFactory } : {}),
 		...(openMemoryOverlayFactory ? { openMemoryOverlay: openMemoryOverlayFactory } : {}),
 		...(openViewOverlayFactory ? { openViewOverlay: openViewOverlayFactory } : {}),
 	});
@@ -362,6 +373,7 @@ export function createOverlayLifecycle(deps: OverlayLifecycleRuntimeDeps): Overl
 	const openContextResetOverlayState = overlayGeneralOpeners.openContextReset;
 	const toggleFooterDashboardState = overlayGeneralOpeners.toggleFooter;
 	const openTasksOverlayState = overlayGeneralOpeners.openTasks;
+	const openDecisionsOverlayState = overlayGeneralOpeners.openDecisions;
 	const openMemoryOverlayState = overlayGeneralOpeners.openMemory;
 	const openViewOverlayState = overlayGeneralOpeners.openView;
 	const toggleDispatchBoardOverlay = overlayGeneralOpeners.toggleDispatchBoard;
@@ -380,6 +392,7 @@ export function createOverlayLifecycle(deps: OverlayLifecycleRuntimeDeps): Overl
 		openContextResetOverlayState,
 		toggleFooterDashboardState,
 		openTasksOverlayState,
+		openDecisionsOverlayState,
 		openMemoryOverlayState,
 		openViewOverlayState,
 		openModelOverlayState: overlayModelSelectors.openModelOverlayState,

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

@@ -192,6 +192,7 @@ export function createOverlayPermissionLifecycle(deps: OverlayPermissionLifecycl
 	const unsubscribePermission =
 		deps.toolRegistry?.onPermissionRequired((call, decision, meta) => {
 			const autonomy = deps.getAutonomy();
+			const view = mainApprovalRequestView(call, decision, meta, autonomy, deps.toolRegistry?.parkedCount());
 			// The dialog states the tool, the target, the action class, the axis
 			// that asked, and the keys that answer it. While it is on screen the
 			// notice repeats all of that one line above the transcript, so it is
@@ -207,13 +208,13 @@ export function createOverlayPermissionLifecycle(deps: OverlayPermissionLifecycl
 					type: "tool_approval_state",
 					toolCallId: meta.toolCallId,
 					state: "awaiting-approval",
+					view,
 				});
 			}
 			if (deps.getOverlayState() !== "closed") {
 				announceParked();
 				return;
 			}
-			const view = mainApprovalRequestView(call, decision, meta, autonomy, deps.toolRegistry?.parkedCount());
 			if (!deps.openPermissionOverlay(view)) {
 				announceParked();
 				return;

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

@@ -12,6 +12,7 @@ import { openMessagePickerOverlay } from "./overlays/message-picker.js";
 import { openSessionOverlay } from "./overlays/session-selector.js";
 import { openTreeOverlay } from "./overlays/tree-selector.js";
 import { lastTurnSummaryFromLedger } from "./session-last-turn.js";
+import { settleChatBeforeSessionSwitch } from "./session-switch-settlement.js";
 import { reseedSessionUsageFromLedger, type SessionUsageSink } from "./session-usage-reseed.js";
 import type { SlashCommandContext } from "./slash-commands.js";
 import type { TurnSummary } from "./status/index.js";
@@ -20,7 +21,7 @@ export interface OverlaySessionLifecycleDeps {
 	tui: TUI;
 	transitions: OverlayTransitions;
 	session?: SessionContract;
-	chat: Pick<ChatLoop, "resetForSession">;
+	chat: Pick<ChatLoop, "cancel" | "isStreaming" | "resetForSession" | "whenSettled">;
 	chatPanel: ChatPanel;
 	/** The one transcript reset: the panel plus every view folded alongside it. */
 	resetTranscript(): void;
@@ -113,20 +114,58 @@ export function createOverlaySessionLifecycle(deps: OverlaySessionLifecycleDeps)
 		deps.transitions.state = "resume";
 		deps.transitions.handle = openResumeOverlay(deps.tui, {
 			session,
-			onResume: (sessionId) => {
+			onResume: async (sessionId) => {
+				const settlement = settleChatBeforeSessionSwitch(deps.chat);
+				if (settlement) await settlement;
 				deps.onResumeSession?.(sessionId);
+				// onResumeSession (wired to session.resume) catches and stderr-logs
+				// its own failure rather than throwing here, so this is the only
+				// signal available: a successful switch always leaves session.current()
+				// pointing at the requested id. Without this check, a failed switch
+				// still replayed the target's transcript and moved the chat leaf to
+				// it while session.current() stayed on the session the operator
+				// started on (issue #93), so the next message was appended with a
+				// parent turn from a session that was never actually opened.
+				if (session.current()?.id !== sessionId) {
+					emitCommandNotice(
+						deps.getSlashNotice(),
+						"error",
+						"resume",
+						`could not switch to that session; staying on ${preResumeSessionId ?? "no session"}`,
+					);
+					deps.refreshFooter();
+					deps.requestRender();
+					return;
+				}
 				try {
 					const turns = deps.readStructuredEntries(sessionId);
-					deps.resetTranscript();
-					rehydrateChatPanelFromTurns(deps.chatPanel, turns);
-					const replayMessages = buildReplayAgentMessagesFromTurns(turns);
+					// The leaf is read before the transcript is rebuilt because it is
+					// what the rebuild has to follow. resolveLeafOnOpen prefers a
+					// persisted `/tree` pin over the newest turn, so a session resumed
+					// on a pin extends from the pinned turn while the file still holds
+					// the abandoned branch after it. Replaying the file unfiltered
+					// rendered those abandoned turns as ordinary history above the
+					// prompt, disagreeing with the branch the next message parents onto
+					// and with the tip `/tree` marks (issue #107). The `/tree` switch
+					// path below has always scoped its replay to the selected turn;
+					// this is the same active-path filter, rooted at the leaf resume
+					// actually landed on.
 					const leafTurnId = session.tree(sessionId).leafId;
+					// activeLeafTurnId, not uptoTurnId: this is a live branch about to
+					// be extended, so sidecars anchored to a path turn but written
+					// after it (a compaction summary covering the leaf, above all)
+					// still belong on screen. uptoTurnId is the historical-truncation
+					// variant `/tree` uses.
+					const replayOptions = leafTurnId ? { activeLeafTurnId: leafTurnId } : {};
+					deps.resetTranscript();
+					rehydrateChatPanelFromTurns(deps.chatPanel, turns, replayOptions);
+					const replayMessages = buildReplayAgentMessagesFromTurns(turns, replayOptions);
 					deps.chat.resetForSession(leafTurnId, replayMessages);
 					rescopeToBranch(session, turns, leafTurnId);
 				} catch (error) {
 					deps.stderr(`[/resume] transcript replay failed: ${error instanceof Error ? error.message : String(error)}\n`);
 				}
-				if (session.current()?.id === sessionId && sessionId !== preResumeSessionId) {
+				if (sessionId !== preResumeSessionId) {
 					deps.announceTaskMemorySeedOffer();
 				}
 				deps.refreshFooter();
@@ -160,7 +199,9 @@ export function createOverlaySessionLifecycle(deps: OverlaySessionLifecycleDeps)
 		deps.transitions.state = "tree";
 		deps.transitions.handle = openTreeSelector(deps.tui, {
 			session,
-			onSwitchTurn: (turnId) => {
+			onSwitchTurn: async (turnId) => {
+				const settlement = settleChatBeforeSessionSwitch(deps.chat);
+				if (settlement) await settlement;
 				try {
 					session.switchTurn(turnId);
 					const sessionId = session.current()?.id ?? null;
@@ -195,7 +236,8 @@ export function createOverlaySessionLifecycle(deps: OverlaySessionLifecycleDeps)
 			return;
 		}
 		const session = deps.session;
-		if (session.current() === null) {
+		const preForkSessionId = session.current()?.id ?? null;
+		if (preForkSessionId === null) {
 			emitCommandNotice(
 				deps.getSlashNotice(),
 				"warn",
@@ -207,14 +249,29 @@ export function createOverlaySessionLifecycle(deps: OverlaySessionLifecycleDeps)
 		deps.transitions.state = "message-picker";
 		deps.transitions.handle = openMessagePicker(deps.tui, {
 			session,
-			onFork: (parentTurnId) => {
+			onFork: async (parentTurnId) => {
+				const settlement = settleChatBeforeSessionSwitch(deps.chat);
+				if (settlement) await settlement;
 				try {
 					if (deps.onForkSession) deps.onForkSession(parentTurnId);
 					else session.fork(parentTurnId);
-					deps.resetTranscript();
 					const forkedSessionId = session.current()?.id ?? null;
-					if (forkedSessionId) replayFork(forkedSessionId, parentTurnId, session);
-					else deps.chat.resetForSession(null);
+					// A successful fork always creates a fresh session id; landing back
+					// on the id fork started from means the fork threw and
+					// onForkSession swallowed it (orchestrator.ts stderr-logs there).
+					// Do not replay: session.current() did not move (issue #93's
+					// extension.ts/fork.ts ordering fix keeps it on the session the
+					// operator started on instead of orphaning it), so there is
+					// nothing new to replay and doing so anyway just re-renders the
+					// same transcript while hiding that the fork failed.
+					if (forkedSessionId === null || forkedSessionId === preForkSessionId) {
+						emitCommandNotice(deps.getSlashNotice(), "error", "fork", `fork failed; staying on ${preForkSessionId}`);
+						deps.refreshFooter();
+						deps.requestRender();
+						return;
+					}
+					deps.resetTranscript();
+					replayFork(forkedSessionId, parentTurnId, session);
 				} catch (error) {
 					deps.stderr(`[/fork] fork failed: ${error instanceof Error ? error.message : String(error)}\n`);
 				}

package/src/interactive/overlays/decisions.ts

@@ -0,0 +1,300 @@
+import type { DecisionLedgerEntry, DecisionRecord } from "../../domains/session/entries.js";
+import {
+	type Component,
+	Input,
+	matchesKey,
+	type OverlayHandle,
+	type TUI,
+	truncateToWidth,
+	visibleWidth,
+	wrapTextWithAnsi,
+} from "../../engine/tui.js";
+import { buildHint, showClioOverlayFrame } from "../overlay-frame.js";
+import { clioTheme, GLYPH, rule } from "../theme/index.js";
+
+const DEFAULT_CONTENT_WIDTH = 88;
+
+export const DECISIONS_OVERLAY_WIDTH = DEFAULT_CONTENT_WIDTH + 4;
+
+export interface DecisionSelection {
+	interviewId: string;
+	key: string;
+	label: string;
+	value: string;
+}
+
+/** The operator-authored turn that makes a durable correction visible to the model. */
+export function formatDecisionCorrectionTurn(selection: DecisionSelection, correction: string): string {
+	return `Decision "${selection.label}" (previously: ${selection.value}) is superseded by the operator. New direction: ${correction}. Acknowledge and adjust the plan.`;
+}
+
+export interface OpenDecisionsOverlayOptions {
+	onSupersede: (selection: DecisionSelection) => void;
+	onCorrection: (selection: DecisionSelection, correction: string) => void;
+	onClose: () => void;
+	requestRender?: () => void;
+	now?: () => number;
+}
+
+interface SelectableDecision {
+	interview: DecisionLedgerEntry;
+	decision: DecisionRecord;
+}
+
+function fitLine(text: string, width: number): string {
+	const safeWidth = Math.max(1, Math.floor(width));
+	return visibleWidth(text) <= safeWidth ? text : truncateToWidth(text, safeWidth, "…", true);
+}
+
+function relativeTime(timestamp: string, now: number): string {
+	const value = Date.parse(timestamp);
+	if (!Number.isFinite(value)) return "unknown time";
+	const seconds = Math.max(0, Math.floor((now - value) / 1000));
+	if (seconds < 60) return `${seconds}s ago`;
+	const minutes = Math.floor(seconds / 60);
+	if (minutes < 60) return `${minutes}m ago`;
+	const hours = Math.floor(minutes / 60);
+	if (hours < 24) return `${hours}h ago`;
+	return `${Math.floor(hours / 24)}d ago`;
+}
+
+function selectionFor(row: SelectableDecision): DecisionSelection {
+	return {
+		interviewId: row.interview.interviewId,
+		key: row.decision.key,
+		label: row.decision.label ?? row.decision.key,
+		value: row.decision.value,
+	};
+}
+
+function selectableRows(interviews: ReadonlyArray<DecisionLedgerEntry>): SelectableDecision[] {
+	return interviews.flatMap((interview) => interview.decisions.map((decision) => ({ interview, decision })));
+}
+
+function interviewHeader(interview: DecisionLedgerEntry, width: number, now: number): string[] {
+	const theme = clioTheme();
+	const rounds = `${interview.roundCount} round${interview.roundCount === 1 ? "" : "s"}`;
+	const status =
+		interview.interviewStatus === "complete" ? theme.fg("success", "complete") : theme.fg("warning", "cancelled");
+	const heading = `${theme.fg("accent", relativeTime(interview.endedAt, now))}${theme.fg("dim", " · ")}${theme.fg("muted", rounds)}${theme.fg("dim", " · ")}${status}`;
+	const lines = [fitLine(heading, width)];
+	if (interview.summary) {
+		lines.push(...wrapTextWithAnsi(theme.fg("dim", interview.summary), width).map((line) => fitLine(line, width)));
+	}
+	return lines;
+}
+
+function decisionLines(decision: DecisionRecord, selected: boolean, expanded: boolean, width: number): string[] {
+	const theme = clioTheme();
+	const cursor = selected ? theme.fg("accent", GLYPH.cursor) : " ";
+	const status = decision.status === "active" ? theme.fg("success", GLYPH.ok) : theme.fg("dim", GLYPH.cancelled);
+	const labelText = decision.label ?? decision.key;
+	const label = decision.status === "superseded" ? theme.fg("dim", labelText) : theme.fg("muted", labelText);
+	const value = decision.status === "superseded" ? theme.fg("dim", decision.value) : decision.value;
+	const lines = [fitLine(`${cursor} ${status} ${label}${theme.fg("dim", ":")} ${value}`, width)];
+	if (decision.status === "superseded" && decision.correction) {
+		lines.push(fitLine(`      ${theme.fg("dim", "correction")} ${theme.fg("muted", decision.correction)}`, width));
+	}
+	if (selected && expanded) {
+		if (decision.source_question) {
+			lines.push(
+				...wrapTextWithAnsi(`${theme.fg("dim", "question")} ${theme.fg("muted", decision.source_question)}`, width).map(
+					(line) => fitLine(`      ${line}`, width),
+				),
+			);
+		}
+		lines.push(
+			...wrapTextWithAnsi(`${theme.fg("dim", "answer")} ${theme.fg("muted", decision.value)}`, width).map((line) =>
+				fitLine(`      ${line}`, width),
+			),
+		);
+	}
+	return lines;
+}
+
+export function formatDecisionsOverlayBodyLines(
+	interviews: ReadonlyArray<DecisionLedgerEntry>,
+	selectedIndex = 0,
+	expandedKey: string | null = null,
+	contentWidth = DEFAULT_CONTENT_WIDTH,
+	now = Date.now(),
+): string[] {
+	const width = Math.max(1, Math.floor(contentWidth));
+	const theme = clioTheme();
+	if (interviews.length === 0) {
+		return [
+			...wrapTextWithAnsi(theme.fg("muted", "No interview decisions have been recorded on this branch."), width),
+			"",
+			...wrapTextWithAnsi(theme.fg("dim", "Completed and cancelled ask_user interviews appear here."), width),
+		].map((line) => fitLine(line, width));
+	}
+	const selected = selectableRows(interviews)[selectedIndex];
+	const lines: string[] = [];
+	for (let interviewIndex = 0; interviewIndex < interviews.length; interviewIndex += 1) {
+		const interview = interviews[interviewIndex];
+		if (!interview) continue;
+		if (interviewIndex > 0) lines.push(rule(theme, width));
+		lines.push(...interviewHeader(interview, width, now));
+		if (interview.decisions.length === 0) {
+			lines.push(fitLine(`  ${theme.fg("dim", "No compact decisions were recorded.")}`, width));
+			continue;
+		}
+		for (const decision of interview.decisions) {
+			const isSelected =
+				selected?.interview.interviewId === interview.interviewId && selected.decision.key === decision.key;
+			const rowKey = `${interview.interviewId}:${decision.key}`;
+			lines.push(...decisionLines(decision, isSelected, isSelected && expandedKey === rowKey, width));
+		}
+	}
+	return lines;
+}
+
+class DecisionsOverlayBody implements Component {
+	private selectedIndex = 0;
+	private expandedKey: string | null = null;
+	private correctionInput: Input | null = null;
+	private status = "";
+
+	constructor(
+		private readonly getInterviews: () => ReadonlyArray<DecisionLedgerEntry>,
+		private readonly options: OpenDecisionsOverlayOptions,
+	) {}
+
+	render(width: number): string[] {
+		const interviews = this.readInterviews();
+		const rows = selectableRows(interviews);
+		this.selectedIndex = Math.max(0, Math.min(this.selectedIndex, Math.max(0, rows.length - 1)));
+		const body = formatDecisionsOverlayBodyLines(
+			interviews,
+			this.selectedIndex,
+			this.expandedKey,
+			width,
+			this.options.now?.() ?? Date.now(),
+		);
+		if (this.correctionInput) {
+			const theme = clioTheme();
+			body.push("", fitLine(theme.fg("accent", "New direction"), width));
+			body.push(
+				...this.correctionInput
+					.render(Math.max(1, width))
+					.map((line) =>
+						fitLine(line.startsWith("> ") ? `${theme.fg("accent", `${GLYPH.cursor} `)}${line.slice(2)}` : line, width),
+					),
+			);
+		}
+		if (this.status) body.push("", fitLine(clioTheme().fg("warning", this.status), width));
+		return body;
+	}
+
+	handleInput(data: string): void {
+		if (this.correctionInput) {
+			this.correctionInput.handleInput(data);
+			return;
+		}
+		const rows = selectableRows(this.readInterviews());
+		if (matchesKey(data, "esc")) {
+			this.options.onClose();
+			return;
+		}
+		if (rows.length === 0) return;
+		if (matchesKey(data, "up")) {
+			this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+			this.expandedKey = null;
+			this.requestRender();
+			return;
+		}
+		if (matchesKey(data, "down")) {
+			this.selectedIndex = Math.min(rows.length - 1, this.selectedIndex + 1);
+			this.expandedKey = null;
+			this.requestRender();
+			return;
+		}
+		const selected = rows[this.selectedIndex];
+		if (!selected) return;
+		if (matchesKey(data, "enter") || data === "\n") {
+			const key = `${selected.interview.interviewId}:${selected.decision.key}`;
+			this.expandedKey = this.expandedKey === key ? null : key;
+			this.requestRender();
+			return;
+		}
+		if (matchesKey(data, "s")) {
+			try {
+				this.options.onSupersede(selectionFor(selected));
+				this.status = "Decision superseded.";
+			} catch (error) {
+				this.status = error instanceof Error ? error.message : String(error);
+			}
+			this.requestRender();
+			return;
+		}
+		if (matchesKey(data, "c")) this.beginCorrection(selected);
+	}
+
+	invalidate(): void {
+		this.correctionInput?.invalidate();
+	}
+
+	footerHint(): string {
+		return this.correctionInput
+			? buildHint([{ key: "Enter", verb: "submit" }])
+			: buildHint([
+					{ key: "↑↓", verb: "select" },
+					{ key: "Enter", verb: "expand" },
+					{ key: "s", verb: "supersede" },
+					{ key: "c", verb: "correct" },
+				]);
+	}
+
+	private readInterviews(): ReadonlyArray<DecisionLedgerEntry> {
+		try {
+			return this.getInterviews();
+		} catch (error) {
+			this.status = error instanceof Error ? error.message : String(error);
+			return [];
+		}
+	}
+
+	private beginCorrection(selected: SelectableDecision): void {
+		const input = new Input();
+		input.onSubmit = (value) => {
+			const correction = value.trim();
+			if (correction.length === 0) {
+				this.status = "Enter the operator's new direction.";
+				this.requestRender();
+				return;
+			}
+			try {
+				this.options.onCorrection(selectionFor(selected), correction);
+			} catch (error) {
+				this.status = error instanceof Error ? error.message : String(error);
+				this.requestRender();
+			}
+		};
+		input.onEscape = () => this.options.onClose();
+		this.correctionInput = input;
+		this.status = "";
+		this.requestRender();
+	}
+
+	private requestRender(): void {
+		this.options.requestRender?.();
+	}
+}
+
+/** Mount the settled interview decision board. */
+export function openDecisionsOverlay(
+	tui: TUI,
+	getInterviews: () => ReadonlyArray<DecisionLedgerEntry>,
+	options: OpenDecisionsOverlayOptions,
+): OverlayHandle {
+	const body = new DecisionsOverlayBody(getInterviews, {
+		...options,
+		requestRender: options.requestRender ?? (() => tui.requestRender()),
+	});
+	return showClioOverlayFrame(tui, body, {
+		anchor: "center",
+		width: DECISIONS_OVERLAY_WIDTH,
+		title: () => "Decisions",
+		footerHint: () => body.footerHint(),
+	});
+}