@iowarp/clio-coder 0.3.3 → 0.3.6

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

@@ -1,5 +1,6 @@
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
+import { BusChannels } from "../core/bus-events.js";
 import type { ClioSettings } from "../core/config.js";
 import type { SafeEventBus } from "../core/event-bus.js";
 import type { PendingSkillRequest } from "../core/skill-activation.js";
@@ -28,6 +29,7 @@ import { type ChatPanel, createChatPanel } from "./chat-panel.js";
 import { rehydrateChatPanelFromTurns } from "./chat-renderer.js";
 import { runCompactWithNotice } from "./command-fallbacks.js";
 import { appendNotice, appendOperatorCommand } from "./command-output.js";
+import { runOperatorRecall } from "./context-recall-command.js";
 import { renderSessionHtml } from "./export-html/index.js";
 import { dateLocal } from "./format-time.js";
 import type { SettingsCenterRowId, SettingsSectionId } from "./overlays/settings.js";
@@ -100,8 +102,10 @@ export interface InteractiveSlashRuntimeDeps {
 	 * Leaf lookup for `/export`, so the export follows the branch the session
 	 * is actually on. current.jsonl still holds the abandoned turns after a
 	 * `/tree` pin, and an unscoped rehydrate reproduced them (issue #109).
+	 * `/context recall` uses the same leaf for its fold, plus `appendEntry` for
+	 * the `contextRecall` record.
 	 */
-	session?: Pick<SessionContract, "tree">;
+	session?: Pick<SessionContract, "tree" | "current" | "appendEntry">;
 	expandSubmit: (text: string) => Promise<InteractiveSlashSubmitExpansion>;
 	openAskUser: AskUserHandler;
 	openSkillsHub: () => void;
@@ -512,6 +516,38 @@ export function createInteractiveSlashRuntime(deps: InteractiveSlashRuntimeDeps)
 			}
 			deps.openContextReset();
 		},
