@iowarp/clio-coder 0.4.5 → 0.4.7

package/src/interactive/chat-renderer.ts

@@ -14,7 +14,6 @@
  */
 
 import { existsSync } from "node:fs";
-import { ToolNames } from "../core/tool-names.js";
 import { foldWorkingSet } from "../domains/context/working-set/fold.js";
 import { compactionCut } from "../domains/context/working-set/visible.js";
 import { captureSkillContext } from "../domains/session/compaction/compact.js";
@@ -52,7 +51,6 @@ import {
 } from "../engine/messages.js";
 import { wrapTextWithAnsi } from "../engine/tui.js";
 import type { AgentMessage } from "../engine/types.js";
-import { toolPresentationPolicy } from "../tools/presentation.js";
 import { toolResultPresentationText } from "../tools/result-disposition.js";
 import type { ChatLoopEvent, RetryStatusPayload } from "./chat-loop.js";
 import { isSelfExplainingAbort, toolResultSummary } from "./chat-loop-messages.js";
@@ -69,7 +67,7 @@ import {
 	type StreamPacer,
 	type StreamPacerSlice,
 } from "./stream-pacer.js";
-import { type FoldOverride, policyToolFold, resolveFold, type TranscriptDetailPolicy } from "./transcript-detail.js";
+import type { TranscriptDetailPolicy } from "./transcript-detail.js";
 import { readWorkerReceiptFactsForReplay } from "./worker-receipts.js";
 import { workerEntriesFromRunEntries } from "./worker-replay.js";
 import type { WorkerReceiptReader } from "./worker-stream.js";
@@ -804,25 +802,24 @@ function appendReplayLine(chatPanel: ChatPanel, text: string): void {
 function renderBashExecutionEntry(
 	entry: BashExecutionEntry,
 	width: number,
-	folded: boolean,
+	detail: TranscriptDetailPolicy,
 	unbounded: boolean,
 ): string[] {
 	const normalizedOutput = entry.output.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\s+$/g, "");
 	return renderBashTranscriptExecution(
 		{
 			command: entry.command,
-			output: unbounded ? normalizedOutput : truncateReplayText(normalizedOutput),
+			output: normalizedOutput,
 			running: false,
 			exitCode: entry.exitCode,
 			cancelled: entry.cancelled,
 			truncated: entry.truncated,
 			fullOutputPath: entry.fullOutputPath,
 			excludeFromContext: entry.excludeFromContext,
-			folded,
 		},
 		width,
 		undefined,
-		{ unbounded, diffStyle: "plain" },
+		{ unbounded, diffStyle: "plain", detail },
 	);
 }
 
