@iowarp/clio-coder 0.4.6 → 0.4.7

package/src/engine/worker-tools.ts

@@ -1,3 +1,4 @@
+import type { WorkerRecall } from "../domains/context/worker/recall.js";
 /**
  * Worker-subprocess tool construction.
  *
@@ -29,6 +30,7 @@ import {
 import { CONFIRMED_SCOPE, isSubset, READONLY_SCOPE, WORKSPACE_SCOPE } from "../domains/safety/scope.js";
 import { effectiveToolNames } from "../tools/agent-tools.js";
 import { assertRegisteredBuiltinTools, registerCoreTools } from "../tools/core-bootstrap.js";
+import { registerHarnessExtensionTools } from "../tools/harness-extensions.js";
 import type { ToolProfileName } from "../tools/profiles.js";
 import { createRegistry, type RegistryDeps, type ToolRegistry } from "../tools/registry.js";
 import { type AgentLedgerPort, toolSignatureOf } from "../worker/protocol.js";
@@ -139,6 +141,7 @@ export function createWorkerToolRegistry(
 	autonomy?: AutonomyLevel,
 	onMiddlewareEffects?: RegistryDeps["onMiddlewareEffects"],
 	agentLedger?: AgentLedgerPort,
+	workerRecall?: WorkerRecall,
 ): ToolRegistry {
 	// A worker always gets a middleware contract, even without a snapshot from
 	// the orchestrator, because the loop guard rides on it as a before_tool
@@ -163,6 +166,7 @@ export function createWorkerToolRegistry(
 	// is what keeps that true now that the session registry omits the tool.
 	const registration = registerCoreTools(registry, {
 		includeLedgerTools: true,
+		...(workerRecall ? { workerRecall } : {}),
 		...(agentLedger ? { agentLedger } : {}),
 		// A worker cannot install a skill or reach the operator who could, so
 		// its skill listing carries installed (or bound) skills only; the
@@ -177,6 +181,7 @@ export function createWorkerToolRegistry(
 		}),
 	});
 	assertRegisteredBuiltinTools(registry, registration, false);
+	registerHarnessExtensionTools(registry);
 	return registry;
 }
 

package/src/entry/orchestrator.ts

@@ -108,6 +108,7 @@ import type { BackgroundMemoryUsageSink } from "../domains/observability/backgro
 import { recordFailedCompactionCalls } from "../domains/observability/compaction-usage.js";
 import type { ObservabilityContract } from "../domains/observability/index.js";
 import { ObservabilityDomainModule } from "../domains/observability/index.js";
+import { PluginsDomainModule } from "../domains/plugins/index.js";
 import type { PromptsContract } from "../domains/prompts/contract.js";
 import { createPromptsDomainModule } from "../domains/prompts/index.js";
 import type { ProvidersContract, TargetDescriptor, ThinkingLevel } from "../domains/providers/index.js";
@@ -199,6 +200,7 @@ import type { BootOptions } from "./boot-options.js";
 import { readCompactionSystemPrompt } from "./compaction-prompt.js";
 import { createExtensionReloadCoordinator } from "./extension-reload.js";
 import { resolvePanesEnablement } from "./panes-activation.js";
+import { reloadPluginResourcesAndNotify } from "./plugin-reload.js";
 import { bindTaskMemoryLifecycle, captureTaskMemoryUsage } from "./task-memory-lifecycle.js";
 
 export type { BootOptions, HeadlessSamplingOverrides } from "./boot-options.js";
@@ -1005,7 +1007,7 @@ function estimateTokensAfterCompaction(entries: ReadonlyArray<SessionEntry>, res
 }
 
 /**
- * Alt+J / Alt+K step the orchestrator through the `scope` list of target
+ * Scoped model cycle actions step the orchestrator through the `scope` list of target
  * ids or target/model refs. Absent scope is a no-op so unconfigured users
  * feel nothing.
  */
