@oh-my-pi/pi-tui 18.8.7 → 18.8.8

package/src/chat/execution-shared.ts

@@ -20,6 +20,7 @@ import { DEFAULT_TERMINAL_PREVIEW_LINES, expandKeyHint } from "../render/render-
 import type { TspCardStatus, TspSpan, TspText, TspTone } from "@oh-my-pi/pi-wire";
 import { card, node, span, text } from "../native/describe";
 import type { NativeChild, NativeNode } from "../native/node";
+import { runBox, runFoot, runInput, runOutput, type RunState } from "../tools/native-view";
 
 /** Output rows shown while an execution is collapsed. */
 export const PREVIEW_LINES = 20;
@@ -190,7 +191,7 @@ export interface ExecutionToolInput {
 	/** Tool name for the head icon (`bash`, `eval`). */
 	readonly name: string;
 	readonly title: string;
-	/** The command / cell source, shown once in the head. */
+	/** The command / cell source: the run box's input and the head's Copy command. */
 	readonly command: string;
 	readonly lang: string;
 	/** Excluded from context (`!!`/`$$`). */
@@ -208,39 +209,55 @@ export interface ExecutionToolInput {
 	readonly artifactError?: OutputArtifactError;
 }
 
+const EXECUTION_RUN_STATE: Record<ExecutionStatus, RunState> = {
+	running: "running",
+	complete: "done",
+	cancelled: "cancelled",
+	error: "failed",
+};
+
 /**
- * A user `!`/`$` run as the agent's `tool` frame (§6.6): the command in the
- * head with a `you` badge (plus `not sent` when excluded from context), the
- * timer, exit chip and cancelled note; the body is the output as an `ansi`
- * mini terminal following its tail, then one quiet truncation line.
+ * A user `!`/`$` run as the agent's `tool` frame (§6.6): a head with a `you`
+ * badge (plus `not sent` when excluded from context) and the command for Copy
+ * command; the body is one run box — the source, the output as an `ansi` mini
+ * terminal following its tail, and the foot (state, time, truncation) — with
+ * any images below it. Timer, exit chip and cancelled note stay head data.
  */
 export function describeExecutionTool(input: ExecutionToolInput): NativeNode {
 	const running = input.status === "running";
-	const body: NativeChild[] = [];
-	if (input.output) body.push(node("ansi", { text: input.output, follow: running }, undefined, "output"));
-	if (input.images) body.push(...input.images);
-	const notes: string[] = [];
-	if (input.truncation) notes.push(formatTruncationMetaNotice(input.truncation));
-	if (input.artifactError) notes.push(formatArtifactErrorNotice(input.artifactError));
-	if (notes.length > 0) {
-		body.push({
-			...text([span(notes.join(" · "), "muted")], { wrap: "word", role: "omp.tool.notice" }),
-			key: "foot",
-		});
-	}
+	const shell = input.name === "bash";
 	const ms = Math.max(0, Math.round((input.endedAt ?? performance.now()) - input.startedAt));
+	const state = EXECUTION_RUN_STATE[input.status];
+	const box = runBox(
+		[
+			runInput(input.command, {
+				role: shell ? "omp.tool.bash.command" : "omp.tool.eval.input",
+				lang: input.lang,
+				wrap: shell,
+			}),
+			input.output.length > 0 &&
+				runOutput(input.output, {
+					role: shell ? "omp.tool.bash.output" : "omp.tool.eval.output",
+					previewLines: DEFAULT_TERMINAL_PREVIEW_LINES,
+				}),
+			runFoot({
+				state,
+				exitCode: input.exitCode,
+				elapsedMs: ms,
+				meta: { truncation: input.truncation, artifactError: input.artifactError },
+			}),
+		],
+		{ key: "run", tone: state === "failed" ? "error" : undefined },
+	);
 	const badges: { text: string; tone?: TspTone; title?: string }[] = [{ text: "you", tone: "user" }];
 	if (input.excluded) badges.push({ text: "not sent", title: "Not sent to the model", tone: "muted" });
-	const hasBody = body.length > 0;
 	return node(
 		"tool",
 		{
 			role: input.role,
 			name: input.name,
 			title: input.title,
-			target: input.command,
-			targetKind: "command",
-			lang: input.lang,
+			command: input.command,
 			badges,
 			status: EXECUTION_CARD_STATUS[input.status],
 			age: running ? ms : undefined,
@@ -248,11 +265,11 @@ export function describeExecutionTool(input: ExecutionToolInput): NativeNode {
 			exit: input.status === "error" ? input.exitCode : undefined,
 			note: input.status === "cancelled" ? "cancelled" : undefined,
 			frame: "card",
-			collapsible: hasBody,
-			collapsed: hasBody ? !input.expanded : undefined,
-			preview: hasBody ? { tail: DEFAULT_TERMINAL_PREVIEW_LINES } : undefined,
+			collapsible: true,
+			collapsed: !input.expanded,
+			preview: "children",
 		},
-		body,
+		[box, ...(input.images ?? [])],
 	);
 }
 

package/src/chat/tool-execution.ts

@@ -111,10 +111,13 @@ function resolveEditModeForTool(toolName: string, tool: AgentTool | undefined):
 
 type ToolRendererStage = "call" | "result";
 
-/** A renderer's preview as the fallback card's clamp (`tail` becomes a head clamp of the same size). */
+/**
+ * A renderer's preview as the fallback card's clamp (`tail` becomes a head
+ * clamp of the same size; `children` leaves the clamping to the body's own previews).
+ */
 function cardPreview(preview: NativeToolView["preview"]): TspPreview | undefined {
 	if (preview === undefined) return { lines: DEFAULT_TERMINAL_PREVIEW_LINES };
-	if (preview === "none") return undefined;
+	if (preview === "none" || preview === "children") return undefined;
 	if (preview !== "auto" && "tail" in preview) return { lines: preview.tail };
 	return preview;
 }
@@ -1025,6 +1028,7 @@ export class ToolExecutionComponent extends Container {
 				target: head?.target,
 				targetKind: head?.targetKind,
 				lang: head?.lang,
+				command: head?.command,
 				href: head?.href,
 				meta: head?.meta,
 				badges: badges.length > 0 ? badges : undefined,
@@ -1124,11 +1128,14 @@ export class ToolExecutionComponent extends Container {
 	 * A renderer that throws falls back to the generic card.
 	 */
 	#nativeView(): NativeToolView {
+		const status = this.#nativeStatus();
 		const options: RenderResultContextOptions = {
 			expanded: this.#expanded,
 			isPartial: this.#isPartial,
 			argsComplete: this.#argsComplete,
 			executionStarted: this.#executionStarted,
+			elapsedMs: this.#elapsedMs(status),
+			cancelled: status === "cancelled",
 			renderContext: this.#buildRenderContext(),
 		};
 		// Custom tools (MCP, extensions) carry their own describe hooks, mirroring

package/src/components/editor.ts

@@ -83,6 +83,7 @@ const VIM_MODE_LABELS: Record<VimMode, string | undefined> = {
 	normal: "NORMAL",
 	visual: "VISUAL",
 	"visual-line": "VISUAL",
+	replace: "REPLACE",
 };
 
 const PASSTHROUGH_COLOR = (text: string): string => text;
@@ -672,7 +673,9 @@ export class Editor implements Component, Focusable {
 	// Emacs-style kill ring
 	#killRing = new KillRing();
 	/** Previous edit, for kill/yank chaining, undo coalescing, and the provisional space after a Tab word accept. */
-	#lastAction: "kill" | "yank" | "type-word" | "accept-word" | null = null;
+	#lastAction: "kill" | "yank" | "type-word" | "accept-word" | "replace" | null = null;
+	/** Graphemes overwritten in the current `R` session, so Backspace can restore them. */
+	#replaceLog: { line: number; col: number; removed: string; text: string }[] = [];
 
 	// Character jump mode
 	#jumpMode: "forward" | "backward" | null = null;
@@ -2252,18 +2255,43 @@ export class Editor implements Component, Focusable {
 			return this.isShowingAutocomplete() ? false : this.#runVimKey("escape", vim);
 		}
 		if (vim.mode === "insert") return false;
+		if (vim.mode === "replace") {
+			if (canonical === "backspace" || matchesKey(data, "backspace") || matchesKey(data, "shift+backspace")) {
+				this.#replaceBackspace();
+				return true;
+			}
+			const replacing = extractPrintableText(data);
+			if (replacing) {
+				for (const seg of segmenter.segment(replacing)) this.#overwriteReplaceGrapheme(seg.segment);
+				return true;
+			}
+		}
 
+		// `f`/`t`/`r` are waiting for a character. Space is that character; arrows and other named
+		// keys cancel, instead of being rewritten to `h`/`l` and inserted or searched for.
+		const awaitingTarget = /[fFtTr]$/.test(vim.pendingText);
+		if (awaitingTarget && (canonical === "space" || data === " ")) return this.#runVimKey(" ", vim);
 		const mapped = canonical === undefined ? undefined : VIM_NAV_KEYS[canonical];
+		if (awaitingTarget && mapped !== undefined) return this.#runVimKey("escape", vim);
 		if (mapped !== undefined) return this.#runVimKey(mapped, vim);
 
-		// Control chords carry no printable text and stay with the host.
+		// Control chords, Enter, and Tab carry no printable text and stay with the host. A half-typed
+		// command (`r`, `f`, `d`) is cancelled first, like character-jump mode, so it cannot outlive a
+		// submit and swallow the first key of the next prompt.
 		const printable = extractPrintableText(data);
-		if (!printable) return false;
+		if (!printable) {
+			if (vim.pending) this.#runVimKey("escape", vim);
+			return false;
+		}
 
 		// Batched stdin can deliver several keystrokes at once, so replay the run one grapheme at a
-		// time. A command that drops out of Normal mode part-way (`iabc`) turns the rest of the run
-		// back into literal text rather than swallowing it.
+		// time. A command that drops out of Normal mode part-way (`iabc`, `Rxx`) turns the rest of
+		// the run into literal text or replace-mode overwrites rather than more Normal commands.
 		for (const seg of segmenter.segment(printable)) {
+			if (vim.mode === "replace") {
+				this.#overwriteReplaceGrapheme(seg.segment);
+				continue;
+			}
 			if (this.#runVimKey(seg.segment, vim)) continue;
 			this.#insertCharacter(printable.slice(seg.index));
 			return true;
@@ -2284,11 +2312,22 @@ export class Editor implements Component, Focusable {
 		if (vim.mode !== before || vim.pendingText !== pendingBefore || this.vimSelectedLines !== selectedLinesBefore) {
 			this.onVimModeChange?.(vim.mode);
 		}
+		if (before === "replace" && vim.mode !== "replace") this.#replaceLog.length = 0;
+		if (vim.mode === "replace" && before !== "replace") this.#replaceLog.length = 0;
 		return true;
 	}
 
 	#applyVimCommands(commands: readonly VimCommand[]): void {
 		for (const command of commands) {
+			// A delete or other edit in replace mode invalidates Backspace restores. Motions do not.
+			if (
+				this.#vim?.mode === "replace" &&
+				command.kind !== "move" &&
+				command.kind !== "mode" &&
+				command.kind !== "yank"
+			) {
+				this.#replaceLog.length = 0;
+			}
 			switch (command.kind) {
 				case "move":
 					this.#moveVimCursor(command.to);
@@ -2320,12 +2359,133 @@ export class Editor implements Component, Focusable {
 				case "undo":
 					this.#applyUndo();
 					break;
+				case "replace":
+					this.#replaceVimSpan(command.from, command.to, command.text);
+					break;
+				case "join":
+					this.#joinVimLines(command.fromLine, command.lines);
+					break;
+				case "indent":
+					this.#indentVimLines(command.fromLine, command.toLine, command.out);
+					break;
 			}
 		}
 		this.#clampVimCursor();
 		this.invalidate();
 	}
 
+	#replaceVimSpan(from: VimPosition, to: VimPosition, text: string): void {
+		const line = this.#state.lines[from.line] ?? "";
+		if (this.#spanCutsAtomicToken(line, from.col, to.col)) return;
+		this.#recordUndoState();
+		this.#lastAction = null;
+		this.#state.lines[from.line] = line.slice(0, from.col) + text + line.slice(to.col);
+		this.#state.cursorLine = from.line;
+		let last = from.col;
+		for (const seg of segmenter.segment(text)) last = from.col + seg.index;
+		this.#setCursorCol(last);
+		this.#afterVimEdit();
+	}
+
+	#overwriteReplaceGrapheme(grapheme: string): void {
+		const lineIdx = this.#state.cursorLine;
+		const line = this.#state.lines[lineIdx] ?? "";
+		const col = this.#state.cursorCol;
+		if (this.#atomicTokenAt(line, col)) return;
+		// Any other edit since the last overwrite (setText, `x`, paste) resets `#lastAction`, which
+		// makes the logged columns meaningless; start a fresh undo step and a fresh log.
+		if (this.#lastAction !== "replace") {
+			this.#recordUndoState();
+			this.#replaceLog.length = 0;
+		}
+		this.#lastAction = "replace";
+		// Editing a recalled prompt makes it a draft, so Up/Down at an edge move the cursor again
+		// instead of navigating history over the overwritten text (same as `#afterVimEdit`).
+		this.#historyIndex = -1;
+		const end = col >= line.length ? col : nextGraphemeStart(line, col);
+		const removed = line.slice(col, end);
+		this.#state.lines[lineIdx] = line.slice(0, col) + grapheme + line.slice(end);
+		this.#replaceLog.push({ line: lineIdx, col, removed, text: grapheme });
+		this.#setCursorCol(col + grapheme.length);
+		this.#notifyChange();
+	}
+
+	#replaceBackspace(): void {
+		if (this.#lastAction !== "replace") {
+			this.#replaceLog.length = 0;
+			return;
+		}
+		const entry = this.#replaceLog.pop();
+		if (!entry) return;
+		const line = this.#state.lines[entry.line] ?? "";
+		const stillThere = line.slice(entry.col, entry.col + entry.text.length) === entry.text;
+		const atCursor = this.#state.cursorLine === entry.line && this.#state.cursorCol === entry.col + entry.text.length;
+		if (!stillThere) return;
+		if (!atCursor) {
+			this.#replaceLog.push(entry);
+			return;
+		}
+		this.#state.lines[entry.line] =
+			line.slice(0, entry.col) + entry.removed + line.slice(entry.col + entry.text.length);
+		this.#setCursorCol(entry.col);
+		this.#notifyChange();
+	}
+
+	#joinVimLines(fromLine: number, span: number): void {
+		const start = Math.max(0, Math.min(fromLine, this.#state.lines.length - 1));
+		const last = Math.min(start + Math.max(span, 2) - 1, this.#state.lines.length - 1);
+		if (last <= start) return;
+		this.#recordUndoState();
+		let text = this.#state.lines[start] ?? "";
+		let cursor = text.length;
+		for (let i = start + 1; i <= last; i++) {
+			const raw = this.#state.lines[i] ?? "";
+			let trim = /^[ \t]*/.exec(raw)?.[0].length ?? 0;
+			const token = this.#atomicTokenAt(raw, 0);
+			if (token && token.start < trim) trim = token.start;
+			const next = raw.slice(trim);
+			const at = text.length;
+			if (i === start + 1) cursor = at;
+			// Vim join: no extra space after whitespace, before `)`, or for an empty line; two spaces after `.!?`.
+			const gap =
+				text.length === 0 || next.length === 0 || /[ \t]$/.test(text) || next.startsWith(")")
+					? ""
+					: /[.!?]$/.test(text)
+						? "  "
+						: " ";
+			text += gap + next;
+		}
+		this.#state.lines.splice(start, last - start + 1, text);
+		this.#state.cursorLine = start;
+		this.#setCursorCol(cursor);
+		this.#lastAction = null;
+		this.#afterVimEdit();
+	}
+
+	#indentVimLines(fromLine: number, toLine: number, out: boolean): void {
+		const first = Math.max(0, Math.min(fromLine, this.#state.lines.length - 1));
+		const last = Math.max(first, Math.min(toLine, this.#state.lines.length - 1));
+		// Two spaces, not Vim's shiftwidth of 8: a prompt draft should not jump a tab stop. A leading tab shifts by one tab so the line keeps its own indent style.
+		// Empty lines stay empty, as in Vim, so shifting a paragraph never leaves trailing blanks.
+		const next = this.#state.lines.slice(first, last + 1).map(line => {
+			const text = line ?? "";
+			if (!out) return text.length === 0 ? text : (text.startsWith("\t") ? "\t" : "  ") + text;
+			if (text.startsWith("\t")) return text.slice(1);
+			const spaces = /^ */.exec(text)?.[0].length ?? 0;
+			return text.slice(Math.min(2, spaces));
+		});
+		if (next.every((line, i) => line === (this.#state.lines[first + i] ?? ""))) return;
+		this.#recordUndoState();
+		for (let i = first; i <= last; i++) this.#state.lines[i] = next[i - first] ?? "";
+		this.#state.cursorLine = first;
+		const landed = this.#state.lines[first] ?? "";
+		let col = 0;
+		while (col < landed.length && /\s/.test(landed.charAt(col))) col++;
+		this.#setCursorCol(col);
+		this.#lastAction = null;
+		this.#afterVimEdit();
+	}
+
 	#moveVimCursor(to: VimPosition): void {
 		this.#state.cursorLine = Math.max(0, Math.min(to.line, this.#state.lines.length - 1));
 		const line = this.#state.lines[this.#state.cursorLine] ?? "";
@@ -3409,6 +3569,23 @@ export class Editor implements Component, Focusable {
 		return undefined;
 	}
 
+	/** True when `[from, to)` overlaps a placeholder. Counted `r` must no-op rather than split it.
+	 *  One pass over the line's matches, so a long counted replace stays linear. */
+	#spanCutsAtomicToken(line: string, from: number, to: number): boolean {
+		const re = this.#getAtomicTokenRe();
+		if (re === undefined) return false;
+		re.lastIndex = 0;
+		for (;;) {
+			const match = re.exec(line);
+			if (match === null || match.index >= to) return false;
+			if (match[0].length === 0) {
+				re.lastIndex = match.index + 1;
+				continue;
+			}
+			if (match.index + match[0].length > from) return true;
+		}
+	}
+
 	/** Expand the half-open range [start, end) so it never cuts through an atomic
 	 *  placeholder token: a boundary landing inside a token pulls the whole token in. */
 	#expandRangeOverAtomicTokens(line: string, start: number, end: number): { start: number; end: number } {

package/src/keybinding-matchers.ts

@@ -53,11 +53,15 @@ export function matchesSelectPageDown(data: string): boolean {
 	return getKeybindings().matches(data, "tui.select.pageDown");
 }
 
+/** Effective external-editor key: the first bound key, or Ctrl+G when unbound. */
+export function appExternalEditorKey(): KeyId {
+	return getKeybindings().getKeys("app.editor.external")[0] ?? "ctrl+g";
+}
+
 /** Match the external-editor keybinding, falling back to Ctrl+G when unbound. */
 export function matchesAppExternalEditor(data: string): boolean {
 	const keybindings = getKeybindings();
-	const externalEditorKeys = keybindings.getKeys("app.editor.external");
-	if (externalEditorKeys.length > 0) {
+	if (keybindings.getKeys("app.editor.external").length > 0) {
 		return keybindings.matches(data, "app.editor.external");
 	}
 	return matchesKey(data, "ctrl+g");

package/src/overlays/agent-hub.ts

@@ -951,12 +951,16 @@ export class AgentHubOverlayComponent<TRecord extends AgentRecordLike = AgentRec
 			return { ...item, depth, open: this.#childrenByParent.has(ref.id) ? true : undefined };
 		}
 		if (!metrics) return item;
+		// A running agent's active time ticks terminal-side from the age at send; a settled one
+		// is frozen text. Progress `durationMs` was current when its frame arrived, so age it to now
+		// — re-sending the stale value on every repaint rewinds Tern's clock. A first frame can
+		// report 0 ms, so a progress timestamp alone makes the row clockable.
+		const progressAt = observed?.progress ? observed.progressAt : undefined;
 		const facts: Record<string, string | number> = {
 			cost: formatCost(metrics.cost),
-			// A running agent's active time ticks terminal-side; a settled one is frozen text.
 			time:
-				ref.status === "running" && metrics.durationMs > 0
-					? metrics.durationMs
+				ref.status === "running" && (metrics.durationMs > 0 || progressAt !== undefined)
+					? metrics.durationMs + (progressAt === undefined ? 0 : Math.max(0, Date.now() - progressAt))
 					: formatDuration(metrics.durationMs),
 			req: metrics.requests,
 			tools: metrics.tools,

package/src/overlays/annotation-overlay.ts

@@ -13,7 +13,7 @@ import {
 } from "../index";
 import { compositeLineAt } from "../render/composite";
 import { wrapLiteralLine } from "../utils";
-import { appKey, editorKey } from "../chrome/keybinding-hints";
+import { editorKey } from "../chrome/keybinding-hints";
 import { formatKeyHint, formatKeyHints, type KeybindingsManager } from "../app-keybindings";
 import type { Keybinding } from "../keybindings";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
@@ -38,7 +38,7 @@ import {
 	topBorder,
 	topBorderSplit,
 } from "../chrome/overlay-box";
-import { matchesAppExternalEditor } from "../keybinding-matchers";
+import { appExternalEditorKey, matchesAppExternalEditor } from "../keybinding-matchers";
 import type { KeyName } from "../key-hint-format";
 import { item, keyed, node, row as rowNode, span, text } from "../native/describe";
 import { leafKey, type NativeChild, type NativeNode, type NativeUiEvent } from "../native/node";
@@ -70,6 +70,8 @@ export interface AnnotationOverlayCallbacks {
 	onWarning?(message: string): void;
 	/** Open the draft in the host's editor and invoke `commit` with its result. */
 	onAnnotationExternalEditor?(draft: string, commit: (text: string | null) => void): void | Promise<void>;
+	/** Open the current source in the host's editor. The overlay stays open. */
+	onExternalEditor?(): void | Promise<void>;
 }
 
 export interface CodeReviewOverlayCallbacks extends AnnotationOverlayCallbacks {
@@ -171,6 +173,8 @@ export class AnnotationOverlay implements Focusable {
 	#editingAnnotationIndex: number | undefined;
 	#annotationChooser: AnnotationChooser | undefined;
 	#externalOperation = false;
+	/** Set once {@link replaceTextSource} runs; the paste result then carries the edited text. */
+	#textSourceEdited = false;
 	#finished = false;
 	#annotations: CommittedAnnotation[] = [];
 	#textAnnotations: CommittedTextAnnotation[] = [];
@@ -306,6 +310,61 @@ export class AnnotationOverlay implements Focusable {
 		return this.#textAnnotations.map(entry => ({ ...entry.annotation }));
 	}
 
+	/** Repo-relative path of the diff file under the cursor, if this is a code review. */
+	reviewFilePath(): string | undefined {
+		const file = this.#files[this.#fileIndex];
+		if (!file) return undefined;
+		return file.newPath ?? file.oldPath ?? file.path;
+	}
+
+	/** Current text-source bytes, including edits applied by {@link replaceTextSource}. */
+	textSourceText(): string | undefined {
+		return this.#textSource?.text;
+	}
+
+	/**
+	 * Replace the text under review. Line notes whose quote still sits on the
+	 * same row stay; a quote that moved to exactly one row is retargeted;
+	 * every other line note is dropped. Returns how many were dropped.
+	 */
+	replaceTextSource(text: string): number {
+		if (!this.#textSource) return 0;
+		this.#textSource = { ...this.#textSource, text };
+		this.#textSourceEdited = true;
+		this.#textLines = splitTextLines(text);
+		this.#viewportDriven = false;
+		this.#sourceIndex = Math.min(this.#sourceIndex, Math.max(0, this.#textLines.length - 1));
+		let dropped = 0;
+		const kept: CommittedTextAnnotation[] = [];
+		for (const entry of this.#textAnnotations) {
+			if (entry.annotation.scope !== "line") {
+				kept.push(entry);
+				continue;
+			}
+			const quote = entry.annotation.quote;
+			if (this.#textLines[entry.sourceIndex] === quote) {
+				kept.push(entry);
+				continue;
+			}
+			const matches = this.#textLines.flatMap((line, index) => (line === quote ? [index] : []));
+			const only = matches.length === 1 ? matches[0] : undefined;
+			if (only !== undefined) {
+				kept.push({
+					sourceIndex: only,
+					annotation: { ...entry.annotation, line: only + 1 },
+				});
+				continue;
+			}
+			dropped++;
+		}
+		this.#textAnnotations = kept;
+		// Earlier snapshots hold notes anchored to the old text; undo must not resurrect them.
+		this.#undoStack = [];
+		this.#annotationRev++;
+		this.#nativeBody = undefined;
+		return dropped;
+	}
+
 	handleInput(data: string): void {
 		if (this.#finished || this.#externalOperation) return;
 		if (this.#annotationChooser) {
@@ -328,6 +387,10 @@ export class AnnotationOverlay implements Focusable {
 			this.#escape();
 			return;
 		}
+		if (this.#callbacks.onExternalEditor && matchesAppExternalEditor(data)) {
+			void this.#openSourceEditor();
+			return;
+		}
 		if (data === "A" && (this.#focus === "files" || this.#focus === "diff")) {
 			this.#startAnnotation(this.#textSource ? "text" : "file");
 			return;
@@ -514,6 +577,7 @@ export class AnnotationOverlay implements Focusable {
 			this.#finish({
 				action: "paste",
 				annotations: this.getTextAnnotations(),
+				...(this.#textSourceEdited ? { editedText: this.#textSource.text } : {}),
 			});
 		} else {
 			this.#finish({
@@ -832,6 +896,22 @@ export class AnnotationOverlay implements Focusable {
 		}
 	}
 
+	async #openSourceEditor(): Promise<void> {
+		const openEditor = this.#callbacks.onExternalEditor;
+		if (this.#externalOperation || !openEditor) return;
+		this.#externalOperation = true;
+		try {
+			await openEditor();
+		} catch (error) {
+			this.#callbacks.onWarning?.(
+				`Failed to open external editor: ${error instanceof Error ? error.message : String(error)}`,
+			);
+		} finally {
+			this.#externalOperation = false;
+			this.#tui.requestRender(true);
+		}
+	}
+
 	#annotationCount(fileIndex: number): number {
 		let count = 0;
 		for (const entry of this.#annotations) if (entry.fileIndex === fileIndex) count++;
@@ -1091,8 +1171,7 @@ export class AnnotationOverlay implements Focusable {
 				`${editorKey("tui.input.newLine")} newline`,
 				`${this.#key("tui.select.cancel")} cancel`,
 			];
-			const externalEditorKey = appKey(this.#keybindings, "app.editor.external");
-			if (externalEditorKey) hints.push(`${externalEditorKey} editor`);
+			hints.push(`${formatKeyHint(appExternalEditorKey())} editor`);
 			return [caption, ...this.#editor.render(width), this.#theme.fg("dim", hints.join(" · "))];
 		}
 		return [this.#theme.fg("dim", this.#helpText())];
@@ -1143,7 +1222,8 @@ export class AnnotationOverlay implements Focusable {
 				: this.#focus === "diff"
 					? `${upDown} line · ${formatKeyHint("shift")} faster · ${this.#key("tui.select.pageUp")}/${this.#key("tui.select.pageDown")} · ${formatKeyHints(["g", "shift+g"])} ends · ${formatKeyHint("a")} line note · ${formatKeyHint("shift+a")} ${this.#textSource ? "text" : "file"} note · ${editNote}`
 					: `${upDown} select · ${confirm} confirm`;
-		return `${focusHelp} · ${formatKeyHint("u")} undo · ${formatKeyHint("tab")} regions · ${this.#key("tui.select.cancel")} cancel`;
+		const editorHint = this.#callbacks.onExternalEditor ? ` · ${formatKeyHint(appExternalEditorKey())} editor` : "";
+		return `${focusHelp} · ${formatKeyHint("u")} undo · ${formatKeyHint("tab")} regions${editorHint} · ${this.#key("tui.select.cancel")} cancel`;
 	}
 
 	#ensureCursorVisible(renderedRowBySource: readonly number[]): boolean {
@@ -1523,7 +1603,7 @@ export class AnnotationOverlay implements Focusable {
 						this.#hint("tui.input.submit", "save"),
 						this.#hint("tui.input.newLine", "newline"),
 						this.#hint("tui.select.cancel", "cancel"),
-						this.#hint("app.editor.external", "editor"),
+						{ keys: [appExternalEditorKey()], label: "editor" },
 					],
 					"annotateHints",
 				),
@@ -1549,6 +1629,7 @@ export class AnnotationOverlay implements Focusable {
 							editNote,
 						]
 					: [upDown("select"), this.#hint("tui.select.confirm", "confirm")];
+		if (this.#callbacks.onExternalEditor) hints.push({ keys: [appExternalEditorKey()], label: "editor" });
 		hints.push(key("u", "undo"), key("tab", "regions"), this.#hint("tui.select.cancel", "cancel"));
 		return [hintsRow(hints)];
 	}

package/src/overlays/annotation-types.ts

@@ -75,4 +75,6 @@ export type TextReviewAnnotation =
 export interface TextReviewOverlayResult {
 	action: "paste";
 	annotations: TextReviewAnnotation[];
+	/** Source text after an external-editor edit; absent when the source was not edited. */
+	editedText?: string;
 }

package/src/overlays/hook-selector.ts

@@ -94,6 +94,10 @@ export interface HookSelectorOptions {
 	/** Number of leading options (original order) that receive a selection
 	 *  marker. Defaults to every option when {@link selectionMarker} is set. */
 	markableCount?: number;
+	/** Describe as a card in the dock (the composer slot) instead of a picker
+	 *  sheet, so dock content above it (e.g. a `/omfg` candidate rule) stays
+	 *  visible and the transcript stays scrollable on native surfaces. */
+	inline?: boolean;
 }
 
 export interface HookSelectorOption {
@@ -210,6 +214,7 @@ export class HookSelectorComponent extends OverlayPanel {
 	#sliderComponent: Text | undefined;
 	#lastRenderWidth: number | undefined;
 	readonly #detailLines: readonly string[];
+	readonly #inline: boolean;
 	readonly #helpText: string | undefined;
 	/** Described option rows by original index; `marker` is the radio state baked into the label. */
 	readonly #nativeItems = new Map<number, { marker: boolean; node: NativeNode }>();
@@ -264,6 +269,7 @@ export class HookSelectorComponent extends OverlayPanel {
 		this.#baseTitle = this.title;
 		this.#detailLines = title.split(/\r?\n/).slice(1);
 		this.#helpText = opts?.helpText;
+		this.#inline = opts?.inline ?? false;
 		this.#onLeftCallback = opts?.onLeft;
 		this.#onRightCallback = opts?.onRight;
 		this.#onExternalEditorCallback = opts?.onExternalEditor;
@@ -726,13 +732,14 @@ export class HookSelectorComponent extends OverlayPanel {
 	}
 
 	/**
-	 * A plain option list is a picker sheet. Otherwise a card headed by the
-	 * title (plus the countdown `elapsed` when a timeout runs), the extra title
-	 * lines, the slider as `tabs`, the options as a `list` keyed by original
-	 * option index, the search query while typing, and the key hints.
+	 * A plain option list is a picker sheet. Otherwise (inline, slider, or
+	 * countdown) a card headed by the title (plus the countdown `elapsed` when a
+	 * timeout runs), the extra title lines, the slider as `tabs`, the options as
+	 * a `list` keyed by original option index, the search query while typing,
+	 * and the key hints.
 	 */
 	override describe(cx: DescribeContext): NativeNode {
-		if (cx.supports("picker") && !this.#slider && !this.#countdown) return this.#describePicker();
+		if (cx.supports("picker") && !this.#inline && !this.#slider && !this.#countdown) return this.#describePicker();
 		const items = this.#menu.visibleItems;
 		const selected = this.#menu.selectedKey;
 		const query = this.#menu.query;