+		...(deps.session
+			? {
+					runContextRecall: (ref: string) => {
+						const session = deps.session;
+						if (!session) return;
+						const outcome = runOperatorRecall(ref, {
+							hasSession: () => session.current() !== null,
+							readEntries: () => {
+								const sessionId = deps.chat.getSessionId();
+								return sessionId ? deps.readStructuredEntries(sessionId) : [];
+							},
+							activeLeafTurnId: () => {
+								const meta = session.current();
+								return meta ? (session.tree(meta.id).leafId ?? undefined) : undefined;
+							},
+							appendEntry: (entry) => session.appendEntry(entry),
+							onRecalled: (payload) => deps.bus.emit(BusChannels.ContextRecalled, payload),
+							...(deps.now ? { now: () => (deps.now?.() ?? new Date()).getTime() } : {}),
+						});
+						if (!outcome.ok) {
+							appendCommandNotice("error", outcome.message);
+							return;
+						}
+						appendCommandNotice("success", outcome.headline);
+						// The body is transcript output, not a notice: notices collapse
+						// newlines, and a recalled build log is worth nothing on one line.
+						// It is a replay block either way, so it never enters model context.
+						deps.io.stdout(`${outcome.body}\n`);
+						deps.requestRender();
+					},
+				}
+			: {}),
 		runContextRefresh: () => {
 			if (!deps.onContextRefresh) {
 				deps.io.stderr("[/context refresh] context refresh not wired; pass onContextRefresh to startInteractive\n");

package/src/interactive/memory-overlay.ts

@@ -1,5 +1,6 @@
 import {
 	describeTaskMemoryActivity,
+	type MemoryProposalResult,
 	type MemoryRecord,
 	type TaskMemoryActivityEvent,
 	type TaskMemoryEntry,
@@ -182,6 +183,7 @@ function memorySignature(status: TaskMemoryOperatorStatus, records: ReadonlyArra
 
 interface OpenMemoryOverlayOptions {
 	onClose?: () => void;
+	onPromote?: (entry: TaskMemoryEntry, scope: "repo" | "global") => Promise<MemoryProposalResult>;
 }
 
 /** Master-detail memory view: status header, grouped list, scrollable detail pane. */
@@ -189,12 +191,18 @@ export class MemoryOverlayView implements Component {
 	private readonly list: ListOverlayView;
 	private signature: string | null = null;
 	private renderMemo: { width: number; status: string; listLines: string[]; lines: string[] } | null = null;
+	private pendingGlobalEntryId: string | null = null;
+	private promotionMessage: { token: "muted" | "warning" | "success" | "error"; text: string } | null = null;
+	private promotionInFlight = false;
 
 	constructor(
 		private readonly getStatus: () => TaskMemoryOperatorStatus,
 		private readonly getRecords: () => ReadonlyArray<MemoryRecord>,
 		onClose: () => void,
 		onChange: () => void,
+		private readonly promotion?: {
+			onPromote: (entry: TaskMemoryEntry, scope: "repo" | "global") => Promise<MemoryProposalResult>;
+		},
 	) {
 		this.list = new ListOverlayView(
 			{
@@ -203,6 +211,18 @@ export class MemoryOverlayView implements Component {
 				filterable: true,
 				layout: "split",
 				emptyMessage: EMPTY_MESSAGE,
+				...(promotion
+					? {
+							hints: [
+								{ key: "p", verb: "propose repo" },
+								{ key: "g", verb: "propose global" },
+							],
+							actions: {
+								p: (item: ListOverlayItem) => this.promote(item, "repo", onChange),
+								g: (item: ListOverlayItem) => this.promote(item, "global", onChange),
+							},
+						}
+					: {}),
 				onClose,
 			},
 			onChange,
@@ -217,11 +237,21 @@ export class MemoryOverlayView implements Component {
 	render(width: number): string[] {
 		const status = this.sync();
 		const statusLine = formatMemoryStatusLine(status, width);
+		const promotionLine =
+			this.promotionMessage === null
+				? null
+				: fitUnits(clioTheme(), "", [clioTheme().fg(this.promotionMessage.token, this.promotionMessage.text)], width);
+		const statusKey = promotionLine === null ? statusLine : `${statusLine}\n${promotionLine}`;
 		const listLines = this.list.render(width);
 		const memo = this.renderMemo;
-		if (memo && memo.width === width && memo.status === statusLine && memo.listLines === listLines) return memo.lines;
-		const lines = [statusLine, rule(clioTheme(), width), ...listLines];
-		this.renderMemo = { width, status: statusLine, listLines, lines };
+		if (memo && memo.width === width && memo.status === statusKey && memo.listLines === listLines) return memo.lines;
+		const lines = [
+			statusLine,
+			...(promotionLine === null ? [] : [promotionLine]),
+			rule(clioTheme(), width),
+			...listLines,
+		];
+		this.renderMemo = { width, status: statusKey, listLines, lines };
 		return lines;
 	}
 
@@ -247,9 +277,63 @@ export class MemoryOverlayView implements Component {
 		}
 		return status;
 	}
+
+	private promote(item: ListOverlayItem, scope: "repo" | "global", onChange: () => void): void {
+		if (this.promotion === undefined || this.promotionInFlight) return;
+		const entry = this.selectedBankEntry(item);
+		if (entry === null) {
+			this.pendingGlobalEntryId = null;
+			this.promotionMessage = { token: "warning", text: "select a knowledge or procedural task-bank entry" };
+			this.invalidate();
+			onChange();
+			return;
+		}
+		if (scope === "global" && this.pendingGlobalEntryId !== entry.id) {
+			this.pendingGlobalEntryId = entry.id;
+			this.promotionMessage = {
+				token: "warning",
+				text: `global scope broadens applicability for ${entry.id}; press g again to acknowledge`,
+			};
+			this.invalidate();
+			onChange();
+			return;
+		}
+		this.pendingGlobalEntryId = null;
+		this.promotionInFlight = true;
+		this.promotionMessage = { token: "muted", text: `proposing ${entry.id} with ${scope} scope` };
+		this.invalidate();
+		onChange();
+		void this.promotion
+			.onPromote(entry, scope)
+			.then((result) => {
+				this.promotionMessage = {
+					token: "success",
+					text: `${result.created ? "proposed" : "found existing"} ${result.record.id}; review, then run clio-coder memory approve ${result.record.id}`,
+				};
+			})
+			.catch((error: unknown) => {
+				this.promotionMessage = {
+					token: "error",
+					text: `promotion failed: ${error instanceof Error ? error.message : String(error)}`,
+				};
+			})
+			.finally(() => {
+				this.promotionInFlight = false;
+				this.invalidate();
+				onChange();
+			});
+	}
+
+	private selectedBankEntry(item: ListOverlayItem): TaskMemoryEntry | null {
+		if (!item.id.startsWith("bank:")) return null;
+		const entryId = item.id.slice("bank:".length);
+		const entry = bankEntries(this.getStatus().bank).find((candidate) => candidate.id === entryId);
+		if (entry === undefined || entry.kind === "status") return null;
+		return entry;
+	}
 }
 
-/** Mount the read-only durable-lessons and live task-bank view. */
+/** Mount durable lessons and the live task bank with reviewed promotion actions. */
 export function openMemoryOverlay(
 	tui: TUI,
 	getStatus: () => TaskMemoryOperatorStatus,
@@ -261,6 +345,7 @@ export function openMemoryOverlay(
 		getRecords,
 		() => options.onClose?.(),
 		() => tui.requestRender(),
+		options.onPromote ? { onPromote: options.onPromote } : undefined,
 	);
 	const handle = showClioOverlayFrame(tui, view, {
 		anchor: "center",

package/src/interactive/model-session-replay.ts

@@ -0,0 +1,21 @@
+import { foldWorkingSet } from "../domains/context/working-set/fold.js";
+import { projectWorkingSet } from "../domains/context/working-set/project.js";
+import type { SessionEntry } from "../domains/session/entries.js";
+import type { AgentMessage } from "../engine/types.js";
+import { buildReplayAgentMessagesFromTurns, type RehydrateChatPanelOptions } from "./chat-renderer.js";
+
+/**
+ * Build provider-facing replay messages from the durable session ledger.
+ * Projection always honors existing eviction and recall entries; the enabled
+ * setting gates creation of new evictions, not replay of durable state.
+ * Visible transcript and export callers intentionally keep using the raw
+ * rehydration helpers so eviction remains a model projection, not data loss.
+ */
+export function buildModelReplayAgentMessagesFromTurns(
+	entries: ReadonlyArray<SessionEntry>,
+	options: RehydrateChatPanelOptions = {},
+): AgentMessage[] {
+	const activeLeafTurnId = options.activeLeafTurnId ?? options.uptoTurnId;
+	const projected = projectWorkingSet(entries, foldWorkingSet(entries, activeLeafTurnId));
+	return buildReplayAgentMessagesFromTurns(projected, options);
+}

package/src/interactive/overlay-ask-user-lifecycle.ts

@@ -77,7 +77,7 @@ export function createOverlayAskUserLifecycle(deps: OverlayAskUserLifecycleDeps)
 		const activeSession = ensureSession();
 		if (!activeSession) return cancelledAskUserResult();
 		pendingCancel = cancel;
-		const result = await activeSession.ask(questions);
+		const result = await activeSession.ask(questions, invokeOptions?.decisionPresentation);
 		if (result.cancelled === true || !toolBacked) {
 			if (result.cancelled === true) cancelledForTurn = true;
 			close();

package/src/interactive/overlay-frame.ts

@@ -478,16 +478,19 @@ export function showClioOverlayFrame(
 	const { title, footerHint, tone, width, visible, maxHeight, margin, ...overlayOptions } = options;
 	const boxWidth = typeof width === "number" ? width : 0;
 	const frame = new ClioOverlayFrame(child, title, footerHint, boxWidth, frameAlignForAnchor(options.anchor), tone);
-	const marginRows = typeof margin === "number" ? margin * 2 : (margin?.top ?? 0) + (margin?.bottom ?? 0);
 	return tui.showOverlay(frame, {
 		...overlayOptions,
 		...(margin !== undefined ? { margin } : {}),
 		width: "100%",
 		visible: (termWidth, termHeight) => {
+			const shown = visible ? visible(termWidth, termHeight) : true;
+			// A caller may update an object margin in its visibility callback to
+			// follow live content geometry. Read it after that callback, every frame.
+			const marginRows = typeof margin === "number" ? margin * 2 : (margin?.top ?? 0) + (margin?.bottom ?? 0);
 			const available = Math.max(1, termHeight - marginRows);
 			const requested = resolveRowSize(maxHeight, termHeight);
 			frame.setRowBudget(requested === null ? available : Math.min(requested, available));
-			return visible ? visible(termWidth, termHeight) : true;
+			return shown;
 		},
 	});
 }

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

@@ -1,6 +1,13 @@
+import type { ClioSettings } from "../core/config.js";
 import type { SafeEventBus } from "../core/event-bus.js";
+import { foldWorkingSet } from "../domains/context/working-set/fold.js";
 import type { DispatchContract } from "../domains/dispatch/index.js";
-import { loadMemoryRecordsSync, type MemoryRecord } from "../domains/memory/index.js";
+import {
+	canonicalMemoryRepositoryIdentity,
+	loadMemoryRecordsSync,
+	type MemoryRecord,
+	proposeMemoryPromotion,
+} from "../domains/memory/index.js";
 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";
@@ -56,6 +63,8 @@ export interface OverlayGeneralOpenersDeps {
 	stateDir: string;
 	getSessionMeta: () => SessionMeta | null;
 	readSessionEntries?: ArtifactProviderDeps["readSessionEntries"];
+	/** Live settings, so `/context` can state the configured working-set policy. */
+	getSettings?: () => Readonly<ClioSettings>;
 	terminal: { columns: number };
 	dispatchBoard: ReturnType<typeof createDispatchBoardView>;
 	startDispatchBoardTicker: () => void;
@@ -107,6 +116,15 @@ export function createOverlayGeneralOpeners(deps: OverlayGeneralOpenersDeps): Ov
 		deps.transitions.handle = openContextOverlayFactory(deps.tui, deps.getContextLedger, {
 			bus: deps.bus,
 			chat: deps.contextChat,
+			getWorkingSet: () => {
+				const readSessionEntries = deps.readSessionEntries;
+				if (!readSessionEntries) return null;
+				return foldWorkingSet(readSessionEntries(), deps.getSessionMeta()?.pinnedLeafTurnId ?? undefined);
+			},
+			getWorkingSetConfig: () => {
+				const workingSet = deps.getSettings?.().context.workingSet;
+				return workingSet ? { enabled: workingSet.enabled, policy: workingSet.policy } : null;
+			},
 		});
 		deps.requestRender();
 	};
@@ -212,6 +230,32 @@ export function createOverlayGeneralOpeners(deps: OverlayGeneralOpenersDeps): Ov
 		deps.transitions.state = "memory";
 		deps.transitions.handle = openMemoryOverlayFactory(deps.tui, deps.getTaskMemoryStatus, () => records, {
 			onClose: deps.closeOverlay,
+			onPromote: async (entry, scope) => {
+				const meta = deps.getSessionMeta();
+				if (!meta) throw new Error("memory promotion requires an active session");
+				const selection =
+					scope === "global"
+						? ({ scope: "global", acknowledgeGlobal: true } as const)
+						: (() => {
+								const repository = canonicalMemoryRepositoryIdentity(meta.cwd);
+								if (repository === null) {
+									throw new Error("repo promotion requires a canonical active repository identity");
+								}
+								return { scope: "repo", repository } as const;
+							})();
+				const result = await proposeMemoryPromotion(
+					deps.dataDir,
+					{
+						kind: "task-bank-entry",
+						sessionId: meta.id,
+						evidenceRefs: [`session-${meta.id}`],
+						entry,
+					},
+					selection,
+				);
+				records = loadMemoryRecordsSync(deps.dataDir);
+				return result;
+			},
 		});
 		deps.requestRender();
 	};
@@ -255,6 +299,7 @@ export function createOverlayGeneralOpeners(deps: OverlayGeneralOpenersDeps): Ov
 	const dispatchBoardHint = (): string => {
 		const row = deps.dispatchBoard.selectedRow();
 		const entries = [{ key: "↑↓", verb: "select" }];
+		if (row) entries.push({ key: "Enter", verb: deps.dispatchBoard.detailExpanded() ? "hide detail" : "detail" });
 		if (row && isDispatchBoardRowSteerable(row)) entries.push({ key: "s", verb: "steer" });
 		if (row && isDispatchBoardRowCancellable(row)) entries.push({ key: "x", verb: "cancel" });
 		return buildHint(entries);

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

@@ -31,6 +31,19 @@ export interface PermissionOverlayKeyDeps {
 	cancelPermission: () => void;
 	confirmPermission: () => void;
 	stopTurnFromPermission: () => void;
+	/**
+	 * Whether the composer holds text. Enter must not allow a parked call while
+	 * it does (issue #186): an operator who typed a message and pressed the
+	 * habitual send key meant to send, and on a safety rail the ambiguous key
+	 * resolves away from "allow". Absent means an empty composer.
+	 */
+	composerHasDraft?: () => boolean;
+	/**
+	 * Deliver a draft-editing key to the composer while the prompt owns input,
+	 * so the draft that makes Enter inert can be cleared without first denying
+	 * the call. Only the deletion keys in `isDraftEditKey` arrive here.
+	 */
+	editDraft?: (data: string) => void;
 }
 
 export interface DispatchBoardOverlayKeyDeps {
@@ -39,6 +52,8 @@ export interface DispatchBoardOverlayKeyDeps {
 	selectNextDispatch: () => void;
 	steerSelectedDispatch: () => void;
 	cancelSelectedDispatch: () => void;
+	/** Open or close the selected run's worker-progress detail. */
+	toggleSelectedDispatchDetail: () => void;
 }
 
 interface CloseOverlayKeyDeps {
@@ -55,10 +70,29 @@ export function isEscapeKey(data: string): boolean {
 	return matchesKey(data, "escape") && !isKeyRelease(data);
 }
 
+const DRAFT_EDIT_KEYS = ["backspace", "delete", "ctrl+u", "ctrl+w", "alt+backspace", "ctrl+k"] as const;
+
+/**
+ * The keys that only ever remove text from the composer. They are the one
+ * class of input a pending permission prompt lets through, because they
+ * cannot type a command, cannot submit, and are the way out of the inert-Enter
+ * state a draft puts the prompt in.
+ */
+function isDraftEditKey(data: string): boolean {
+	return !isKeyRelease(data) && DRAFT_EDIT_KEYS.some((key) => matchesKey(data, key));
+}
+
 /** Pure permission overlay key router: returns true when the input was consumed. */
 export function routePermissionOverlayKey(data: string, deps: PermissionOverlayKeyDeps): boolean {
 	if (matchesKey(data, "enter") && !isKeyRelease(data)) {
-		deps.confirmPermission();
+		// Consumed either way: with a draft the press changes nothing, and the
+		// composer rail says what clears it. Letting it fall through would hand
+		// Enter to the editor, which is the send path this guard exists to block.
+		if (!(deps.composerHasDraft?.() ?? false)) deps.confirmPermission();
+		return true;
+	}
+	if (deps.editDraft && isDraftEditKey(data)) {
+		deps.editDraft(data);
 		return true;
 	}
 	if (isEscapeKey(data)) {
@@ -98,6 +132,12 @@ export function routeDispatchBoardOverlayKey(data: string, deps: DispatchBoardOv
 		deps.cancelSelectedDispatch();
 		return true;
 	}
+	// Worker progress is expanded detail the operator asks for. The default list
+	// stays compact so a fan-out of scouts costs one card each.
+	if (matchesKey(data, "enter")) {
+		deps.toggleSelectedDispatchDetail();
+		return true;
+	}
 	return false;
 }
 

package/src/interactive/overlay-lifecycle.ts

@@ -12,7 +12,9 @@ import {
 	createPermissionOverlayBody,
 	PERMISSION_OVERLAY_WIDTH,
 	permissionOverlayHint,
+	permissionOverlayPlacement,
 	permissionOverlayTitle,
+	permissionOverlayTone,
 } from "./permission-overlay.js";
 
 export * from "./overlay-key-routing.js";
@@ -82,7 +84,7 @@ export interface OverlayLifecycleRuntimeDeps {
 	/** Rescopes the footer's last-turn line when a session overlay changes the branch. */
 	setLastTurnSummary?: (summary: import("./status/index.js").TurnSummary | null) => void;
 	keybindings: ReturnType<typeof import("./keybinding-manager.js").createKeybindingManager>;
-	editor: Pick<import("./clio-editor.js").ClioEditor, "getText" | "setText">;
+	editor: Pick<import("./clio-editor.js").ClioEditor, "getText" | "render" | "setText">;
 	getSlashContext: () => import("./slash-commands.js").SlashCommandContext;
 	showOverlayFrame?: typeof showClioOverlayFrame;
 	openAuthDialog?: typeof import("./overlays/auth-dialog.js").openAuthDialog;
@@ -194,6 +196,7 @@ export function createOverlayLifecycle(deps: OverlayLifecycleRuntimeDeps): Overl
 		cancelPendingAskUser: () => overlayAskUser?.cancelPending() ?? false,
 		finishAuth: (dismiss) => overlayAuth.finish(dismiss),
 		onPermissionOverlayClosed: () => overlayPermission?.onPermissionOverlayClosed(),
+		onOverlayClosed: () => overlayPermission?.retryPending(),
 	});
 	const closeOverlay = overlayTransitions.close;
 
@@ -227,10 +230,13 @@ export function createOverlayLifecycle(deps: OverlayLifecycleRuntimeDeps): Overl
 			if (overlayTransitions.state !== "closed") return false;
 			overlayTransitions.state = "permission-confirm";
 			overlayTransitions.handle = showOverlayFrame(tui, createPermissionOverlayBody(view), {
-				anchor: "center",
+				...permissionOverlayPlacement(tui, editor, footer.view),
 				width: PERMISSION_OVERLAY_WIDTH,
-				title: permissionOverlayTitle(),
-				footerHint: (innerWidth) => permissionOverlayHint(innerWidth),
+				title: permissionOverlayTitle(view),
+				tone: permissionOverlayTone(view),
+				// Read per frame: the footer names what Enter does right now, and
+				// that depends on whether the composer holds a draft.
+				footerHint: (innerWidth) => permissionOverlayHint(innerWidth, editor.getText().length > 0),
 			});
 			tui.requestRender();
 			return true;
@@ -351,6 +357,7 @@ export function createOverlayLifecycle(deps: OverlayLifecycleRuntimeDeps): Overl
 		stateDir: deps.app.stateDir,
 		getSessionMeta: () => deps.app.session?.current() ?? null,
 		...(deps.app.readSessionEntries ? { readSessionEntries: deps.app.readSessionEntries } : {}),
+		...(deps.app.getSettings ? { getSettings: deps.app.getSettings } : {}),
 		terminal,
 		dispatchBoard,
 		startDispatchBoardTicker: () => interactiveTickers.startDispatchBoardTicker(),

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

@@ -2,9 +2,11 @@ import { BusChannels, type PermissionRequestedPayload } from "../core/bus-events
 import type { SafeEventBus } from "../core/event-bus.js";
 import { ToolNames } from "../core/tool-names.js";
 import type { DispatchContract } from "../domains/dispatch/contract.js";
-import type { ClassifierCall } from "../domains/safety/action-classifier.js";
+import type { ActionClass, ClassifierCall } from "../domains/safety/action-classifier.js";
 import { sanitizeCallTargetText } from "../domains/safety/call-target.js";
 import type { SafetyDecision } from "../domains/safety/contract.js";
+import { decisionActionClass } from "../domains/safety/decision-presentation.js";
+import { askUserExposure } from "../tools/ask-user.js";
 import type { PermissionRequiredMeta, ToolRegistry } from "../tools/registry.js";
 import { approvalParkedNotice, autonomyDeniedNotice, workerEscalationNotice } from "./bus-notices.js";
 import type { ToolApprovalStateEvent } from "./chat-loop.js";
@@ -29,7 +31,7 @@ interface WorkerEscalationEntry {
 	requestId: string;
 	agentId: string;
 	tool: string;
-	actionClass: string;
+	actionClass: ActionClass;
 	axis: ApprovalRequestView["axis"];
 	reason: string;
 	target?: string;
@@ -60,6 +62,14 @@ export interface OverlayPermissionLifecycle {
 	 */
 	stopTurn(): void;
 	onPermissionOverlayClosed(): void;
+	/**
+	 * Re-present whatever is still parked once no overlay holds the screen. A
+	 * request that arrived while `/context` or a picker was open could only be
+	 * announced, and nothing re-attempted the dialog when that overlay closed:
+	 * the transcript said awaiting approval, the footer said confirm, and the
+	 * operator had no key to press (issue #186).
+	 */
+	retryPending(): void;
 	dispose(): void;
 }
 
@@ -114,7 +124,7 @@ function mainApprovalRequestView(
 		(axisFromDecision.kind === "net"
 			? { kind: "net" as const, ruleId: axisFromDecision.ruleId }
 			: { kind: "autonomy" as const, level: autonomy });
-	const target = describeCallTarget(call.args);
+	const target = describeCallTarget(call.tool, call.args);
 	return {
 		requestId: meta?.requestId ?? "permission-pending",
 		tool: call.tool,
@@ -126,6 +136,7 @@ function mainApprovalRequestView(
 		...(call.tool === ToolNames.Dispatch && decision.kind === "ask"
 			? { artifact: { kind: "dispatch-plan" as const, text: decision.rejection.detail } }
 			: {}),
+		...(call.tool === ToolNames.AskUser ? { exposure: askUserExposure(call.args) } : {}),
 		...(target.length > 0 ? { target } : {}),
 		...(queueDepth !== undefined && queueDepth > 1 ? { queueDepth } : {}),
 	};
@@ -141,7 +152,7 @@ function workerEscalationEntry(payload: PermissionRequestedPayload, autonomy: st
 		requestId: payload.requestId,
 		agentId: typeof payload.agentId === "string" ? payload.agentId : "worker",
 		tool: typeof payload.tool === "string" ? payload.tool : "unknown",
-		actionClass: typeof payload.actionClass === "string" ? payload.actionClass : "unknown",
+		actionClass: decisionActionClass(payload.actionClass),
 		axis:
 			axisViewFromId(typeof payload.axis === "string" ? payload.axis : undefined, autonomy) ??
 			(typeof payload.ruleId === "string"
@@ -188,6 +199,12 @@ export function createOverlayPermissionLifecycle(deps: OverlayPermissionLifecycl
 		const next = workerQueue.shift();
 		if (next) openWorker(next);
 	};
+	const retryPending = (): void => {
+		maybeOpenWorker();
+		if (deps.getOverlayState() === "closed" && deps.toolRegistry?.hasParkedCalls()) {
+			deps.toolRegistry.renotifyHead();
+		}
+	};
 
 	const unsubscribePermission =
 		deps.toolRegistry?.onPermissionRequired((call, decision, meta) => {
@@ -310,10 +327,7 @@ export function createOverlayPermissionLifecycle(deps: OverlayPermissionLifecycl
 			workerQueue.length = 0;
 			return;
 		}
-		maybeOpenWorker();
-		if (deps.getOverlayState() === "closed" && deps.toolRegistry?.hasParkedCalls()) {
-			deps.toolRegistry.renotifyHead();
-		}
+		retryPending();
 	};
 
 	return {
@@ -336,6 +350,7 @@ export function createOverlayPermissionLifecycle(deps: OverlayPermissionLifecycl
 			);
 		},
 		onPermissionOverlayClosed,
+		retryPending,
 		dispose: () => {
 			unsubscribePermission();
 			unsubscribeWorker();

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

@@ -3,9 +3,10 @@ import type { SessionContract, SessionEntry } from "../domains/session/index.js"
 import type { TUI } from "../engine/tui.js";
 import type { ChatLoop } from "./chat-loop.js";
 import type { ChatPanel } from "./chat-panel.js";
-import { buildReplayAgentMessagesFromTurns, rehydrateChatPanelFromTurns } from "./chat-renderer.js";
+import { rehydrateChatPanelFromTurns } from "./chat-renderer.js";
 import { emitCommandNotice } from "./command-fallbacks.js";
 import type { InteractiveNoticeLevel } from "./interactive-subscriptions.js";
+import { buildModelReplayAgentMessagesFromTurns } from "./model-session-replay.js";
 import type { OverlayTransitions } from "./overlay-transitions.js";
 import { openCwdFallbackOverlay } from "./overlays/cwd-fallback.js";
 import { openMessagePickerOverlay } from "./overlays/message-picker.js";
@@ -159,7 +160,7 @@ export function createOverlaySessionLifecycle(deps: OverlaySessionLifecycleDeps)
 					const replayOptions = leafTurnId ? { activeLeafTurnId: leafTurnId } : {};
 					deps.resetTranscript();
 					rehydrateChatPanelFromTurns(deps.chatPanel, turns, replayOptions);
-					const replayMessages = buildReplayAgentMessagesFromTurns(turns, replayOptions);
+					const replayMessages = buildModelReplayAgentMessagesFromTurns(turns, replayOptions);
 					deps.chat.resetForSession(leafTurnId, replayMessages);
 					rescopeToBranch(session, turns, leafTurnId);
 				} catch (error) {
@@ -209,7 +210,7 @@ export function createOverlaySessionLifecycle(deps: OverlaySessionLifecycleDeps)
 					const turns = deps.readStructuredEntries(sessionId);
 					deps.resetTranscript();
 					rehydrateChatPanelFromTurns(deps.chatPanel, turns, { uptoTurnId: turnId });
-					const replayMessages = buildReplayAgentMessagesFromTurns(turns, { uptoTurnId: turnId });
+					const replayMessages = buildModelReplayAgentMessagesFromTurns(turns, { uptoTurnId: turnId });
 					deps.chat.resetForSession(turnId, replayMessages);
 					// The same branch the transcript above was just scoped to. Without the
 					// leaf, /cost, the footer Σ, and the last-turn line kept reporting the
@@ -287,8 +288,11 @@ export function createOverlaySessionLifecycle(deps: OverlaySessionLifecycleDeps)
 		try {
 			const turns = deps.readStructuredEntries(forkedSessionId);
 			rehydrateChatPanelFromTurns(deps.chatPanel, turns);
-			const replayMessages = buildReplayAgentMessagesFromTurns(turns);
 			const leafTurnId = session.tree(forkedSessionId).leafId ?? parentTurnId;
+			const replayMessages = buildModelReplayAgentMessagesFromTurns(
+				turns,
+				leafTurnId ? { activeLeafTurnId: leafTurnId } : {},
+			);
 			deps.chat.resetForSession(leafTurnId, replayMessages);
 			rescopeToBranch(session, turns, leafTurnId);
 		} catch (error) {

package/src/interactive/overlay-transitions.ts

@@ -9,6 +9,12 @@ export interface OverlayTransitionsDeps {
 	cancelPendingAskUser: () => boolean;
 	finishAuth: (dismiss: boolean) => void;
 	onPermissionOverlayClosed: () => void;
+	/**
+	 * Runs after any overlay has closed and the state is back to `closed`. The
+	 * permission lifecycle uses it to re-present a call that parked while this
+	 * overlay held the screen; nothing else re-attempts that dialog.
+	 */
+	onOverlayClosed?: () => void;
 }
 
 export interface OverlayTransitions {
@@ -26,7 +32,11 @@ export function createOverlayTransitions(deps: OverlayTransitionsDeps): OverlayT
 			return state;
 		},
 		set state(next) {
+			const closing = state !== "closed" && next === "closed";
 			state = next;
+			// The ask-user and auth lifecycles leave by assigning the state rather
+			// than through `close`, so the hook fires here for them.
+			if (closing) deps.onOverlayClosed?.();
 		},
 		get handle() {
 			return handle;
@@ -50,6 +60,7 @@ export function createOverlayTransitions(deps: OverlayTransitionsDeps): OverlayT
 		handle?.hide();
 		handle = null;
 		if (leaving === "permission-confirm") deps.onPermissionOverlayClosed();
+		else deps.onOverlayClosed?.();
 		deps.renderContextIsland();
 		deps.renderTaskIsland();
 		deps.requestRender();