@@ -1140,6 +1142,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 		[
 			options.startupSettings ? createConfigDomainModule(options.startupSettings) : ConfigDomainModule,
 			ExtensionsDomainModule,
+			PluginsDomainModule,
 			InteropDomainModule,
 			createResourcesDomainModule({
 				reservedPromptNames: new Set(BUILTIN_SLASH_COMMANDS.map((entry) => entry.name)),
@@ -1535,6 +1538,8 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 	// keep evaluating after the guards and before the assessors below.
 	const hookReceiptLog = createHookReceiptLog({ persistPath: join(clioStateDir(), "hook-receipts.json") });
 	let bootHookNotices = true;
+	const reloadPlugins = () =>
+		reloadPluginResourcesAndNotify(process.cwd(), (event) => bus.emit(BusChannels.PluginsReloaded, event));
 	const extensionReload = createExtensionReloadCoordinator({
 		extensions,
 		middleware,
@@ -1545,7 +1550,10 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 			else if (bootHookNotices) initialNotices.push(line);
 			else bus.emit(BusChannels.ExtensionsLoadIssue, { message: line });
 		},
-		onCommitted: (event) => bus.emit(BusChannels.ExtensionsReloaded, event),
+		onCommitted: (event) => {
+			reloadPlugins();
+			bus.emit(BusChannels.ExtensionsReloaded, event);
+		},
 	});
 	extensionReload.applyBoot();
 	bootHookNotices = false;
@@ -1593,7 +1601,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 				listInstalledSkillNames: () => resources.skills(process.cwd()).items.map((skill) => skill.name),
 				listMarketplaceEntries: () => discoverMarketplaceSkills({ cwd: process.cwd() }).skills,
 				installEntry: (entry, scope) => {
-					const installed = installSkill({ source: entry.sourceUrl, scope, name: entry.name, cwd: process.cwd() });
+					const installed = installSkill({ source: `skill:${entry.name}`, scope, name: entry.name, cwd: process.cwd() });
 					return { path: installed.path, sourceUrl: installed.sourceUrl, installedHash: installed.installedHash };
 				},
 			}),