@@ -1259,16 +1256,16 @@ export function rehydrateChatPanelFromTurns(
 			case "message": {
 				if (entry.role === "user") {
 					runAssistantMessages = [];
-					const text = truncateReplayText(replayedUserText(entry));
+					const text = replayedUserText(entry);
 					if (text.length > 0) chatPanel.appendUser(text);
 					break;
 				}
 				if (entry.role === "assistant") {
 					const text = chatMessageText(entry);
 					const failure = messageFailure(entry);
-					const richMessage = richMessageFromEntry(entry, MAX_REPLAY_TEXT_CHARS);
+					const richMessage = richMessageFromEntry(entry, Number.POSITIVE_INFINITY);
 					if (richMessage || text.length > 0 || failure) {
-						const message = richMessage ?? makeTextMessage("assistant", truncateReplayText(text), entry.timestamp);
+						const message = richMessage ?? makeTextMessage("assistant", text, entry.timestamp);
 						if (failure) {
 							(message as { stopReason?: string; errorMessage?: string }).stopReason = failure.stopReason;
 							(message as { stopReason?: string; errorMessage?: string }).errorMessage = failure.errorMessage;
@@ -1303,7 +1300,7 @@ export function rehydrateChatPanelFromTurns(
 							type: "tool_execution_end",
 							toolCallId: fallbackId,
 							toolName: result.name,
-							result: displayReplayToolResult(result.result, options.unboundedToolBodies === true),
+							result: displayReplayToolResult(result.result, true),
 							isError: result.isError,
 							...(result.durationMs !== undefined ? { durationMs: result.durationMs } : {}),
 							...(resultSummary !== undefined ? { resultSummary } : {}),
@@ -1312,12 +1309,12 @@ export function rehydrateChatPanelFromTurns(
 							...(evictedReason !== undefined ? { evictedReason } : {}),
 						} as ChatLoopEvent);
 					} else {
-						chatPanel.appendReplayBlock((width) =>
+						chatPanel.appendReplayBlock((width, detail, unbounded) =>
 							renderToolResultOnly(
 								{
 									toolCallId: result.id ?? "",
 									toolName: result.name,
-									result: displayReplayToolResult(result.result, options.unboundedToolBodies === true),
+									result: displayReplayToolResult(result.result, true),
 									isError: result.isError,
 									...(result.durationMs !== undefined ? { durationMs: result.durationMs } : {}),
 									...(resultSummary !== undefined ? { resultSummary } : {}),
@@ -1326,7 +1323,7 @@ export function rehydrateChatPanelFromTurns(
 									...(evictedReason !== undefined ? { evictedReason } : {}),
 								},
 								width,
-								{ unbounded: options.unboundedToolBodies === true },
+								{ unbounded: unbounded || options.unboundedToolBodies === true, detail },
 							),
 						);
 					}
@@ -1345,21 +1342,8 @@ export function rehydrateChatPanelFromTurns(
 				break;
 			}
 			case "bashExecution": {
-				let fold: FoldOverride;
-				const presentation = toolPresentationPolicy(ToolNames.Bash, undefined);
-				const policyFold = (detail: TranscriptDetailPolicy) => policyToolFold(detail, presentation);
-				const unbounded = options.unboundedToolBodies === true;
-				chatPanel.appendReplayBlock(
-					(width, detail) =>
-						renderBashExecutionEntry(entry, width, resolveFold(fold, policyFold(detail)) === "folded", unbounded),
-					undefined,
-					{
-						policyFold,
-						fold: () => fold,
-						setFold: (next: FoldOverride) => {
-							fold = next;
-						},
-					},
+				chatPanel.appendReplayBlock((width, detail, unbounded) =>
+					renderBashExecutionEntry(entry, width, detail, unbounded || options.unboundedToolBodies === true),
 				);
 				break;
 			}
@@ -1427,5 +1411,4 @@ export function rehydrateChatPanelFromTurns(
 	// whatever the operator had opened or folded before the switch belonged to
 	// the transcript they left. /export reaches the same policy with a verbose
 	// panel, so nothing here is terminal-only.
-	chatPanel.clearFoldOverrides();
 }

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 {

package/src/interactive/dispatch-board.ts

@@ -246,9 +246,7 @@ export interface DispatchOriginPresentation {
  * surface; a board row sits under the fleet summary, which already owns the
  * quadrant's single orange, so here the filled glyph carries origin by shape.
  */
-export function dispatchOriginPresentation(
-	row: Pick<DispatchBoardRow, "requestOrigin">,
-): DispatchOriginPresentation | null {
+function dispatchOriginPresentation(row: Pick<DispatchBoardRow, "requestOrigin">): DispatchOriginPresentation | null {
 	if (row.requestOrigin === "user") return { glyph: GLYPH.workerHuman, token: "accent" };
 	if (row.requestOrigin === "agent") return { glyph: GLYPH.workerAgent, token: "muted" };
 	if (row.requestOrigin === "internal") return { glyph: GLYPH.workerInternal, token: "dim" };

package/src/interactive/editor-submit.ts

@@ -1,9 +1,8 @@
 import { combineBashOutput, runBashCommand } from "../core/bash-exec.js";
+import { type ExternalEditResult, editTextExternally, resolveExternalEditor } from "../core/external-editor.js";
 import type { PendingSkillRequest } from "../core/skill-activation.js";
-import { ToolNames } from "../core/tool-names.js";
 import type { DispatchContract } from "../domains/dispatch/contract.js";
 import type { SessionContract, SessionEntry } from "../domains/session/index.js";
-import { toolPresentationPolicy } from "../tools/presentation.js";
 import type { ChatLoop } from "./chat-loop.js";
 import type { ChatPanel } from "./chat-panel.js";
 import { bashExecutionEntryInput, parseEditorBashCommand, unguardPastedEditorOperator } from "./editor-bash.js";
@@ -13,16 +12,8 @@ import {
 	type RunningDispatchRef,
 	resolveSteerTarget,
 } from "./editor-steer.js";
-import { type ExternalEditResult, editTextExternally, resolveExternalEditor } from "./external-editor.js";
 import { type BashTranscriptExecution, renderBashTranscriptExecution } from "./renderers/tool-execution.js";
 import { parseSlashCommand, type RunIo, type SlashCommand, type SlashCommandDispatchResult } from "./slash-commands.js";
-import {
-	type FoldOverride,
-	policyRunningToolFold,
-	policyToolFold,
-	resolveFold,
-	type TranscriptDetailPolicy,
-} from "./transcript-detail.js";
 
 const EDITOR_BASH_TIMEOUT_MS = 300_000;
 /** Existing bash TERM-to-KILL grace (5s), plus settlement and session append. */
@@ -61,6 +52,9 @@ export interface EditorSubmitEditor {
 	getText(): string;
 	/** Draft spelling for an immediate send, including any editor provenance envelope. */
 	getTextForSubmit(): string;
+	getExpandedText?(): string;
+	readonly draftRevision?: number;
+	setLiteralText?(text: string): void;
 	setText(text: string): void;
 	addToHistory(text: string): void;
 }
@@ -86,6 +80,7 @@ export interface EditorSubmitSessionTranscript {
 }
 
 export interface EditorSubmitDeps {
+	onLocalBashRunning?: (running: boolean) => void;
 	editor: EditorSubmitEditor;
 	ui: EditorSubmitUi;
 	io: RunIo;
@@ -111,7 +106,7 @@ export interface EditorSubmitDeps {
 
 export interface EditorSubmitController {
 	runEditorBash(text: string): boolean;
-	openExternalEditorForInput(): void;
+	openExternalEditorForInput(text?: string): boolean;
 	handleEditorSteerMention(mention: { target: string; text: string }): boolean;
 	submitEditorText(text: string): void;
 	/** Admit an immutable boot record without reading or mutating the live draft. */
@@ -123,7 +118,7 @@ export interface EditorSubmitController {
 	 * refusals (attached dispatch, parked permission ask), which degrade the
 	 * message to next-slot delivery with a notice.
 	 */
-	interruptFromEditor(): void;
+	interruptFromEditor(text?: string): void;
 	restoreQueuedFollowUpsToEditor(): void;
 	hasActiveEditorBash(): boolean;
 	cancelActiveEditorBash(): boolean;
@@ -171,35 +166,19 @@ export function createEditorSubmitController(deps: EditorSubmitDeps): EditorSubm
 			totalBytes: 0,
 			excludeFromContext: parsed.excludeFromContext,
 		};
-		// The operator's bash row follows the same rule as a model bash call: the
-		// transcript detail policy (through bash's presentation once settled)
-		// unless the operator overrode this one block with the expand key.
-		let fold: FoldOverride;
-		const bashPresentation = toolPresentationPolicy(ToolNames.Bash, undefined);
-		const policyFold = (detail: TranscriptDetailPolicy) =>
-			execution.running ? policyRunningToolFold(detail) : policyToolFold(detail, bashPresentation);
 		deps.chatPanel.appendReplayBlock(
-			(width, detail) =>
+			(width, detail, unbounded) =>
 				renderBashTranscriptExecution(
-					{
-						...execution,
-						folded: resolveFold(fold, policyFold(detail)) === "folded",
-						...(execution.running ? { elapsedMs: Math.max(0, performance.now() - startedAt) } : {}),
-					},
+					{ ...execution, ...(execution.running ? { elapsedMs: Math.max(0, performance.now() - startedAt) } : {}) },
 					width,
+					undefined,
+					{ detail, ...(unbounded ? { unbounded } : {}) },
 				),
 			() => execution.running,
-			{
-				policyFold,
-				fold: () => fold,
-				setFold: (next: FoldOverride) => {
-					fold = next;
-					deps.ui.requestRender();
-				},
-			},
 		);
 		deps.ui.requestRender();
 
+		deps.onLocalBashRunning?.(true);
 		let settlement!: Promise<void>;
 		settlement = (async () => {
 			try {
@@ -249,6 +228,7 @@ export function createEditorSubmitController(deps: EditorSubmitDeps): EditorSubm
 				execution.error = msg;
 				deps.io.stderr(`[bash] ${msg}\n`);
 			} finally {
+				deps.onLocalBashRunning?.(false);
 				if (activeEditorBash === abort) activeEditorBash = null;
 				if (activeEditorBashSettlement === settlement) activeEditorBashSettlement = null;
 				deps.ui.requestRender();
@@ -259,27 +239,45 @@ export function createEditorSubmitController(deps: EditorSubmitDeps): EditorSubm
 		return true;
 	};
 
-	const openExternalEditorForInput = (): void => {
+	const setLiteralText = (text: string): void => {
+		if (deps.editor.setLiteralText) deps.editor.setLiteralText(text);
+		else deps.editor.setText(text);
+	};
+	const openExternalEditorForInput = (explicitText?: string): boolean => {
 		const command = (deps.resolveEditor ?? resolveExternalEditor)();
 		if (!command) {
 			deps.io.stderr("[editor] no external editor configured; set VISUAL or EDITOR\n");
-			return;
+			return false;
 		}
-		const currentText = deps.editor.getText();
+		const currentText =
+			explicitText ?? deps.editor.getExpandedText?.() ?? unguardPastedEditorOperator(deps.editor.getTextForSubmit());
 		let result: ExternalEditResult;
 		try {
 			deps.ui.stop();
 			result = (deps.editExternally ?? editTextExternally)(currentText, command);
+		} catch (error) {
+			result = { ok: false, error: error instanceof Error ? error.message : String(error) };
 		} finally {
 			deps.ui.start();
 			deps.ui.requestRender(true);
 		}
-		if (result.ok) {
-			deps.editor.setText(result.text ?? "");
-		} else if (result.error) {
-			deps.io.stderr(`[editor] ${result.error}\n`);
-		}
+		if (result.ok) setLiteralText(result.text ?? "");
+		else if (result.error) deps.io.stderr(`[editor] ${result.error}\n`);
 		deps.ui.requestRender(true);
+		return result.ok;
+	};
+
+	// A snapshot remains owned until expansion and admission finish. A second
+	// press on that same snapshot is inert; a newer draft has its own identity.
+	const pendingDrafts = new Set<string>();
+	const captureDraft = () => {
+		const text = deps.editor.getText();
+		const revision = deps.editor.draftRevision;
+		const key = JSON.stringify([revision, text]);
+		return {
+			key,
+			owns: () => deps.editor.getText() === text && deps.editor.draftRevision === revision,
+		};
 	};
 
 	const submitEditorSteerMention = (mention: { target: string; text: string }): EditorSteerSubmission => {
@@ -360,7 +358,12 @@ export function createEditorSubmitController(deps: EditorSubmitDeps): EditorSubm
 			}
 		}
 		const command = parseSlashCommand(trimmed);
-		if (isRejectedCommand(command)) {
+		if (command.kind === "editor" || command.kind === "interrupt") {
+			// Keep the correctable command until its owner accepts the snapshot.
+			deps.editor.setText(literalText);
+			const result = deps.dispatchCommand(trimmed);
+			if (result === "accepted") deps.editor.addToHistory(literalText);
+		} else if (isRejectedCommand(command)) {
 			deps.editor.setText(literalText);
 			deps.dispatchCommand(trimmed);
 		} else if (command.kind === "unknown-command") {
@@ -442,7 +445,8 @@ export function createEditorSubmitController(deps: EditorSubmitDeps): EditorSubm
 
 	const queueFollowUpFromEditor = (): void => {
 		const streaming = deps.chat.isStreaming();
-		const text = (streaming ? deps.editor.getText() : deps.editor.getTextForSubmit()).trim();
+		const snapshot = captureDraft();
+		const text = deps.editor.getTextForSubmit().trim();
 		if (text.length === 0) return;
 		if (!streaming) {
 			deps.editor.setText("");
@@ -450,8 +454,10 @@ export function createEditorSubmitController(deps: EditorSubmitDeps): EditorSubm
 			deps.ui.requestRender();
 			return;
 		}
+		if (pendingDrafts.has(snapshot.key)) return;
+		pendingDrafts.add(snapshot.key);
 		void (async () => {
-			const submitted = await deps.expandSubmit(text);
+			const submitted = await deps.expandSubmit(unguardPastedEditorOperator(text));
 			if (submitted.images.length > 0) {
 				deps.io.stderr("[follow-up] image references cannot be queued while a response is streaming\n");
 				return;
@@ -462,17 +468,20 @@ export function createEditorSubmitController(deps: EditorSubmitDeps): EditorSubm
 				return;
 			}
 			deps.editor.addToHistory(text);
-			deps.editor.setText("");
+			if (snapshot.owns()) deps.editor.setText("");
 			deps.ui.requestRender();
-		})().catch((err) => {
-			const msg = err instanceof Error ? err.message : String(err);
-			deps.io.stderr(`[follow-up] ${msg}\n`);
-		});
+		})()
+			.catch((err) => {
+				const msg = err instanceof Error ? err.message : String(err);
+				deps.io.stderr(`[follow-up] ${msg}\n`);
+			})
+			.finally(() => pendingDrafts.delete(snapshot.key));
 	};
 
-	const interruptFromEditor = (): void => {
+	const interruptFromEditor = (explicitText?: string): void => {
 		const streaming = deps.chat.isStreaming();
-		const text = (streaming ? deps.editor.getText() : deps.editor.getTextForSubmit()).trim();
+		const snapshot = captureDraft();
+		const text = (explicitText ?? deps.editor.getTextForSubmit()).trim();
 		if (text.length === 0) return;
 		if (!streaming) {
 			deps.editor.setText("");
@@ -480,8 +489,10 @@ export function createEditorSubmitController(deps: EditorSubmitDeps): EditorSubm
 			deps.ui.requestRender();
 			return;
 		}
+		if (pendingDrafts.has(snapshot.key)) return;
+		pendingDrafts.add(snapshot.key);
 		void (async () => {
-			const submitted = await deps.expandSubmit(text);
+			const submitted = await deps.expandSubmit(unguardPastedEditorOperator(text));
 			if (submitted.images.length > 0) {
 				deps.io.stderr("[interrupt] image references cannot be sent while a response is streaming\n");
 				return;
@@ -492,7 +503,8 @@ export function createEditorSubmitController(deps: EditorSubmitDeps): EditorSubm
 			// than vanishing with the cancelled run. A refused interrupt cancels
 			// nothing, so the queue stays put.
 			const restored = deps.chat.interruptRefusal() === null ? deps.chat.clearQueuedFollowUps() : [];
-			deps.editor.setText(restored.join("\n\n"));
+			const newerDraft = snapshot.owns() ? "" : (deps.editor.getExpandedText?.() ?? deps.editor.getText());
+			setLiteralText([...restored, newerDraft].filter((part) => part.length > 0).join("\n\n"));
 			deps.ui.requestRender();
 			// An interrupt is a fresh prompt, so it carries what the idle path
 			// carries: the launchpad collapse, the submitted-turn count, and the
@@ -509,10 +521,12 @@ export function createEditorSubmitController(deps: EditorSubmitDeps): EditorSubm
 				...(skillRequests.length > 0 ? { pendingSkillRequests: skillRequests } : {}),
 			});
 			await deps.settleVisibleFrame?.("interrupt-submit-return");
-		})().catch((err) => {
-			const msg = err instanceof Error ? err.message : String(err);
-			deps.io.stderr(`[interrupt] ${msg}\n`);
-		});
+		})()
+			.catch((err) => {
+				const msg = err instanceof Error ? err.message : String(err);
+				deps.io.stderr(`[interrupt] ${msg}\n`);
+			})
+			.finally(() => pendingDrafts.delete(snapshot.key));
 	};
 
 	const restoreQueuedFollowUpsToEditor = (): void => {
@@ -521,9 +535,9 @@ export function createEditorSubmitController(deps: EditorSubmitDeps): EditorSubm
 			deps.io.stderr("[follow-up] no queued messages to restore\n");
 			return;
 		}
-		const currentText = deps.editor.getText();
+		const currentText = deps.editor.getExpandedText?.() ?? deps.editor.getText();
 		const queuedText = restored.join("\n\n");
-		deps.editor.setText([queuedText, currentText].filter((part) => part.trim().length > 0).join("\n\n"));
+		setLiteralText([queuedText, currentText].filter((part) => part.trim().length > 0).join("\n\n"));
 		deps.ui.requestRender();
 	};
 

package/src/interactive/fleet-run-preview.ts

@@ -177,6 +177,8 @@ export function compileFleetRunPreview(input: FleetRunPreviewInput): FleetRunPre
 	let plan: ExecutionPlan;
 	try {
 		plan = compileFleetExecutionPlan({
+			commands,
+			vars: input.vars,
 			contract,
 			task,
 			resolveAgent(context) {

package/src/interactive/follow-up-queue-panel.ts

@@ -11,8 +11,8 @@ export interface FollowUpQueuePanelOptions {
 }
 
 /**
- * Keybindings are stored lowercase (`alt+up`), but the hint vocabulary spells
- * modifiers and keys in title case (`[Alt+Up]`). Format the bound key for
+ * Keybindings are stored lowercase (`alt+q`), but the hint vocabulary spells
+ * modifiers and keys in title case (`[Alt+Q]`). Format the bound key for
  * display so the panel reads the same whether or not the binding is customized.
  */
 function displayKey(key: string): string {
@@ -52,7 +52,7 @@ export function createFollowUpQueuePanel(options: FollowUpQueuePanelOptions = {}
 				message.kind === "steer" ? theme.fg("action", `${GLYPH.user} steer`) : theme.fg("muted", `${GLYPH.queued} queued`);
 			lines.push(`${marker} ${theme.fg("muted", preview)}`);
 		}
-		const restoreKey = key && key.length > 0 ? displayKey(key) : "Alt+Up";
+		const restoreKey = key && key.length > 0 ? displayKey(key) : "see /help";
 		lines.push(theme.fg("dim", `[${restoreKey}] restore to editor`));
 
 		cachedLines = frame(theme, "Steering Queue", lines, bodyWidth + 4);