@@ -1718,6 +1726,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 				})
 			: null;
 	registerAllTools(toolRegistry, {
+		captureWorkerContext: () => chat.captureWorkerContext?.() ?? null,
 		...(session
 			? {
 					session,
@@ -1803,7 +1812,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 	const getCurrentSettings = (): ClioSettings => {
 		// Recents live in the data dir (core/recent-models.ts), never in
 		// settings.yaml; consumers that need them call listRecentModels
-		// directly, so an Alt+L pick in another session does not churn the
+		// directly, so an Alt+M pick in another session does not churn the
 		// config watcher here.
 		const base = config?.get();
 		// No config domain (unit tests, degraded boot): readSettings() returns a
@@ -2000,7 +2009,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 		bumpSessionState();
 		persistSavedMutation((saved) => setAtPath(saved, id, value));
 	};
-	/** Alt+J / Alt+K: step this session's orchestrator through the scope list. */
+	/** Scoped model cycle actions: step this session's orchestrator through the scope list. */
 	const cycleScopedSession = (direction: "forward" | "backward"): boolean => {
 		const next = advanceScopedTarget(getCurrentSettings(), direction);
 		if (!next) return false;
@@ -2323,6 +2332,14 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 				await termination.shutdown(1);
 				return { exitCode: 1, bootTimeMs: timer.snapshot().totalMs };
 			}
+			// A display-only template that reached boot (the CLI preflight answers
+			// most of them earlier) is printed for the operator and the run ends;
+			// its body was never model text.
+			if (promptExpansion?.expanded === false && promptExpansion.display) {
+				process.stdout.write(`${promptExpansion.display.text}\n`);
+				await termination.shutdown(0);
+				return { exitCode: 0, bootTimeMs: timer.snapshot().totalMs };
+			}
 			const fileExpansion = await expandInlineFileReferencesAsync(
 				promptExpansion?.expanded ? promptExpansion.text : parsedSkillRequest.text,
 				{
@@ -2382,6 +2399,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 		...(resources ? { resources } : {}),
 		...(extensions ? { extensions } : {}),
 		reloadExtensions: () => extensionReload.reload(),
+		reloadPlugins,
 		...(interop ? { interop } : {}),
 		...(share ? { share } : {}),
 		...(mux ? { mux } : {}),
@@ -2435,6 +2453,9 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 		getSettings: getCurrentSettings,
 		getFleetNodes: () => result.getContract<SchedulingContract>("scheduling")?.fleet?.list() ?? [],
 		onBackgroundDispatch: () => dispatchBackground.backgroundNewest(),
+		// A boot-time resume opens onto an existing conversation, so the welcome
+		// header starts collapsed rather than offering fresh-start onboarding.
+		...(resumedSessionAtBoot ? { startsResumed: true } : {}),
 		...(session ? { getSessionId: () => session.current()?.id ?? null } : {}),
 		...(contextDomain
 			? {

package/src/entry/plugin-reload.ts

@@ -0,0 +1,18 @@
+import type { PluginsReloadedPayload } from "../core/bus-events.js";
+import { type PluginSnapshot, pluginSnapshotFor, reloadPluginResources } from "../domains/plugins/index.js";
+
+/** Publish data-only plugin resources before asking session caches to refresh. */
+export function reloadPluginResourcesAndNotify(
+	cwd: string,
+	notify: (event: PluginsReloadedPayload) => void,
+): PluginSnapshot {
+	const previous = pluginSnapshotFor(cwd);
+	const next = reloadPluginResources(cwd);
+	notify({
+		generation: next.generation,
+		previousGeneration: previous.generation,
+		changed: previous.generation === 0 || previous.digest !== next.digest,
+		digest: next.digest,
+	});
+	return next;
+}

package/src/interactive/application-controller.ts

@@ -1,11 +1,11 @@
 import type { ClioKeybinding } from "../domains/config/keybindings.js";
-import { isKeyRelease, matchesKey } from "../engine/tui.js";
+import { isKeyRelease, isKeyRepeat, matchesKey } from "../engine/tui.js";
 import type { LeaderKeyController } from "./leader-key.js";
 import { isEscapeKey, type OverlayState, overlayOwnsInput } from "./overlay-lifecycle.js";
 
 export const APPLICATION_DOUBLE_TAP_MS = 500;
 
-const CLOSED_ACTION_ORDER = [
+export const CLOSED_ACTION_ORDER = [
 	"clio-coder.output.cycle",
 	"clio-coder.notifications.dismiss",
 	"clio-coder.editor.external",
@@ -24,6 +24,7 @@ export const GLOBAL_ACTION_ORDER = [
 	"clio-coder.decisions.open",
 	"clio-coder.dispatch.background",
 	"clio-coder.model.select",
+	"clio-coder.library.toggle",
 	// Backward stays ahead of forward so prefix-overlapping user bindings keep
 	// the same more-specific-first behavior as the original input listener.
 	"clio-coder.model.cycleBackward",
@@ -31,7 +32,13 @@ export const GLOBAL_ACTION_ORDER = [
 	"clio-coder.exit",
 ] as const satisfies ReadonlyArray<ClioKeybinding>;
 
-export type CtrlCAction = "cancel-stream" | "close-overlay" | "clear-editor" | "arm-shutdown" | "shutdown";
+export type CtrlCAction =
+	| "cancel-stream"
+	| "close-overlay"
+	| "clear-editor"
+	| "arm-shutdown"
+	| "shutdown"
+	| "protect-queue";
 
 export interface CtrlCActionState {
 	overlayState: OverlayState;
@@ -39,13 +46,15 @@ export interface CtrlCActionState {
 	editorText: string;
 	lastCtrlCAt: number;
 	now: number;
+	hasQueuedMessages?: boolean;
 }
 
 function resolveApplicationCtrlCAction(state: CtrlCActionState): CtrlCAction {
 	if (state.overlayState !== "closed") return "close-overlay";
-	if (state.lastCtrlCAt > 0 && state.now - state.lastCtrlCAt <= APPLICATION_DOUBLE_TAP_MS) return "shutdown";
 	if (state.streaming) return "cancel-stream";
 	if (state.editorText.length > 0) return "clear-editor";
+	if (state.hasQueuedMessages) return "protect-queue";
+	if (state.lastCtrlCAt > 0 && state.now - state.lastCtrlCAt <= APPLICATION_DOUBLE_TAP_MS) return "shutdown";
 	return "arm-shutdown";
 }
 
@@ -78,6 +87,15 @@ export interface ApplicationControllerDeps {
 	intervals: ApplicationIntervalCoordinator;
 	intervalsToClear: ReadonlyArray<ApplicationIntervalHandle>;
 	leaderKeys: LeaderKeyController;
+	isSearchFocused?: () => boolean;
+	closeSearch?: () => void;
+	forwardFocusedInput?: (data: string) => void;
+	cancelFocusedOwner?: () => void;
+	isAutocompleteVisible?: () => boolean;
+	matchesRepeatableInput?: (data: string) => boolean;
+	routeComposerKey?: (data: string) => boolean;
+	hasQueuedMessages?: () => boolean;
+	explainProtectedExit?: () => void;
 	getOverlayState: () => OverlayState;
 	routeOverlayKey: (data: string) => boolean;
 	/** Let pi-tui's focused Editor own dedicated prompt-history actions before app bindings. */
@@ -136,7 +154,7 @@ export interface ApplicationController {
 	run: Promise<number>;
 	handleInput(data: string): ApplicationInputResult;
 	handleCtrlC(): void;
-	dismissNotifications(): void;
+	dismissNotifications(all?: boolean): void;
 	shutdown(): Promise<void>;
 }
 
@@ -152,9 +170,6 @@ export function createApplicationController(deps: ApplicationControllerDeps): Ap
 	const keepAlive = deps.intervals.setInterval(() => {}, 1 << 30);
 	let shuttingDown = false;
 	let lastCtrlCAt = 0;
-	let lastNotificationDismissAt = 0;
-
-	const isDoubleTap = (lastAt: number, now: number): boolean => lastAt > 0 && now - lastAt <= APPLICATION_DOUBLE_TAP_MS;
 
 	let shutdownArmed = false;
 	let armedIndicator: ApplicationIntervalHandle | null = null;
@@ -273,12 +288,31 @@ export function createApplicationController(deps: ApplicationControllerDeps): Ap
 	};
 
 	const handleCtrlC = (): void => {
+		deps.leaderKeys.reset();
+		if (deps.isSearchFocused?.()) {
+			deps.closeSearch?.();
+			lastCtrlCAt = 0;
+			setShutdownArmed(false);
+			return;
+		}
+		if (deps.getOverlayState() !== "closed" && deps.cancelFocusedOwner) {
+			deps.cancelFocusedOwner();
+			lastCtrlCAt = 0;
+			setShutdownArmed(false);
+			return;
+		}
+		if (deps.getOverlayState() === "closed" && deps.cancelActiveEditorBash()) {
+			lastCtrlCAt = 0;
+			setShutdownArmed(false);
+			return;
+		}
 		const action = resolveApplicationCtrlCAction({
 			overlayState: deps.getOverlayState(),
 			streaming: deps.isStreaming(),
 			editorText: deps.getEditorText(),
 			lastCtrlCAt,
 			now: deps.clock.now(),
+			hasQueuedMessages: deps.hasQueuedMessages?.() ?? false,
 		});
 		if (action === "shutdown") {
 			lastCtrlCAt = 0;
@@ -317,16 +351,19 @@ export function createApplicationController(deps: ApplicationControllerDeps): Ap
 			deps.requestRender();
 			return;
 		}
+		if (action === "protect-queue") {
+			lastCtrlCAt = 0;
+			setShutdownArmed(false);
+			deps.explainProtectedExit?.();
+			return;
+		}
 		// arm-shutdown. The one branch that used to fall off the end of this
 		// function with nothing to show for the press.
 		setShutdownArmed(true);
 	};
 
-	const dismissNotifications = (): void => {
-		const now = deps.clock.now();
-		const doubleTap = isDoubleTap(lastNotificationDismissAt, now);
-		lastNotificationDismissAt = now;
-		if (doubleTap) {
+	const dismissNotifications = (all = false): void => {
+		if (all) {
 			deps.dismissAllNotifications();
 			return;
 		}
@@ -335,19 +372,27 @@ export function createApplicationController(deps: ApplicationControllerDeps): Ap
 	};
 
 	const handleInput = (data: string): ApplicationInputResult => {
-		const initialOverlayState = deps.getOverlayState();
-		if (overlayOwnsInput(initialOverlayState) && deps.leaderKeys.isPending()) deps.leaderKeys.reset();
-		if (!overlayOwnsInput(initialOverlayState) && deps.leaderKeys.isPending() && deps.leaderKeys.route(data)) {
+		if (isKeyRelease(data)) return { consume: true };
+		if (isKeyRepeat(data) && !(deps.matchesRepeatableInput?.(data) ?? false)) return { consume: true };
+		if (matchesKey(data, "ctrl+c")) {
+			handleCtrlC();
 			return { consume: true };
 		}
-
-		if (matchesKey(data, "ctrl+c") && !isKeyRelease(data)) {
-			handleCtrlC();
+		if (deps.leaderKeys.isPending() && deps.leaderKeys.route(data)) return { consume: true };
+		if (deps.leaderKeys.route(data)) return { consume: true };
+		if (deps.isSearchFocused?.()) {
+			deps.forwardFocusedInput?.(data);
 			return { consume: true };
 		}
 		if (deps.routeOverlayKey(data)) return { consume: true };
-		if (overlayOwnsInput(deps.getOverlayState())) return undefined;
-		if (deps.getOverlayState() === "closed" && deps.leaderKeys.route(data)) return { consume: true };
+		if (overlayOwnsInput(deps.getOverlayState())) {
+			if (deps.forwardFocusedInput) {
+				deps.forwardFocusedInput(data);
+				return { consume: true };
+			}
+			return undefined;
+		}
+		if (isEscapeKey(data) && deps.isAutocompleteVisible?.()) return undefined;
 		if (isEscapeKey(data) && deps.cancelActiveEditorBash()) return { consume: true };
 		if (isEscapeKey(data) && deps.isStreaming()) {
 			deps.cancelActiveRun();
@@ -369,6 +414,7 @@ export function createApplicationController(deps: ApplicationControllerDeps): Ap
 			if (!deps.matchesAction(data, id)) continue;
 			return deps.dispatchAction(id) ? { consume: true } : undefined;
 		}
+		if (deps.routeComposerKey?.(data)) return { consume: true };
 		return undefined;
 	};
 

package/src/interactive/chat-loop.ts

@@ -1,3 +1,5 @@
+import type { WorkerContextSnapshot } from "../domains/context/worker/contract.js";
+import { captureWorkerContext } from "../domains/context/worker/snapshot.js";
 /**
  * The chat loop: one turn's state machine.
  *
@@ -129,6 +131,7 @@ export interface QueueUpdateEvent {
  * same beat. Enqueue time shows the text only in the steering-queue panel.
  */
 export interface QueuedUserTurnEvent {
+	display?: { text: string; note: string };
 	type: "queued_user_turn";
 	text: string;
 	/** `interrupt` marks a message that cancelled the run and was submitted as a fresh prompt. */
@@ -198,6 +201,8 @@ export type ChatLoopEvent =
 	| ToolApprovalStateEvent;
 
 export interface ChatSubmitOptions {
+	/** Presentation only; never part of the model message or persisted text. */
+	display?: { text: string; note: string };
 	/** Host-owned run identity, scoped to this submit and its internal continuations. */
 	hostRun?: ToolInvokeOptions["hostRun"];
 	images?: ReadonlyArray<ImageContent>;
@@ -315,6 +320,7 @@ export interface ChatLoop {
 	cancel(options?: ChatCancelOptions): void;
 	onEvent(handler: (event: ChatLoopEvent) => void): () => void;
 	getSessionId(): string | null;
+	captureWorkerContext?(): WorkerContextSnapshot | null;
 	lastRunSnapshot?(): ChatLoopRunSnapshot | null;
 	isStreaming(): boolean;
 	/**
@@ -751,7 +757,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 	const queues = createTurnQueues({
 		state,
 		emitQueueUpdateEvent: (messages) => emit({ type: "queue_update", messages }),
-		emitQueuedUserTurn: (entry) => emit({ type: "queued_user_turn", text: entry.text, kind: entry.kind }),
+		emitQueuedUserTurn: (entry) => emit({ type: "queued_user_turn", ...entry }),
 		emitNotice,
 		// The loop's own resubmits (stranded steers, continuation requests) run
 		// from submit's finally and bypass the admission gate: an interrupt that
@@ -863,6 +869,11 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			if (payload.changed) context.invalidateSessionPromptCache();
 		}) ?? null;
 
+	const unsubscribePluginsReload =
+		deps.bus?.on(BusChannels.PluginsReloaded, () => {
+			context.invalidateSessionPromptCache();
+		}) ?? null;
+
 	const unsubscribeSynthesisLock =
 		deps.bus?.on(BusChannels.LoopBlocked, (payload) => {
 			const disposition = (payload as { disposition?: unknown } | null)?.disposition;
@@ -1097,13 +1108,13 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 						// Enter while streaming means "correct it now": the engine
 						// steering queue drains after every tool batch, so the text
 						// lands as a user message before the next model turn.
-						// alt+enter (queueFollowUp) keeps the after-this-run intent.
+						// Ctrl+Q (queueFollowUp) keeps the after-this-run intent.
 						if (isWorkerShareNote(trimmed)) state.turnSharedWorkerNote = true;
 						// The queue carries the submitted bytes, not the trimmed copy the
 						// guard above reads: a steer is a model-facing turn and the
 						// payload contract applies to it too (issue #244).
-						if (mode === "end-of-turn") queues.queueFollowUp(text);
-						else queues.steer(text);
+						if (mode === "end-of-turn") queues.queueFollowUp(text, options.display);
+						else queues.steer(text, options.display);
 						return;
 					}
 					emitNotice("[Clio Coder] response already in progress. Press Esc to cancel the active run.");
@@ -1287,7 +1298,13 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			// An interrupt was submitted while a run was active, so no caller drew
 			// it in the transcript; render it here, after the cancel notice and the
 			// cancelled run's leftovers, which is the order the ledger has.
-			if (interrupted) emit({ type: "queued_user_turn", text, kind: "interrupt" });
+			if (interrupted)
+				emit({
+					type: "queued_user_turn",
+					text,
+					kind: "interrupt",
+					...(options.display ? { display: options.display } : {}),
+				});
 			context.logPromptCompileIfPending();
 			const previousThinkingLevel = previousRunSnapshot?.runtimeResolution?.effectiveThinkingLevel;
 			if (
@@ -1484,6 +1501,15 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			};
 		},
 
+		captureWorkerContext(): WorkerContextSnapshot | null {
+			const meta = deps.session?.current();
+			if (!meta) return null;
+			return captureWorkerContext(
+				{ sessionId: meta.id, leafTurnId: state.lastTurnId, cwd: meta.cwd },
+				state.runtime?.agent.state.messages ?? state.replayedContextMessages,
+			);
+		},
+
 		getSessionId(): string | null {
 			return deps.session?.current()?.id ?? null;
 		},
@@ -1547,6 +1573,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		dispose(): void {
 			unsubscribeConfigReload?.();
 			unsubscribeExtensionsReload?.();
+			unsubscribePluginsReload?.();
 			unsubscribeSynthesisLock?.();
 			unsubscribePrewarmCompaction();
 			prewarm.dispose();

package/src/interactive/chat-panel.ts

@@ -1401,7 +1401,11 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 				// A queued steer or follow-up the engine just injected. Rendering it
 				// here, at injection time, keeps the transcript in the order the
 				// model saw: enqueue time shows the text only in the queue panel.
-				transcript.push({ role: "user", text: event.text });
+				transcript.push({ role: "user", text: event.display?.text ?? event.text });
+				if (event.display) {
+					const note = event.display.note;
+					transcript.push({ role: "replayBlock", renderBlock: (width) => wrapTextWithAnsi(`  ${note}`, width) });
+				}
 				markDirty();
 				return;
 			}

package/src/interactive/clio-editor.ts

@@ -112,7 +112,7 @@ function composerMode(chrome: EditorChrome, text: string): ComposerMode {
 function lowerRailHint(theme: ClioTheme, chrome: EditorChrome): string {
 	return theme.fg(
 		"dim",
-		`${chrome.getSubmitKeyLabel?.() ?? "Enter"} send · ${chrome.getNewlineKeyLabel?.() ?? "Shift+Enter"} newline`,
+		`${chrome.getSubmitKeyLabel?.() ?? "Enter"} send · ${chrome.getNewlineKeyLabel?.() ?? "Ctrl+J"} newline`,
 	);
 }
 
@@ -205,6 +205,25 @@ function startsWithPastedOperator(text: string, pastedBangOffsets: ReadonlySet<n
 export class ClioEditor extends Editor {
 	private pastedBangOffsets = new Set<number>();
 	private bracketedPasteActive = false;
+	private revision = 0;
+	private pastedOperatorTokens = new Set<string>();
+
+	get draftRevision(): number {
+		return this.revision;
+	}
+
+	/** Restored queues and external buffers are literal editor content. */
+	setLiteralText(text: string): void {
+		this.setText(text);
+		this.pastedBangOffsets = new Set([...text.matchAll(/!/gu)].map((match) => match.index));
+	}
+
+	override applyEdit(operation: Parameters<Editor["applyEdit"]>[0]): void {
+		const before = this.getText();
+		super.applyEdit(operation);
+		this.revision += 1;
+		this.pastedBangOffsets = remapPastedBangOffsets(before, this.getText(), this.pastedBangOffsets, operation === "undo");
+	}
 
 	constructor(
 		tui: TUI,
@@ -270,18 +289,20 @@ export class ClioEditor extends Editor {
 	 */
 	getTextForSubmit(): string {
 		const text = this.getExpandedText();
-		return startsWithPastedOperator(this.getText(), this.pastedBangOffsets) ? guardPastedEditorOperator(text) : text;
+		return this.startsWithLiteralOperator() ? guardPastedEditorOperator(text) : text;
 	}
 
-	/**
-	 * pi-tui's bracketed-paste handling inserts pasted text (including a
-	 * trailing newline the paste carried) without submitting: a pasted
-	 * `/model\n` lands as two lines in the buffer and just sits there. Once
-	 * the base handler has applied a chunk that closed a paste, check whether
-	 * the buffer now reads as a completed slash command and, if so, submit it
-	 * through the same handler the typed-Enter path uses.
-	 */
+	private startsWithLiteralOperator(): boolean {
+		const visible = this.getText();
+		return (
+			startsWithPastedOperator(visible, this.pastedBangOffsets) ||
+			[...this.pastedOperatorTokens].some((token) => visible.trimStart().startsWith(token))
+		);
+	}
+
+	/** Paste is always literal; a later deliberate key submits it. */
 	override handleInput(data: string): void {
+		this.revision += 1;
 		const openedPaste = data.includes("\x1b[200~");
 		const closedPaste = data.includes("\x1b[201~");
 		const pasteMutation = this.bracketedPasteActive || openedPaste;
@@ -291,10 +312,7 @@ export class ClioEditor extends Editor {
 		// pasted bang draft for that synchronous handoff so the Bash parser can
 		// distinguish it from a typed operator; the submit controller unwraps it
 		// before sending the literal prompt onward.
-		if (
-			startsWithPastedOperator(textBeforeInput, this.pastedBangOffsets) &&
-			keybindings.matches(data, "tui.input.submit")
-		) {
+		if (this.startsWithLiteralOperator() && keybindings.matches(data, "tui.input.submit")) {
 			const pastedText = this.getTextForSubmit();
 			this.pastedBangOffsets.clear();
 			this.bracketedPasteActive = false;
@@ -322,16 +340,30 @@ export class ClioEditor extends Editor {
 		);
 		if (openedPaste) this.bracketedPasteActive = true;
 		if (closedPaste) this.bracketedPasteActive = false;
-		if (!closedPaste) return;
-		const text = this.getText();
-		if (!text.endsWith("\n")) return;
-		const command = text.trimEnd();
-		if (!command.startsWith("/")) return;
-		this.setText("");
-		this.onSubmit?.(command);
+		if (pasteMutation && textAfterInput !== this.getExpandedText()) {
+			// A large paste is represented by an opaque visible token. Remember the
+			// inserted token through edits and undo, without depending on its format.
+			let start = 0;
+			while (
+				start < textBeforeInput.length &&
+				start < textAfterInput.length &&
+				textBeforeInput[start] === textAfterInput[start]
+			)
+				start++;
+			let oldEnd = textBeforeInput.length,
+				end = textAfterInput.length;
+			while (oldEnd > start && end > start && textBeforeInput[oldEnd - 1] === textAfterInput[end - 1]) {
+				oldEnd--;
+				end--;
+			}
+			const token = textAfterInput.slice(start, end).trimStart();
+			if (token && !token.startsWith("!")) this.pastedOperatorTokens.add(token);
+		}
 	}
 
 	override setText(text: string): void {
+		this.revision += 1;
+		this.pastedOperatorTokens.clear();
 		this.pastedBangOffsets.clear();
 		this.bracketedPasteActive = false;
 		super.setText(text);

package/src/interactive/command-output.ts

@@ -1,5 +1,6 @@
 import { wrapTextWithAnsi } from "../engine/tui.js";
-import type { RunIo } from "./slash-commands.js";
+import { renderReferenceCard } from "./renderers/reference-card.js";
+import type { PromptReferenceCard, RunIo } from "./slash-commands.js";
 import { type ClioToken, clioTheme, GLYPH } from "./theme/index.js";
 
 export type NoticeLevel = "info" | "success" | "warn" | "error";
@@ -54,6 +55,60 @@ export function appendOperatorCommand(text: string, sink: CommandOutputSink): vo
 	sink.requestRender();
 }
 
+/**
+ * Render a display-only prompt template for the operator. A replay block like
+ * the command echo above: it is never persisted as a session entry and never
+ * reaches the model, which is what "display only" promises the author.
+ */
+export function appendReferenceCard(card: PromptReferenceCard, sink: CommandOutputSink): void {
+	sink.appendReplayBlock((width) => renderReferenceCard(card, width));
+	sink.requestRender();
+}
+
+/**
+ * A dim line under an operator turn, in the prose gutter, saying something
+ * about the turn that the operator did not type: which template expanded, how
+ * long it was. Transcript-only, like the echo above.
+ */
+export function appendOperatorAside(text: string, sink: CommandOutputSink): void {
+	const normalized = text.replace(/\r/g, "").replace(/\n+/gu, " ").trim();
+	if (normalized.length === 0) return;
+	sink.appendReplayBlock((width) => {
+		const theme = clioTheme();
+		return wrapTextWithAnsi(theme.fg("dim", normalized), Math.max(1, width - 2)).map((line) => `  ${line}`);
+	});
+	sink.requestRender();
+}
+
+export interface InterviewRecordEntry {
+	/** The question's header, or its first line when it has none. */
+	label: string;
+	answer: string;
+}
+
+/**
+ * What a round of an interview asked and what the operator answered, kept in
+ * the transcript once the overlay has moved on. Without it the round left
+ * only a tool row reading `▸ tool action {"action":"ask",…`, and the answers
+ * lived on `/decisions` alone.
+ */
+export function appendInterviewRecord(entries: ReadonlyArray<InterviewRecordEntry>, sink: CommandOutputSink): void {
+	const kept = entries.filter((entry) => entry.answer.trim().length > 0);
+	if (kept.length === 0) return;
+	sink.appendReplayBlock((width) => {
+		const theme = clioTheme();
+		const lines: string[] = [];
+		const inner = Math.max(1, width - 2);
+		for (const entry of kept) {
+			const label = entry.label.replace(/\s+/gu, " ").trim();
+			lines.push(...wrapTextWithAnsi(`${theme.fg("accent", GLYPH.cursor)} ${theme.fg("dim", label)}`, width));
+			lines.push(...wrapTextWithAnsi(theme.fg("muted", entry.answer.trim()), inner).map((line) => `  ${line}`));
+		}
+		return lines;
+	});
+	sink.requestRender();
+}
+
 export type CommandOutputReplayBlock = (width: number) => string[];
 
 export interface CommandOutputSink {