dsh-code 1.0.1 → 1.0.2

package/lib/index.mjs

@@ -14,12 +14,12 @@ import { PassThrough, Stream } from "node:stream";
 import process$1, { cwd, env } from "node:process";
 import { EventEmitter } from "node:events";
 import { Buffer as Buffer$1 } from "node:buffer";
+import { DEFAULT_FILE_SEARCH_EXCLUDED_DIRECTORIES, DEFAULT_FILE_SEARCH_MAX_ENTRIES, DEFAULT_FILE_SEARCH_MAX_RESULTS, WorkspaceFileSearch } from "@deepseek-ai/dsh-file-reference-local";
+import { formatSessionReferenceMention, parseSessionReferenceText } from "@deepseek-ai/dsh-session-reference";
 import { execFile, spawn } from "node:child_process";
 import { credentialKeyId, credentialKeyScope } from "@deepseek-ai/dsh-credentials";
 import { AuthorizationDeclinedError } from "@deepseek-ai/dsh-authorization";
 import { fileURLToPath } from "node:url";
-import { DEFAULT_FILE_SEARCH_EXCLUDED_DIRECTORIES, DEFAULT_FILE_SEARCH_MAX_ENTRIES, DEFAULT_FILE_SEARCH_MAX_RESULTS, WorkspaceFileSearch } from "@deepseek-ai/dsh-file-reference-local";
-import { formatSessionReferenceMention, parseSessionReferenceText } from "@deepseek-ai/dsh-session-reference";
 import { UserQuestionError } from "@deepseek-ai/dsh-user-questions";
 import { isUserInvocable } from "@deepseek-ai/dsh-skill";
 //#region node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react.production.min.js
@@ -26633,11 +26633,7 @@ function renderMarkdown(text, width, options = {}) {
 }
 //#endregion
 //#region src/render/animations.ts
-/**
-* The web StateDot "ongoing" chase in terminal form: three cells of the 3×3
-* ring trail clockwise around the eight outer positions, one braille glyph
-* per step — 8 frames × 125ms = the web's 1s cycle.
-*/
+/** Original terminal StateDot chase frames. */
 const BUSY_CHASE_FRAMES = [
 	"⣾",
 	"⣽",
@@ -26648,10 +26644,40 @@ const BUSY_CHASE_FRAMES = [
 	"⣯",
 	"⣷"
 ];
-/** Chase frame for a monotonic tick (the busy composer/Deep-diving marker). */
+/** Chase frame for a monotonic tick. */
 function busyChaseFrame(tick) {
 	return BUSY_CHASE_FRAMES[tick % BUSY_CHASE_FRAMES.length] ?? BUSY_CHASE_FRAMES[0];
 }
+/** Codex shimmer timing and geometry. */
+const DEEP_DIVING_SHIMMER_DURATION_MS = 2e3;
+const DEEP_DIVING_SPARK_BREATH_DURATION_MS = 2e3;
+/**
+* Codex's 2-second shimmer sweep, expressed in terminal ticks. The sweep has
+* ten virtual columns of padding on either side and a five-column cosine
+* highlight band, so the text changes gently rather than cycling rapidly.
+*/
+function deepDivingShimmerIntensity(index, tick, graphemeCount) {
+	if (graphemeCount <= 0) return 0;
+	const period = graphemeCount + 20;
+	const position = (tick * 33 % DEEP_DIVING_SHIMMER_DURATION_MS + DEEP_DIVING_SHIMMER_DURATION_MS) % DEEP_DIVING_SHIMMER_DURATION_MS / DEEP_DIVING_SHIMMER_DURATION_MS * period;
+	const distance = Math.abs(index + 10 - position);
+	if (distance > 5) return 0;
+	const angle = Math.PI * distance / 5;
+	return .5 * (1 + Math.cos(angle));
+}
+/** Blue RGB color for one grapheme in the Codex-style shimmer. */
+function deepDivingGradientColor(index, tick, graphemeCount, base, highlight) {
+	return blendRgb(highlight, base, deepDivingShimmerIntensity(index, tick, graphemeCount));
+}
+/** Smooth breathing intensity for the always-visible Deep diving sparkle. */
+function deepDivingSparkIntensity(tick) {
+	const phase = (tick * 33 % DEEP_DIVING_SPARK_BREATH_DURATION_MS + DEEP_DIVING_SPARK_BREATH_DURATION_MS) % DEEP_DIVING_SPARK_BREATH_DURATION_MS / DEEP_DIVING_SPARK_BREATH_DURATION_MS;
+	return .2 + .8 * (.5 + .5 * Math.cos(Math.PI * 2 * phase));
+}
+/** Blue RGB color for the breathing Deep diving sparkle. */
+function deepDivingSparkColor(tick, base, highlight) {
+	return blendRgb(highlight, base, deepDivingSparkIntensity(tick));
+}
 /** Caret visibility: half the ticks on, half off (530ms blink). */
 function caretVisible(tick) {
 	return tick % 2 === 0;
@@ -27041,6 +27067,87 @@ function effortAboveHigh(effort) {
 	return rank !== void 0 && rank > 3;
 }
 //#endregion
+//#region src/mentions.ts
+/** Menu cap on file rows; the service owns ranking and default rows. */
+const MAX_FILE_ROWS = 20;
+/** Whether a mention token is already navigating a filesystem path. */
+function isPathLikeMentionQuery(query) {
+	return /[\\/]/u.test(query);
+}
+/**
+* Create the mention API for one agent's workspace. A missing
+* `fileReferences` service (with an agent present) or `sessionReferenceResolver`
+* degrades that half to empty rows; `prepare` passes text through untouched
+* without references. An undefined agent (a bare launch before any session
+* exists) runs the official WorkspaceFileSearch over the launch cwd — the
+* same class the mounted service uses per agent — so `@` file completion
+* works from the first keystroke; session references wait for the session.
+*
+* `candidates` never reaches for `this` — the runner hands it to the input
+* editor as a detached callback, and a `this`-bound method would throw on
+* every `@` key.
+* @param ctx - context carrying the optional `fileReferences` and
+* `sessionReferenceResolver` services.
+* @param agent - the session owner; excluded from its own session candidates.
+* @param cwd - launch working directory; bounds the pre-session search.
+*/
+function createMentions(ctx, agent, cwd) {
+	const resolver = ctx.get("sessionReferenceResolver");
+	const fileReferences = ctx.get("fileReferences");
+	const sessionCapable = agent !== void 0 && resolver !== void 0;
+	let preSessionSearch;
+	const preSessionFiles = (query, signal) => {
+		preSessionSearch ??= new WorkspaceFileSearch(cwd, {
+			maxResults: DEFAULT_FILE_SEARCH_MAX_RESULTS,
+			maxEntries: DEFAULT_FILE_SEARCH_MAX_ENTRIES,
+			excludedDirectories: [...DEFAULT_FILE_SEARCH_EXCLUDED_DIRECTORIES]
+		});
+		return preSessionSearch.list(query, signal ?? new AbortController().signal);
+	};
+	return {
+		async candidates(query, signal) {
+			const needle = query.trim();
+			const [files, sessions] = await Promise.all([agent !== void 0 && fileReferences !== void 0 ? fileReferences.list(agent, needle, signal ?? new AbortController().signal).catch(() => []) : agent === void 0 ? preSessionFiles(needle, signal).catch(() => []) : Promise.resolve([]), sessionCapable && needle !== "" && !isPathLikeMentionQuery(needle) && agent !== void 0 ? resolver.listCandidates(agent, needle, 10, signal).catch(() => []) : Promise.resolve([])]);
+			const fileRows = files.slice(0, MAX_FILE_ROWS).map((candidate) => ({
+				label: candidate.path,
+				description: candidate.kind === "directory" ? "Folder" : "File",
+				kind: candidate.kind,
+				...candidate.kind === "file" ? { path: isAbsolute(candidate.path) ? candidate.path : resolve(cwd, candidate.path) } : {}
+			}));
+			const sessionRows = sessions.map((candidate) => ({
+				label: formatSessionReferenceMention(candidate),
+				description: `Session · ${candidate.cwd ?? "(no cwd)"}`,
+				kind: "session"
+			}));
+			return [...fileRows, ...sessionRows];
+		},
+		parse(text) {
+			return parseSessionReferenceText(text);
+		},
+		async prepare(parsed, signal) {
+			if (parsed.references.length === 0 || resolver === void 0 || agent === void 0) return {
+				text: parsed.text,
+				references: parsed.references
+			};
+			const prepared = await resolver.prepare(agent, [{
+				type: "text",
+				text: parsed.text
+			}], parsed.references, signal);
+			return {
+				text: prepared.content.filter((block) => block.type === "text").map((block) => block.text).join(""),
+				references: parsed.references,
+				additionalContext: prepared.additionalContext
+			};
+		},
+		sessionMention(candidate) {
+			return formatSessionReferenceMention({
+				sessionId: candidate.sessionId,
+				label: candidate.label
+			});
+		}
+	};
+}
+//#endregion
 //#region src/session-directory.ts
 /** Lightweight session-directory projection for the /resume picker. */
 /** Case-insensitive filesystems (Windows, macOS) compare paths by lowercased form. */
@@ -27970,13 +28077,20 @@ function toolDetailLines(detail, columns) {
 		default: return detail;
 	}
 }
+/** Default compact tool-card window used while the Ctrl+R fold is closed. */
+const DEFAULT_TOOL_ROWS = 3;
+/** Keep the invocation visible while making hidden tool output discoverable. */
+function compactToolLines(lines, columns) {
+	if (lines.length <= DEFAULT_TOOL_ROWS) return lines;
+	return [...lines.slice(0, 2), ...textLines("    … output hidden · Ctrl+R", columns, "dim").slice(0, 1)];
+}
 /**
 * Convert one durable transcript entry to its complete scrollable row model.
 * The source entry stays intact; only the caller's visible slice is rendered.
 * Wrapped continuations keep a hanging indent aligned under each row's
 * content (Codex history-cell alignment) instead of resetting to column 0.
 */
-function transcriptEntryLines(entry, columns, showReasoning = true, reasoningToggleHint = true) {
+function transcriptEntryLines(entry, columns, showReasoning = true, reasoningToggleHint = true, showToolDetails = showReasoning) {
 	const width = Math.max(1, Math.floor(columns));
 	switch (entry.kind) {
 		case "user": return entry.notice ? hangingStyledLines([lineSegment(promptDisplayText(entry), "dim")], width, "⤷ ", "dim", "  ", "dim") : hangingStyledLines([lineSegment(promptDisplayText(entry), "plain")], width, "❯ ", "brand", "  ", "plain");
@@ -27998,7 +28112,7 @@ function transcriptEntryLines(entry, columns, showReasoning = true, reasoningTog
 			const mark = entry.state === "running" ? "●" : entry.state === "error" ? "⨯" : "⏺";
 			const markStyle = entry.state === "running" ? "brand" : entry.state === "error" ? "error" : "success";
 			const summaryStyle = entry.state === "error" ? "error" : "dim";
-			return [
+			const lines = [
 				...hangingStyledLines([
 					lineSegment(`[${entry.ordinal}] `, "dim"),
 					lineSegment(entry.name, "brand"),
@@ -28008,6 +28122,7 @@ function transcriptEntryLines(entry, columns, showReasoning = true, reasoningTog
 				...entry.summary === "" ? [] : hangingTextLines(entry.state === "error" ? `call ${entry.ordinal}: ${entry.summary}` : entry.summary, width, "  ⎿ ", summaryStyle, "    ", summaryStyle),
 				...entry.detail === void 0 ? [] : toolDetailLines(entry.detail, width)
 			];
+			return showToolDetails ? lines : compactToolLines(lines, width);
 		}
 		case "command": {
 			const mark = entry.state === "running" ? "●" : entry.state === "error" ? "⨯" : "⏺";
@@ -28025,7 +28140,7 @@ function transcriptEntryLines(entry, columns, showReasoning = true, reasoningTog
 }
 /** Settled-history variant carrying the Ctrl+R reasoning fold. */
 function settledEntryLines(entry, columns, showReasoning) {
-	return transcriptEntryLines(entry, columns, showReasoning, false);
+	return transcriptEntryLines(entry, columns, showReasoning, false, showReasoning);
 }
 //#endregion
 //#region src/render/editor.ts
@@ -28039,9 +28154,8 @@ function settledEntryLines(entry, columns, showReasoning) {
 * grapheme boundaries) so the React state stays two primitives
 * (value, cursor) and every operation here stays pure and testable.
 *
-* Word motion deviates from Codex's UAX#29 segmentation in one deliberate
-* way: a run of same-class characters is ONE piece, so a CJK run moves as a
-* single word (two hanzi are one Alt+B step, not two).
+* Word motion follows Codex's piece semantics: whitespace separates runs,
+* punctuation runs stay atomic, and each Han grapheme is its own boundary.
 *
 * @module @deepseek-ai/dsh-code/render/editor
 */
@@ -28194,6 +28308,28 @@ function editorModel(value, columns) {
 		length: value.length
 	};
 }
+/** Split one row around the authoritative caret; every other row stays whole. */
+function editorRowParts(row, rowIndex, caretRow, cursor, caretEnabled = true) {
+	if (!caretEnabled || rowIndex !== caretRow) return {
+		before: "",
+		caret: "",
+		after: row.text,
+		hasCaret: false
+	};
+	const at = row.offsets.indexOf(cursor);
+	if (at < 0) return {
+		before: "",
+		caret: "",
+		after: row.text,
+		hasCaret: false
+	};
+	return {
+		before: at > 0 ? row.text.slice(0, row.cuts[at]) : "",
+		caret: at < row.cuts.length - 1 ? row.text.slice(row.cuts[at], row.cuts[at + 1]) : " ",
+		after: at < row.cuts.length - 1 ? row.text.slice(row.cuts[at + 1]) : "",
+		hasCaret: true
+	};
+}
 /** Map a cursor offset to its caret site on the wrapped rows. */
 function caretSite(model, offset) {
 	const target = Math.max(0, Math.min(model.length, offset));
@@ -28218,7 +28354,9 @@ function caretSite(model, offset) {
 */
 function moveCursorVertically(model, offset, preferredColumn, delta) {
 	const target = caretSite(model, offset).row + delta;
-	if (target < 0 || target >= model.rows.length || delta === 0) return offset;
+	if (delta === 0) return offset;
+	if (target < 0) return 0;
+	if (target >= model.rows.length) return model.length;
 	const row = model.rows[target];
 	const wanted = Math.max(0, Math.min(preferredColumn, row.columns[row.columns.length - 1]));
 	let best = 0;
@@ -28238,24 +28376,28 @@ function lineBounds(value, offset) {
 }
 /** Codex WORD_SEPARATORS: punctuation runs are their own word pieces. */
 const WORD_SEPARATORS = /* @__PURE__ */ new Set("`~!@#$%^&*()-=+[{]}\\|;:'\",.<>/?");
+const HAN_GRAPHEME = /^\p{Script=Han}(?:\p{Mark}|\uFE0F)*$/u;
+const UNICODE_PUNCTUATION = /^\p{P}+$/u;
 function classifyGrapheme(text) {
 	if (/^\s$/u.test(text)) return "space";
-	return WORD_SEPARATORS.has(text) ? "punct" : "word";
+	return WORD_SEPARATORS.has(text) || UNICODE_PUNCTUATION.test(text) ? "punct" : "word";
 }
-/** Maximal same-class runs of graphemes as [start, end) spans. */
+/** Maximal same-class runs; Han graphemes deliberately stay one run each. */
 function pieceRuns(value) {
 	const runs = [];
 	let current;
 	for (const span of splitGraphemes(value)) {
 		const klass = span.text === "\n" ? "space" : classifyGrapheme(span.text);
-		if (current !== void 0 && current.class === klass) {
+		const atomic = klass === "word" && HAN_GRAPHEME.test(span.text);
+		if (current !== void 0 && current.class === klass && !current.atomic && !atomic) {
 			current.end = span.end;
 			continue;
 		}
 		current = {
 			start: span.start,
 			end: span.end,
-			class: klass
+			class: klass,
+			atomic
 		};
 		runs.push(current);
 	}
@@ -28266,10 +28408,9 @@ function pieceRuns(value) {
 * START of the trailing non-space piece (extending over separator pieces).
 */
 function moveWordLeft(value, offset) {
-	const cursor = Math.max(0, Math.min(value.length, offset));
+	const cursor = clampCursor(value, offset);
 	const runs = pieceRuns(value);
-	let index = runs.length - 1;
-	while (index >= 0 && runs[index].end > cursor) index -= 1;
+	let index = runs.findLastIndex((run) => run.start < cursor);
 	if (index < 0) return 0;
 	if (runs[index].class === "space") {
 		index -= 1;
@@ -28284,10 +28425,9 @@ function moveWordLeft(value, offset) {
 * the leading non-space piece (extending over separator pieces).
 */
 function moveWordRight(value, offset) {
-	const cursor = Math.max(0, Math.min(value.length, offset));
+	const cursor = clampCursor(value, offset);
 	const runs = pieceRuns(value);
-	let index = 0;
-	while (index < runs.length && runs[index].start < cursor) index += 1;
+	let index = runs.findIndex((run) => run.end > cursor);
 	if (index >= runs.length) return value.length;
 	if (runs[index].class === "space") {
 		index += 1;
@@ -28376,6 +28516,62 @@ function insertText(value, cursor, text) {
 		killed: void 0
 	};
 }
+/** Ctrl+A: current logical line start, then the previous line start on repeat. */
+function moveToLineStart(value, cursor, crossOnRepeat) {
+	const site = clampCursor(value, cursor);
+	const bounds = lineBounds(value, site);
+	if (!crossOnRepeat || site !== bounds.start || bounds.start === 0) return bounds.start;
+	return lineBounds(value, bounds.start - 1).start;
+}
+/** Ctrl+E: current logical line end, then the next line end on repeat. */
+function moveToLineEnd(value, cursor, crossOnRepeat) {
+	const site = clampCursor(value, cursor);
+	const bounds = lineBounds(value, site);
+	if (!crossOnRepeat || site !== bounds.end || bounds.end >= value.length) return bounds.end;
+	return lineBounds(value, bounds.end + 1).end;
+}
+/**
+* Remap a captured range when all intervening edits are wholly before or
+* wholly after it. An edit overlapping either boundary invalidates the
+* anchor instead of guessing and inserting content at a surprising place.
+*/
+function remapStableRange(original, current, range) {
+	const start = Math.max(0, Math.min(original.length, range.start));
+	const end = Math.max(start, Math.min(original.length, range.end));
+	if (original === current) return {
+		start,
+		end
+	};
+	let prefix = 0;
+	const shared = Math.min(original.length, current.length);
+	while (prefix < shared && original[prefix] === current[prefix]) prefix += 1;
+	let suffix = 0;
+	while (suffix < original.length - prefix && suffix < current.length - prefix && original[original.length - 1 - suffix] === current[current.length - 1 - suffix]) suffix += 1;
+	const oldChangedEnd = original.length - suffix;
+	if (prefix >= end) return {
+		start,
+		end
+	};
+	if (oldChangedEnd <= start) {
+		const delta = current.length - original.length;
+		return {
+			start: start + delta,
+			end: end + delta
+		};
+	}
+}
+/** Replace a current range while preserving a cursor moved after capture. */
+function replaceRangePreservingCursor(value, cursor, range, replacement) {
+	const start = Math.max(0, Math.min(value.length, range.start));
+	const end = Math.max(start, Math.min(value.length, range.end));
+	const site = clampCursor(value, cursor);
+	const nextCursor = site <= start ? site : site >= end ? site + replacement.length - (end - start) : start + replacement.length;
+	return {
+		value: value.slice(0, start) + replacement + value.slice(end),
+		cursor: nextCursor,
+		killed: void 0
+	};
+}
 /**
 * Composer editor row budget: the editor itself never grows past this many
 * physical rows; deeper drafts scroll internally to keep the caret visible.
@@ -28385,14 +28581,73 @@ function composerMaxRows(terminalRows) {
 	return Math.max(1, Math.min(6, Math.floor((Math.max(1, terminalRows) - 10) / 3)));
 }
 /**
-* Codex `should_handle_navigation`: Up/Down walk history only from an empty
-* draft, or from a boundary of a draft that still exactly matches the last
-* recalled entry. Any interior cursor position keeps vertical caret movement.
+* History navigation starts with Up on an empty draft, or after visual
+* movement has reached the directional text edge of an unchanged recalled
+* entry. Every other position remains under textarea movement.
 */
-function shouldRecallNavigate(value, cursor, lastRecalled) {
-	if (value === "") return true;
-	if (cursor !== 0 && cursor !== value.length) return false;
-	return lastRecalled === value;
+function shouldRecallNavigate(value, cursor, lastRecalled, direction) {
+	if (value === "") return direction < 0;
+	if (lastRecalled !== value) return false;
+	return direction < 0 ? cursor === 0 : cursor === value.length;
+}
+//#endregion
+//#region src/keyboard.ts
+/**
+* Keyboard enhancement protocol (Codex `keyboard_modes` parity) and the
+* kitty CSI-u normalization layer.
+*
+* The TUI pushes the kitty keyboard protocol with DISAMBIGUATE_ESCAPE_CODES
+* and REPORT_ALTERNATE_KEYS (flags 1|4 = `\x1b[>5u`). Event types are
+* deliberately NOT requested: Ink 5's parser cannot decode the
+* `:event-type` suffix, and repeat/release reporting buys this surface
+* nothing.
+*
+* Ink 5 also cannot parse most CSI-u forms at all — they fall through its
+* regex as unnamed sequences and get INSERTED AS DRAFT TEXT. The composer's
+* stdin read patch therefore rewrites every CSI-u form it can decode back
+* to the legacy byte or canonical sequence the existing key handling
+* already understands, before Ink ever parses the chunk.
+* @module @deepseek-ai/dsh-code/keyboard
+*/
+/** Push keyboard enhancement (modifyOtherKeys off, kitty flags 1|4). */
+const KEYBOARD_ENHANCE_ENABLE = "\x1B[>4;0m\x1B[>5u";
+/** Pop the enhancement stack and reset modifyOtherKeys (exit path). */
+const KEYBOARD_ENHANCE_DISABLE = "\x1B[<u\x1B[>4;0m";
+const DSH_ENABLE_KEYBOARD_ENHANCEMENT = "DSH_ENABLE_KEYBOARD_ENHANCEMENT";
+function parseBooleanEnv(value) {
+	if (value === void 0) return void 0;
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "1" || normalized === "true" || normalized === "yes") return true;
+	if (normalized === "0" || normalized === "false" || normalized === "no") return false;
+}
+/** True when the process is running inside the VS Code integrated terminal. */
+function isVsCodeTerminalEnv(env = process.env) {
+	return env.TERM_PROGRAM?.trim().toLowerCase() === "vscode" || env.VSCODE_INJECTION === "1";
+}
+/** Whether to push Kitty keyboard enhancement for the current terminal. */
+function shouldEnableKeyboardEnhancement(env = process.env) {
+	if (parseBooleanEnv(env["DSH_DISABLE_KEYBOARD_ENHANCEMENT"]) === true) return false;
+	const explicitEnable = parseBooleanEnv(env[DSH_ENABLE_KEYBOARD_ENHANCEMENT]);
+	if (explicitEnable !== void 0) return explicitEnable;
+	return !isVsCodeTerminalEnv(env);
+}
+/** Enable bracketed paste reporting. */
+const BRACKETED_PASTE_ENABLE = "\x1B[?2004h";
+/** Disable bracketed paste reporting. */
+const BRACKETED_PASTE_DISABLE = "\x1B[?2004l";
+/** Enable terminal focus-in/focus-out reporting (xterm focus protocol). */
+const TERMINAL_FOCUS_REPORT_ENABLE = "\x1B[?1004h";
+/** Disable terminal focus-in/focus-out reporting. */
+const TERMINAL_FOCUS_REPORT_DISABLE = "\x1B[?1004l";
+/**
+* Remove xterm focus reports from one input chunk and update the caller's
+* focus state. Focus reports are terminal protocol, not composer text.
+*/
+function stripTerminalFocusEvents(chunk, onFocus) {
+	return chunk.replace(/\x1b\[(I|O)/gu, (_whole, event) => {
+		onFocus(event === "I");
+		return "";
+	});
 }
 /** Bracketed paste markers as Ink delivers them (it strips the leading ESC). */
 const PASTE_START_MARKER = "[200~";
@@ -28464,6 +28719,98 @@ function normalizeKeyboardChunk(chunk) {
 		}) ?? whole;
 	});
 }
+const HOME_SEQUENCES = [
+	"\x1B[H",
+	"\x1B[1~",
+	"\x1B[7~",
+	"\x1BOH"
+];
+const END_SEQUENCES = [
+	"\x1B[F",
+	"\x1B[4~",
+	"\x1B[8~",
+	"\x1BOF"
+];
+/** Parse one CSI functional-key sequence at `offset`. */
+function functionalToken(chunk, offset) {
+	const tail = chunk.slice(offset);
+	for (const sequence of HOME_SEQUENCES) if (tail.startsWith(sequence)) return {
+		token: { kind: "home" },
+		length: sequence.length
+	};
+	for (const sequence of END_SEQUENCES) if (tail.startsWith(sequence)) return {
+		token: { kind: "end" },
+		length: sequence.length
+	};
+	const modifiedHome = /^\x1b\[1;(\d+)H/u.exec(tail);
+	if (modifiedHome !== null) return {
+		token: { kind: "home" },
+		length: modifiedHome[0].length
+	};
+	const modifiedEnd = /^\x1b\[1;(\d+)F/u.exec(tail);
+	if (modifiedEnd !== null) return {
+		token: { kind: "end" },
+		length: modifiedEnd[0].length
+	};
+	const modifiedDelete = /^\x1b\[3(?:;(\d+))?~/u.exec(tail);
+	if (modifiedDelete !== null) {
+		const modifiers = Number.parseInt(modifiedDelete[1] ?? "1", 10) - 1;
+		return {
+			token: { kind: (modifiers & 2) !== 0 || (modifiers & 4) !== 0 ? "delete-word-forward" : "delete-forward" },
+			length: modifiedDelete[0].length
+		};
+	}
+}
+/**
+* Tokenize a stdin chunk containing at least one editor-only key. Ink calls
+* `useInput` once for a pasted/batched chunk, so preserving each action here
+* prevents repeated Backspace/Home/End/Delete presses from collapsing into
+* one blurred key event. Unknown escape sequences return undefined and stay
+* under Ink's ownership.
+*/
+function tokenizeRawEditorChunk(chunk) {
+	const tokens = [];
+	let text = "";
+	let special = false;
+	const flushText = () => {
+		if (text === "") return;
+		tokens.push({
+			kind: "text",
+			text
+		});
+		text = "";
+	};
+	for (let offset = 0; offset < chunk.length;) {
+		if (chunk.startsWith("\x1B", offset) || chunk.startsWith("\x1B\b", offset)) {
+			flushText();
+			tokens.push({ kind: "delete-word-backward" });
+			special = true;
+			offset += 2;
+			continue;
+		}
+		const functional = functionalToken(chunk, offset);
+		if (functional !== void 0) {
+			flushText();
+			tokens.push(functional.token);
+			special = true;
+			offset += functional.length;
+			continue;
+		}
+		const char = chunk[offset];
+		if (char === "" || char === "\b") {
+			flushText();
+			tokens.push({ kind: "delete-backward" });
+			special = true;
+			offset += 1;
+			continue;
+		}
+		if (char === "\x1B") return void 0;
+		text += char;
+		offset += 1;
+	}
+	flushText();
+	return special ? tokens : void 0;
+}
 //#endregion
 //#region src/kernel-panels.ts
 /** Bounded, composer-safe panels for preset, session, and plugin kernel views. */
@@ -29923,11 +30270,15 @@ async function inspectImagePaths(paths, attachments, cwd = process.cwd()) {
 	return inspected;
 }
 /** Read, validate, and persist an ordered image path list as model content blocks. */
-async function saveImagePaths(paths, attachments) {
+async function saveImagePaths(paths, attachments, signal) {
 	if (paths.length === 0) return [];
 	if (attachments === void 0) throw new Error("image attachments are unavailable in this profile");
+	const checkCancelled = () => {
+		if (signal?.aborted === true) throw new Error("image submission cancelled");
+	};
 	const inputs = [];
 	for (const path of paths) {
+		checkCancelled();
 		let data;
 		try {
 			data = await readFile(path);
@@ -29942,7 +30293,10 @@ async function saveImagePaths(paths, attachments) {
 			name: basename(path)
 		});
 	}
-	return (await attachments.saveImages(inputs)).map((attachment) => ({
+	checkCancelled();
+	const refs = await attachments.saveImages(inputs);
+	checkCancelled();
+	return refs.map((attachment) => ({
 		type: "image",
 		attachment
 	}));
@@ -30098,14 +30452,15 @@ function padColumns(text, width) {
 	return clipped + " ".repeat(Math.max(0, width - visibleColumns(clipped)));
 }
 /** Interval-driven frame counter for one self-contained animated leaf. */
-function useFrames(intervalMs) {
+function useFrames(intervalMs, active = true) {
 	const [tick, setTick] = (0, import_react.useState)(0);
 	(0, import_react.useEffect)(() => {
+		if (!active) return;
 		const id = setInterval(() => setTick((current) => current + 1), intervalMs);
 		return () => {
 			clearInterval(id);
 		};
-	}, [intervalMs]);
+	}, [active, intervalMs]);
 	return tick;
 }
 /**
@@ -30122,12 +30477,7 @@ function useStableInput(handler, active) {
 	}, []);
 	useInput(stableHandler, { isActive: active });
 }
-/**
-* The web StateDot "ongoing" chase in terminal form: three cells of the 3×3
-* ring trail clockwise around the eight outer positions (8 frames × 125ms =
-* the web's 1s cycle). Replaces the plain busy ellipsis as the composer's
-* prompt marker and leads the Deep-diving line.
-*/
+/** The original web StateDot chase used by the busy composer marker. */
 function BusyChase() {
 	const tick = useFrames(125);
 	return (0, import_react.createElement)(Text, { color: inkColor(getPalette().brandBright) }, busyChaseFrame(tick) + " ");
@@ -30137,21 +30487,46 @@ function Caret() {
 	const tick = useFrames(530);
 	return (0, import_react.createElement)(Text, null, caretVisible(tick) ? "▍" : " ");
 }
-/** Blinking input cursor: inverse block while the caret phase is on. */
-function CursorBlock({ char }) {
-	const tick = useFrames(530);
-	return (0, import_react.createElement)(Text, { inverse: caretVisible(tick) || void 0 }, char);
+/** One resettable input-caret phase shared by the entire composer. */
+function useCursorBlink(active) {
+	const [epoch, setEpoch] = (0, import_react.useState)(0);
+	const [visible, setVisible] = (0, import_react.useState)(true);
+	(0, import_react.useEffect)(() => {
+		setVisible(true);
+		if (!active) return;
+		const id = setInterval(() => setVisible((current) => !current), 530);
+		return () => {
+			clearInterval(id);
+		};
+	}, [active, epoch]);
+	return {
+		visible,
+		reset: (0, import_react.useCallback)(() => {
+			setVisible(true);
+			setEpoch((current) => current + 1);
+		}, [])
+	};
 }
 /**
-* The busy line, web TurnStatus contract: the StateDot chase leads the plain
-* `Deep diving...` label, with the elapsed clock appended only once the turn
-* has clearly been running (15s) — anchored to `turn/start` so a resumed
-* mid-turn keeps the real time.
+* The busy line, web TurnStatus contract: a continuously moving blue gradient
+* paints the complete `Deep diving...` label, with the elapsed clock appended
+* only once the turn has clearly been running (15s) — anchored to `turn/start`
+* so a resumed mid-turn keeps the real time.
 */
 function DeepDivingLine({ since }) {
-	useFrames(1e3);
+	const tick = useFrames(33);
 	const elapsed = since === 0 ? 0 : Date.now() - since;
-	return (0, import_react.createElement)(Box, { flexDirection: "row" }, (0, import_react.createElement)(BusyChase), (0, import_react.createElement)(Text, { dimColor: true }, elapsed >= 15e3 ? `Deep diving... ${runClock(elapsed)}` : "Deep diving..."));
+	const text = elapsed >= 15e3 ? `✻ Deep diving... ${runClock(elapsed)}` : "✻ Deep diving...";
+	const palette = getPalette();
+	const graphemes = splitGraphemes(text);
+	return (0, import_react.createElement)(Text, { wrap: "truncate-end" }, ...graphemes.map((grapheme, index) => {
+		const sparkle = grapheme.text === "✻";
+		return (0, import_react.createElement)(Text, {
+			key: `${grapheme.start}-${grapheme.end}`,
+			color: inkColor(sparkle ? deepDivingSparkColor(tick, palette.brandDeep, palette.brandBright) : deepDivingGradientColor(index, tick, graphemes.length, palette.brandDeep, palette.brandBright)),
+			bold: sparkle || void 0
+		}, grapheme.text);
+	}));
 }
 /**
 * The streaming buffer rendered with a hard size cap: the live region must
@@ -31730,49 +32105,6 @@ function HelpPanel({ descriptors, skills, commandError, skillError, onClose }) {
 function verboseLine(text, columns) {
 	return truncateColumns(displayText(text).replace(/\n/gu, " ↵ ").replace(/\t/gu, "  "), Math.max(1, columns));
 }
-/** Identify one whole-chunk key sequence Ink drops or blurs. */
-function annotateRawKey(chunk) {
-	switch (chunk) {
-		case "": return "delete-backward";
-		case "\x1B":
-		case "\x1B\b": return "delete-word-backward";
-		case "\x1B[3~":
-		case "\x1B[3;2~": return "delete-forward";
-		case "\x1B[3;3~":
-		case "\x1B[3;5~": return "delete-word-forward";
-		case "\x1B[H":
-		case "\x1B[1~":
-		case "\x1B[7~":
-		case "\x1BOH": return "home";
-		case "\x1B[F":
-		case "\x1B[4~":
-		case "\x1B[8~":
-		case "\x1BOF": return "end";
-		default: return;
-	}
-}
-/**
-* One-row editor window keeping the logical cursor visible in long drafts.
-* The caret and its surroundings slice at grapheme boundaries: splitting a
-* star-plane surrogate pair would render an isolated half under the block
-* caret with a width the terminal never draws.
-*/
-function editorWindow(value, cursor, columns) {
-	const width = Math.max(1, columns);
-	const normalize = (text) => displayText(text).replace(/\n/gu, "↵").replace(/\t/gu, "  ");
-	const site = clampCursor(value, cursor);
-	const caretSpan = splitGraphemes(value).find((span) => span.start === site);
-	const caret = caretSpan === void 0 ? " " : normalize(caretSpan.text);
-	const rest = value.slice(caretSpan === void 0 ? site : caretSpan.end);
-	const remaining = Math.max(0, width - visibleColumns(caret));
-	const afterBudget = Math.min(Math.floor(remaining / 3), visibleColumns(normalize(rest)));
-	const beforeBudget = Math.max(0, remaining - afterBudget);
-	return {
-		before: beforeBudget === 0 ? "" : displayTail(normalize(value.slice(0, site)), beforeBudget, 1).text,
-		caret,
-		after: afterBudget === 0 ? "" : truncateColumns(normalize(rest), afterBudget)
-	};
-}
 /** The empty-composer placeholder text (shared by the static and wave paths). */
 const COMPOSER_PLACEHOLDER = "type a message · / commands · @ mentions";
 /** Adjacent cells with identical styling merge into one styled Text span. */
@@ -32023,7 +32355,9 @@ function CompletionMenu({ active, mention, index, rows }) {
 */
 function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, interrupt, quit, openModel, openEffort, openHelp, openMode, openPermission, openResume, openPlugin, openJobs, openStatusline, openTheme, openHistory, openAgents, openSubagent, openTodos, openDelete, openDiff, reviewChanges, deleteConfirm, confirmDelete, cancelDelete, createSession, forkSession, cancelSessionSwitch, notify, hasNotice, dismissNotice, toggleReasoning, openVerbose, clearView, refresh, loadMentions, inspectImages, prepareImages, cyclePermission, exportTranscript, renameTitle, copyLastResponse, recallSpace, recordLocal, recordHistory, queued, cancelQueued, historyFill, historyConsumed, waveTier, waveStyle, maxRows, onEditorRows }) {
 	const columns = useStdout().stdout?.columns ?? 80;
+	const editorColumns = Math.max(1, columns - 6);
 	const stdin = useStdin().stdin;
+	const focusReporting = isVsCodeTerminalEnv();
 	const [value, setValue] = (0, import_react.useState)("");
 	const [cursor, setCursor] = (0, import_react.useState)(0);
 	const valueRef = (0, import_react.useRef)(value);
@@ -32034,22 +32368,37 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 	const draftImagesRef = (0, import_react.useRef)(draftImages);
 	draftImagesRef.current = draftImages;
 	const [preparingImages, setPreparingImages] = (0, import_react.useState)(false);
+	const prepareAbortRef = (0, import_react.useRef)(void 0);
+	const prepareEpochRef = (0, import_react.useRef)(0);
+	const { visible: cursorVisible, reset: resetCursorBlink } = useCursorBlink(active && !frozen && !preparingImages);
+	(0, import_react.useEffect)(() => () => {
+		prepareEpochRef.current += 1;
+		prepareAbortRef.current?.abort();
+	}, []);
 	const killRef = (0, import_react.useRef)("");
 	const preferredColumnRef = (0, import_react.useRef)(null);
 	const editorScrollRef = (0, import_react.useRef)(0);
 	const pasteBracketRef = (0, import_react.useRef)(false);
 	/** Cancels the pending lost-paste safety timer (undefined when disarmed). */
 	const pasteBracketCancelRef = (0, import_react.useRef)(void 0);
-	/** Annotation of the stdin chunk Ink is about to deliver to useInput. */
-	const rawAnnotation = (0, import_react.useRef)(void 0);
+	/** Ordered editor tokens from the stdin chunk Ink is about to deliver. */
+	const rawEditorTokens = (0, import_react.useRef)(void 0);
+	/** VS Code focus state from xterm focus-report events; starts focused. */
+	const terminalFocusedRef = (0, import_react.useRef)(true);
 	const recall = (0, import_react.useRef)(beginRecall([], ""));
+	(0, import_react.useEffect)(() => {
+		preferredColumnRef.current = null;
+	}, [editorColumns]);
 	(0, import_react.useEffect)(() => {
 		if (historyFill === void 0) return;
 		const safe = sanitizeDraftText(historyFill.text);
 		draftImagesRef.current = [];
 		setDraftImages([]);
+		valueRef.current = safe;
+		cursorRef.current = safe.length;
 		setValue(safe);
 		setCursor(safe.length);
+		resetCursorBlink();
 		preferredColumnRef.current = null;
 		setDismissedMenuValue(void 0);
 		recall.current = {
@@ -32062,7 +32411,8 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 	}, [
 		historyFill,
 		recallSpace,
-		historyConsumed
+		historyConsumed,
+		resetCursorBlink
 	]);
 	(0, import_react.useEffect)(() => {
 		setDraftImages((current) => {
@@ -32078,13 +32428,16 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 			const chunk = originalRead(...args);
 			if (chunk === null) return chunk;
 			const normalized = normalizeKeyboardChunk(typeof chunk === "string" ? chunk : String(chunk));
-			rawAnnotation.current = annotateRawKey(normalized);
-			return normalized;
+			const input = focusReporting ? stripTerminalFocusEvents(normalized, (focused) => {
+				terminalFocusedRef.current = focused;
+			}) : normalized;
+			rawEditorTokens.current = tokenizeRawEditorChunk(input);
+			return input;
 		};
 		return () => {
 			stdin.read = originalRead;
 		};
-	}, [stdin]);
+	}, [focusReporting, stdin]);
 	if (recall.current.entries !== recallSpace) {
 		const index = recall.current.index === null || recall.current.index < recallSpace.length ? recall.current.index : null;
 		recall.current = {
@@ -32106,6 +32459,7 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 	};
 	const mentionActive = mentionToken !== void 0;
 	const [mentionRows, setMentionRows] = (0, import_react.useState)([]);
+	const mentionRequestRef = (0, import_react.useRef)(0);
 	const sameImagePath = (left, right) => process.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right;
 	const uniqueImageMarker = (name, source, reserved = []) => {
 		const safeName = singleLineText(sanitizeDraftText(name));
@@ -32131,6 +32485,8 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 		return true;
 	};
 	const insertDroppedImages = (paths) => {
+		const originalValue = valueRef.current;
+		const originalCursor = cursorRef.current;
 		notify(`checking ${paths.length} image${paths.length === 1 ? "" : "s"}…`);
 		inspectImages(paths).then((inspected) => {
 			const additions = [];
@@ -32148,14 +32504,24 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 				notify("those images are already attached", "warning");
 				return;
 			}
-			const at = cursorRef.current;
 			const current = valueRef.current;
+			const anchor = remapStableRange(originalValue, current, {
+				start: originalCursor,
+				end: originalCursor
+			});
+			if (anchor === void 0) {
+				notify("draft changed at the image drop point; drop the images again", "warning");
+				return;
+			}
+			const at = anchor.start;
 			const insertion = `${at > 0 && !/\s$/u.test(current.slice(0, at)) ? " " : ""}${markers.join(" ")}${current.slice(at) === "" ? "" : " "}`;
-			const next = current.slice(0, at) + insertion + current.slice(at);
-			valueRef.current = next;
-			cursorRef.current = at + insertion.length;
-			setValue(next);
-			setCursor(cursorRef.current);
+			const edit = replaceRangePreservingCursor(current, cursorRef.current, anchor, insertion);
+			const nextCursor = current === originalValue && cursorRef.current === originalCursor ? at + insertion.length : edit.cursor;
+			valueRef.current = edit.value;
+			cursorRef.current = nextCursor;
+			setValue(edit.value);
+			setCursor(nextCursor);
+			resetCursorBlink();
 			const nextImages = [...draftImagesRef.current, ...additions];
 			draftImagesRef.current = nextImages;
 			setDraftImages(nextImages);
@@ -32165,14 +32531,21 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 		});
 	};
 	(0, import_react.useEffect)(() => {
+		const requestId = mentionRequestRef.current + 1;
+		mentionRequestRef.current = requestId;
 		if (!active || !mentionActive) {
 			setMentionRows([]);
 			return;
 		}
 		const controller = new AbortController();
-		setMentionRows([]);
-		loadMentions(mentionToken.query, controller.signal).then((rows) => setMentionRows(rows), () => {});
+		const query = mentionToken.query;
+		const timer = setTimeout(() => {
+			loadMentions(query, controller.signal).then((rows) => {
+				if (!controller.signal.aborted && mentionRequestRef.current === requestId) setMentionRows(rows);
+			}, () => {});
+		}, 50);
 		return () => {
+			clearTimeout(timer);
 			controller.abort();
 		};
 	}, [
@@ -32180,8 +32553,9 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 		mentionActive,
 		mentionToken?.query
 	]);
-	const menuActive = (slashActive || mentionActive) && dismissedMenuValue !== value;
-	const menuRows = mentionActive ? mentionRows.map((row) => ({
+	const menuActive = !preparingImages && (slashActive || mentionActive) && dismissedMenuValue !== value;
+	const visibleMentionRows = mentionToken !== void 0 && isPathLikeMentionQuery(mentionToken.query) ? mentionRows.filter((row) => row.kind !== "session") : mentionRows;
+	const menuRows = mentionActive ? visibleMentionRows.map((row) => ({
 		label: row.label.startsWith("@") ? row.label : `@${row.label}${row.kind === "directory" ? "/" : ""}`,
 		description: row.description,
 		origin: "mention"
@@ -32189,34 +32563,45 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 	/** Accept the highlighted completion-menu candidate into the draft. */
 	const acceptMenuCandidate = () => {
 		if (mentionActive && mentionToken !== void 0) {
-			const row = mentionRows[completionIndex % mentionRows.length];
+			if (visibleMentionRows.length === 0) return;
+			const row = visibleMentionRows[completionIndex % visibleMentionRows.length];
 			if (row !== void 0) {
 				if (row.kind === "file" && row.path !== void 0 && looksLikeImagePath(row.path)) {
 					const tokenText = value.slice(mentionToken.start, cursor);
 					const start = mentionToken.start;
+					const originalValue = value;
 					notify(`checking image ${basename(row.path)}…`);
 					inspectImages([row.path]).then((inspected) => {
 						const inspection = inspected[0];
 						if (inspection === void 0) return;
 						const current = valueRef.current;
-						if (current.slice(start, start + tokenText.length) !== tokenText) return;
+						const anchor = remapStableRange(originalValue, current, {
+							start,
+							end: start + tokenText.length
+						});
+						if (anchor === void 0 || current.slice(anchor.start, anchor.end) !== tokenText) {
+							notify("draft changed around the image mention; select it again", "warning");
+							return;
+						}
 						if (draftImagesRef.current.some((image) => sameImagePath(image.path, inspection.path))) {
-							const next = current.slice(0, start) + current.slice(start + tokenText.length);
-							valueRef.current = next;
-							cursorRef.current = start;
-							setValue(next);
-							setCursor(start);
-							setDismissedMenuValue(next);
+							const edit = replaceRangePreservingCursor(current, cursorRef.current, anchor, "");
+							valueRef.current = edit.value;
+							cursorRef.current = edit.cursor;
+							setValue(edit.value);
+							setCursor(edit.cursor);
+							resetCursorBlink();
+							setDismissedMenuValue(edit.value);
 							notify(`${inspection.name} is already attached`, "warning");
 							return;
 						}
 						const marker = uniqueImageMarker(inspection.name, "mention");
-						const next = current.slice(0, start) + marker + current.slice(start + tokenText.length);
-						valueRef.current = next;
-						cursorRef.current = start + marker.length;
-						setValue(next);
-						setCursor(cursorRef.current);
-						setDismissedMenuValue(next);
+						const edit = replaceRangePreservingCursor(current, cursorRef.current, anchor, marker);
+						valueRef.current = edit.value;
+						cursorRef.current = edit.cursor;
+						setValue(edit.value);
+						setCursor(edit.cursor);
+						resetCursorBlink();
+						setDismissedMenuValue(edit.value);
 						registerDraftImage(inspection, marker);
 						notify(`${inspection.name} ready for the next message`);
 					}, (reason) => {
@@ -32227,14 +32612,25 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 					return;
 				}
 				const insertion = row.label.startsWith("@") ? row.label : `@${row.label}${row.kind === "directory" ? "/" : ""}`;
-				setValue(value.slice(0, mentionToken.start) + insertion + value.slice(cursor));
-				setCursor(mentionToken.start + insertion.length);
+				const nextValue = value.slice(0, mentionToken.start) + insertion + value.slice(cursor);
+				const nextCursor = mentionToken.start + insertion.length;
+				valueRef.current = nextValue;
+				cursorRef.current = nextCursor;
+				setValue(nextValue);
+				setCursor(nextCursor);
+				resetCursorBlink();
 			}
 		} else {
+			if (candidates.length === 0) return;
 			const candidate = candidates[completionIndex % candidates.length];
 			if (candidate !== void 0) {
-				setValue(`${candidate.label} `);
-				setCursor(candidate.label.length + 1);
+				const nextValue = `${candidate.label} `;
+				const nextCursor = candidate.label.length + 1;
+				valueRef.current = nextValue;
+				cursorRef.current = nextCursor;
+				setValue(nextValue);
+				setCursor(nextCursor);
+				resetCursorBlink();
 			}
 		}
 		setCompletionIndex(0);
@@ -32243,21 +32639,101 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 	/** Apply one editor edit: draft, cursor, kill buffer, menu reset. */
 	const applyEdit = (edit) => {
 		if (edit.killed !== void 0 && edit.killed !== "") killRef.current = edit.killed;
+		valueRef.current = edit.value;
+		cursorRef.current = edit.cursor;
 		setValue(edit.value);
 		setCursor(edit.cursor);
+		resetCursorBlink();
 		preferredColumnRef.current = null;
 		setCompletionIndex(0);
 		setDismissedMenuValue(void 0);
 	};
 	/** Move the cursor without editing; horizontal moves clear the column preference. */
 	const moveCursorTo = (next) => {
-		if (next === cursor) return;
+		resetCursorBlink();
+		if (next === cursorRef.current) return;
+		cursorRef.current = next;
 		setCursor(next);
 		preferredColumnRef.current = null;
 	};
-	useInput((input, key) => {
+	/** Apply an ordered raw-key batch against one current draft snapshot. */
+	const applyRawEditorTokens = (tokens) => {
+		let nextValue = valueRef.current;
+		let nextCursor = cursorRef.current;
+		for (const token of tokens) {
+			if (token.kind === "text") {
+				const edit = insertText(nextValue, nextCursor, token.text);
+				nextValue = edit.value;
+				nextCursor = edit.cursor;
+				continue;
+			}
+			if (token.kind === "home") {
+				nextCursor = moveToLineStart(nextValue, nextCursor, false);
+				continue;
+			}
+			if (token.kind === "end") {
+				nextCursor = moveToLineEnd(nextValue, nextCursor, false);
+				continue;
+			}
+			const edit = token.kind === "delete-backward" ? deleteBackward(nextValue, nextCursor) : token.kind === "delete-word-backward" ? deleteWordBackward(nextValue, nextCursor) : token.kind === "delete-forward" ? deleteForward(nextValue, nextCursor) : deleteWordForward(nextValue, nextCursor);
+			if (edit.killed !== void 0 && edit.killed !== "") killRef.current = edit.killed;
+			nextValue = edit.value;
+			nextCursor = edit.cursor;
+		}
+		valueRef.current = nextValue;
+		cursorRef.current = nextCursor;
+		setValue(nextValue);
+		setCursor(nextCursor);
+		resetCursorBlink();
+		preferredColumnRef.current = null;
+		setCompletionIndex(0);
+		setDismissedMenuValue(void 0);
+	};
+	const cancelImageSubmission = () => {
+		prepareEpochRef.current += 1;
+		prepareAbortRef.current?.abort();
+		prepareAbortRef.current = void 0;
+		setPreparingImages(false);
+		dismissNotice();
+		notify("image submission cancelled", "warning");
+	};
+	/** Move through visual rows first, then cross history at the true edge. */
+	const navigateVertical = (direction) => {
+		const currentValue = valueRef.current;
+		const currentCursor = cursorRef.current;
+		const model = editorModel(currentValue, editorColumns);
+		const preferred = preferredColumnRef.current ?? caretSite(model, currentCursor).column;
+		const next = moveCursorVertically(model, currentCursor, preferred, direction);
+		if (next !== currentCursor) {
+			cursorRef.current = next;
+			setCursor(next);
+			resetCursorBlink();
+			preferredColumnRef.current = preferred;
+			return;
+		}
+		if (recall.current.entries.length > 0 && shouldRecallNavigate(currentValue, currentCursor, recall.current.lastRecalled, direction)) {
+			const step = direction < 0 ? recallOlder(recall.current, currentValue) : recallNewer(recall.current);
+			recall.current = step.state;
+			if (step.entry !== void 0) {
+				const safe = sanitizeDraftText(step.entry);
+				valueRef.current = safe;
+				cursorRef.current = safe.length;
+				setValue(safe);
+				setCursor(safe.length);
+				preferredColumnRef.current = null;
+				setDismissedMenuValue(void 0);
+			}
+		}
+		resetCursorBlink();
+	};
+	useStableInput((input, key) => {
 		if (!active) return;
-		if (preparingImages) return;
+		const liveValue = valueRef.current;
+		const liveCursor = cursorRef.current;
+		if (preparingImages) {
+			if (key.escape || key.ctrl && input === "c") cancelImageSubmission();
+			return;
+		}
 		if (deleteConfirm !== void 0) {
 			if (input === "y" || input === "Y") confirmDelete();
 			else cancelDelete();
@@ -32273,6 +32749,7 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 			return;
 		}
 		if (key.ctrl && input === "r") {
+			if (focusReporting && !terminalFocusedRef.current) return;
 			toggleReasoning();
 			return;
 		}
@@ -32282,9 +32759,12 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 		}
 		if (key.ctrl && input === "c") {
 			if (busy) interrupt();
-			else if (value !== "") {
+			else if (liveValue !== "") {
+				valueRef.current = "";
+				cursorRef.current = 0;
 				setValue("");
 				setCursor(0);
+				resetCursorBlink();
 				draftImagesRef.current = [];
 				setDraftImages([]);
 				setCompletionIndex(0);
@@ -32293,8 +32773,8 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 			return;
 		}
 		if (key.ctrl && input === "d") {
-			if (value !== "") {
-				applyEdit(deleteForward(value, cursor));
+			if (liveValue !== "") {
+				applyEdit(deleteForward(liveValue, liveCursor));
 				return;
 			}
 			if (busy) notify("cancel the running turn before exiting (Esc or Ctrl+C)", "warning");
@@ -32303,7 +32783,7 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 		}
 		if (key.escape) {
 			if (menuActive) {
-				setDismissedMenuValue(value);
+				setDismissedMenuValue(liveValue);
 				return;
 			}
 			if (hasNotice) {
@@ -32313,27 +32793,33 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 			if (busy) interrupt();
 			return;
 		}
-		if (key.delete && value === "" && queued.length > 0) {
+		if (key.delete && liveValue === "" && queued.length > 0) {
 			cancelQueued(queued[queued.length - 1].messageId);
 			return;
 		}
 		if (key.return) {
 			if (pasteBracketRef.current) {
-				applyEdit(insertText(value, cursor, "\n"));
+				applyEdit(insertText(liveValue, liveCursor, "\n"));
 				return;
 			}
 			if (menuActive) {
-				if (!(!mentionActive && candidates.some((candidate) => candidate.label === value))) {
+				if (!(!mentionActive && candidates.some((candidate) => candidate.label === liveValue))) {
 					acceptMenuCandidate();
 					return;
 				}
 			}
-			const text = value.trim();
+			const text = liveValue.trim();
 			if (draftImagesRef.current.length > 0) {
+				const controller = new AbortController();
+				const epoch = prepareEpochRef.current + 1;
+				prepareEpochRef.current = epoch;
+				prepareAbortRef.current = controller;
 				setPreparingImages(true);
 				notify(`processing ${draftImagesRef.current.length} image${draftImagesRef.current.length === 1 ? "" : "s"}…`);
 				const snapshot = draftImagesRef.current;
-				prepareImages(snapshot.map((image) => image.path)).then((images) => {
+				prepareImages(snapshot.map((image) => image.path), controller.signal).then((images) => {
+					if (controller.signal.aborted || prepareEpochRef.current !== epoch) return;
+					prepareAbortRef.current = void 0;
 					setPreparingImages(false);
 					valueRef.current = "";
 					cursorRef.current = 0;
@@ -32352,13 +32838,18 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 					if (busy) steer(text, images);
 					else dispatch(text, images);
 				}, (reason) => {
+					if (controller.signal.aborted || prepareEpochRef.current !== epoch) return;
+					prepareAbortRef.current = void 0;
 					setPreparingImages(false);
 					notify(`image submission failed: ${reason instanceof Error ? reason.message : String(reason)}`, "error");
 				});
 				return;
 			}
+			valueRef.current = "";
+			cursorRef.current = 0;
 			setValue("");
 			setCursor(0);
+			resetCursorBlink();
 			setCompletionIndex(0);
 			setDismissedMenuValue(void 0);
 			if (text === "") return;
@@ -32485,6 +32976,12 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 			return;
 		}
 		if (input === "\n" || input === "\r") return;
+		if (menuActive && (key.tab || input.startsWith("	"))) {
+			const remainder = key.tab ? "" : input.slice(1);
+			acceptMenuCandidate();
+			if (remainder !== "") applyEdit(insertText(valueRef.current, cursorRef.current, remainder));
+			return;
+		}
 		if (menuActive && key.upArrow) {
 			setCompletionIndex((index) => (index + menuRows.length - 1) % menuRows.length);
 			return;
@@ -32493,119 +32990,74 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 			setCompletionIndex((index) => (index + 1) % menuRows.length);
 			return;
 		}
-		const rawKey = rawAnnotation.current;
-		if (rawKey !== void 0) {
-			if (rawKey === "home") moveCursorTo(lineBounds(value, cursor).start);
-			else if (rawKey === "end") moveCursorTo(lineBounds(value, cursor).end);
-			else if (rawKey === "delete-backward") applyEdit(deleteBackward(value, cursor));
-			else if (rawKey === "delete-word-backward") applyEdit(deleteWordBackward(value, cursor));
-			else if (rawKey === "delete-forward") applyEdit(deleteForward(value, cursor));
-			else applyEdit(deleteWordForward(value, cursor));
+		const rawTokens = rawEditorTokens.current;
+		rawEditorTokens.current = void 0;
+		if (rawTokens !== void 0) {
+			applyRawEditorTokens(rawTokens);
 			return;
 		}
 		if (key.upArrow || key.downArrow) {
-			if (recall.current.entries.length > 0 && shouldRecallNavigate(value, cursor, recall.current.lastRecalled)) {
-				const step = key.upArrow ? recallOlder(recall.current, value) : recallNewer(recall.current);
-				recall.current = step.state;
-				if (step.entry !== void 0) {
-					const safe = sanitizeDraftText(step.entry);
-					setValue(safe);
-					setCursor(safe.length);
-					preferredColumnRef.current = null;
-					setDismissedMenuValue(void 0);
-				}
-				return;
-			}
-			const model = editorModel(value, Math.max(1, columns - 6));
-			const preferred = preferredColumnRef.current ?? caretSite(model, cursor).column;
-			const next = moveCursorVertically(model, cursor, preferred, key.upArrow ? -1 : 1);
-			if (next !== cursor) {
-				setCursor(next);
-				preferredColumnRef.current = preferred;
-			}
+			navigateVertical(key.upArrow ? -1 : 1);
 			return;
 		}
 		if (key.ctrl && (input === "p" || input === "n")) {
-			const up = input === "p";
-			if (recall.current.entries.length > 0 && shouldRecallNavigate(value, cursor, recall.current.lastRecalled)) {
-				const step = up ? recallOlder(recall.current, value) : recallNewer(recall.current);
-				recall.current = step.state;
-				if (step.entry !== void 0) {
-					const safe = sanitizeDraftText(step.entry);
-					setValue(safe);
-					setCursor(safe.length);
-					preferredColumnRef.current = null;
-					setDismissedMenuValue(void 0);
-				}
-				return;
-			}
-			const model = editorModel(value, Math.max(1, columns - 6));
-			const preferred = preferredColumnRef.current ?? caretSite(model, cursor).column;
-			const next = moveCursorVertically(model, cursor, preferred, up ? -1 : 1);
-			if (next !== cursor) {
-				setCursor(next);
-				preferredColumnRef.current = preferred;
-			}
-			return;
-		}
-		if (key.tab && menuActive) {
-			acceptMenuCandidate();
+			navigateVertical(input === "p" ? -1 : 1);
 			return;
 		}
 		if (key.leftArrow) {
-			moveCursorTo(key.meta || key.ctrl ? moveWordLeft(value, cursor) : moveCursorBy(value, cursor, -1));
+			moveCursorTo(key.meta || key.ctrl ? moveWordLeft(liveValue, liveCursor) : moveCursorBy(liveValue, liveCursor, -1));
 			return;
 		}
 		if (key.rightArrow) {
-			moveCursorTo(key.meta || key.ctrl ? moveWordRight(value, cursor) : moveCursorBy(value, cursor, 1));
+			moveCursorTo(key.meta || key.ctrl ? moveWordRight(liveValue, liveCursor) : moveCursorBy(liveValue, liveCursor, 1));
 			return;
 		}
 		if (key.meta && input === "b") {
-			moveCursorTo(moveWordLeft(value, cursor));
+			moveCursorTo(moveWordLeft(liveValue, liveCursor));
 			return;
 		}
 		if (key.meta && input === "f") {
-			moveCursorTo(moveWordRight(value, cursor));
+			moveCursorTo(moveWordRight(liveValue, liveCursor));
 			return;
 		}
 		if (key.ctrl && input === "b") {
-			moveCursorTo(moveCursorBy(value, cursor, -1));
+			moveCursorTo(moveCursorBy(liveValue, liveCursor, -1));
 			return;
 		}
 		if (key.ctrl && input === "f") {
-			moveCursorTo(moveCursorBy(value, cursor, 1));
+			moveCursorTo(moveCursorBy(liveValue, liveCursor, 1));
 			return;
 		}
 		if (key.ctrl && input === "w") {
-			applyEdit(deleteWordBackward(value, cursor));
+			applyEdit(deleteWordBackward(liveValue, liveCursor));
 			return;
 		}
 		if (key.meta && input === "d") {
-			applyEdit(deleteWordForward(value, cursor));
+			applyEdit(deleteWordForward(liveValue, liveCursor));
 			return;
 		}
 		if (key.backspace || key.delete) {
-			applyEdit(deleteBackward(value, cursor));
+			applyEdit(deleteBackward(liveValue, liveCursor));
 			return;
 		}
 		if (key.ctrl && input === "a") {
-			moveCursorTo(lineBounds(value, cursor).start);
+			moveCursorTo(moveToLineStart(liveValue, liveCursor, true));
 			return;
 		}
 		if (key.ctrl && input === "e") {
-			moveCursorTo(lineBounds(value, cursor).end);
+			moveCursorTo(moveToLineEnd(liveValue, liveCursor, true));
 			return;
 		}
 		if (key.ctrl && input === "u") {
-			applyEdit(killToLineStart(value, cursor));
+			applyEdit(killToLineStart(liveValue, liveCursor));
 			return;
 		}
 		if (key.ctrl && input === "k") {
-			applyEdit(killToLineEnd(value, cursor));
+			applyEdit(killToLineEnd(liveValue, liveCursor));
 			return;
 		}
 		if (key.ctrl && input === "y") {
-			if (killRef.current !== "") applyEdit(insertText(value, cursor, killRef.current));
+			if (killRef.current !== "") applyEdit(insertText(liveValue, liveCursor, killRef.current));
 			return;
 		}
 		if (key.ctrl && input === "l") {
@@ -32638,9 +33090,9 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 				insertDroppedImages(droppedPaths);
 				return;
 			}
-			applyEdit(insertText(value, cursor, text));
+			applyEdit(insertText(valueRef.current, cursorRef.current, text));
 		}
-	});
+	}, active);
 	const [waveTick, setWaveTick] = (0, import_react.useState)(null);
 	const wavePrevious = (0, import_react.useRef)({
 		tier: null,
@@ -32658,7 +33110,7 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 		}
 		if (previous.tier !== waveTier || previous.style !== waveStyle) setWaveTick(0);
 	}, [waveTier, waveStyle]);
-	const waveActive = waveTick !== null && waveTier !== null && waveStyle !== null && waveTick * 33 < deepseekWaveDuration(waveTier, waveStyle);
+	const waveActive = !preparingImages && waveTick !== null && waveTier !== null && waveStyle !== null && waveTick * 33 < deepseekWaveDuration(waveTier, waveStyle);
 	(0, import_react.useEffect)(() => {
 		if (!waveActive) return;
 		const id = setInterval(() => {
@@ -32679,7 +33131,7 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 	const tierHues = waveTier === null ? null : deepseekWaveHues(waveTier);
 	const promptColor = tierHues === null ? inkColor(getPalette().brand) : inkColor(tierHues[0]);
 	const promptGlyph = waveTier === "flash" ? "›" : waveTier === "deepseek" ? "»" : "❯";
-	const editorViewModel = editorModel(value, Math.max(1, columns - 6));
+	const editorViewModel = editorModel(value, editorColumns);
 	const clampedCursor = clampCursor(value, cursor);
 	const caret = caretSite(editorViewModel, clampedCursor);
 	const editorWindowRows = Math.min(editorViewModel.rows.length, Math.max(1, maxRows));
@@ -32730,123 +33182,120 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 	const editorRows = [];
 	for (let index = editorWindowStart; index < Math.min(editorViewModel.rows.length, editorWindowStart + editorWindowRows); index += 1) {
 		const row = editorViewModel.rows[index];
-		const caretAt = index === caret.row ? row.offsets.indexOf(clampedCursor) : -1;
-		const before = caretAt > 0 ? row.text.slice(0, row.cuts[caretAt]) : "";
-		const caretChar = caretAt >= 0 && caretAt < row.cuts.length - 1 ? row.text.slice(row.cuts[caretAt], row.cuts[caretAt + 1]) : " ";
-		const after = caretAt < 0 ? row.text : caretAt < row.cuts.length - 1 ? row.text.slice(row.cuts[caretAt + 1]) : "";
-		const placeholder = index === 0 && value === "" && !busy;
-		const tail = placeholder ? COMPOSER_PLACEHOLDER : after;
-		const consumed = 2 + visibleColumns(before) + visibleColumns(caretChar) + visibleColumns(tail);
+		const parts = editorRowParts(row, index, caret.row, clampedCursor, !preparingImages);
+		const placeholder = index === 0 && value === "" && !busy && !preparingImages;
+		const tail = placeholder ? COMPOSER_PLACEHOLDER : parts.after;
+		const consumed = 2 + visibleColumns(parts.before) + visibleColumns(parts.caret) + visibleColumns(tail);
 		editorRows.push((0, import_react.createElement)(Text, {
 			key: index,
 			backgroundColor: bandBg,
 			wrap: "truncate-end"
-		}, index === 0 ? busy ? (0, import_react.createElement)(BusyChase) : (0, import_react.createElement)(Text, {
+		}, index === 0 ? preparingImages ? (0, import_react.createElement)(Text, {
+			color: inkColor(getPalette().warn),
+			bold: true
+		}, "… ") : busy ? (0, import_react.createElement)(BusyChase) : (0, import_react.createElement)(Text, {
 			color: promptColor,
 			bold: tierActive ? true : void 0
-		}, `${promptGlyph} `) : "  ", before, (0, import_react.createElement)(CursorBlock, {
+		}, `${promptGlyph} `) : "  ", parts.before, parts.hasCaret ? (0, import_react.createElement)(Text, {
 			key: "caret",
-			char: caretChar
-		}), placeholder ? (0, import_react.createElement)(Text, { dimColor: true }, COMPOSER_PLACEHOLDER) : after, bandFill(consumed)));
+			inverse: cursorVisible || void 0
+		}, parts.caret) : null, placeholder ? (0, import_react.createElement)(Text, { dimColor: true }, COMPOSER_PLACEHOLDER) : parts.after, bandFill(consumed)));
 	}
 	const staticEditor = (0, import_react.createElement)(Box, { flexDirection: "column" }, ...editorRows);
 	const waveRow = () => {
 		const hues = deepseekWaveHues(waveTier);
 		const style = waveStyle;
 		const bandRgb = getPalette().composerBand;
+		const visibleRows = editorViewModel.rows.slice(editorWindowStart, editorWindowStart + editorWindowRows);
+		const totalBandRows = visibleRows.length + 2;
 		const waveBg = (row, column) => {
-			const rgb = deepseekWaveColumnBg(waveTick, column, bandWidth, waveTier, style, hues, bandRgb, row, 3);
+			const rgb = deepseekWaveColumnBg(waveTick, column, bandWidth, waveTier, style, hues, bandRgb, row, totalBandRows);
 			return rgb === null ? bandBg : inkColor(rgb);
 		};
 		const blankBandRow = (row) => {
 			const blanks = [];
-			while (blanks.length < bandWidth) blanks.push({
+			for (let column = 0; column < bandWidth; column += 1) blanks.push({
 				char: " ",
-				backgroundColor: waveBg(row, blanks.length)
+				width: 1,
+				backgroundColor: waveBg(row, column)
 			});
-			return (0, import_react.createElement)(Text, { key: row }, ...waveRowSpans(blanks));
+			return (0, import_react.createElement)(Text, { key: `blank-${row}` }, ...waveRowSpans(blanks));
 		};
-		const waveEditor = editorWindow(value, cursor, Math.max(1, columns - 7));
-		const cells = [
-			{
-				char: " ",
-				backgroundColor: waveBg(1, 0)
-			},
-			{
-				char: " ",
-				backgroundColor: waveBg(1, 1)
-			},
-			{
-				char: promptGlyph,
-				color: promptColor,
-				bold: true,
-				backgroundColor: waveBg(1, 2)
-			},
-			{
-				char: " ",
-				color: promptColor,
-				backgroundColor: waveBg(1, 3)
+		const cellIndexAtColumn = (cells, target) => {
+			let column = 0;
+			for (let index = 0; index < cells.length; index += 1) {
+				if (column === target) return index;
+				column += cells[index].width ?? visibleColumns(cells[index].char);
+				if (column > target) return void 0;
 			}
-		];
-		for (const char of waveEditor.before) cells.push({
-			char,
-			backgroundColor: waveBg(1, cells.length)
-		});
-		cells.push({
-			char: waveEditor.caret,
-			inverse: true,
-			backgroundColor: waveBg(1, cells.length)
-		});
-		if (value === "" && !busy) for (let at = 0; at < 40; at += 1) cells.push({
-			char: COMPOSER_PLACEHOLDER[at],
-			dim: true,
-			backgroundColor: waveBg(1, cells.length)
-		});
-		else for (const char of waveEditor.after) cells.push({
-			char,
-			backgroundColor: waveBg(1, cells.length)
-		});
-		while (cells.length < bandWidth) cells.push({
-			char: " ",
-			backgroundColor: waveBg(1, cells.length)
+		};
+		const editorWaveRows = visibleRows.map((row, visibleIndex) => {
+			const sourceIndex = editorWindowStart + visibleIndex;
+			const bandRow = visibleIndex + 1;
+			const parts = editorRowParts(row, sourceIndex, caret.row, clampedCursor);
+			const placeholder = sourceIndex === 0 && value === "" && !busy;
+			const cells = [];
+			let usedColumns = 0;
+			const push = (char, extra = {}) => {
+				const width = visibleColumns(char);
+				cells.push({
+					char,
+					width,
+					backgroundColor: waveBg(bandRow, usedColumns),
+					...extra
+				});
+				usedColumns += width;
+			};
+			if (sourceIndex === 0) {
+				push(promptGlyph, {
+					color: promptColor,
+					bold: true
+				});
+				push(" ", { color: promptColor });
+			} else {
+				push(" ");
+				push(" ");
+			}
+			for (const span of splitGraphemes(parts.before)) push(span.text);
+			if (parts.hasCaret) push(parts.caret, { inverse: cursorVisible });
+			const tail = placeholder ? COMPOSER_PLACEHOLDER : parts.after;
+			for (const span of splitGraphemes(tail)) push(span.text, placeholder ? { dim: true } : {});
+			while (usedColumns < bandWidth) push(" ");
+			const middleBandRow = Math.floor(totalBandRows / 2);
+			if (bandRow === middleBandRow && deepseekWaveWordVisible(waveTick, waveTier, style)) {
+				const word = waveTier === "unknown" ? "Into the Unknown" : "deepseek";
+				const start = Math.max(2, Math.floor((bandWidth - word.length) / 2));
+				const indices = Array.from({ length: word.length }, (_, at) => cellIndexAtColumn(cells, start + at));
+				if (indices.every((index) => index !== void 0 && (cells[index].char === " " || cells[index].dim === true))) for (let at = 0; at < word.length; at += 1) {
+					const cell = cells[indices[at]];
+					cell.char = word[at];
+					cell.width = 1;
+					cell.color = inkColor(deepseekWaveWordHue(at, hues));
+					cell.bold = true;
+					cell.dim = false;
+				}
+			}
+			if (bandRow === middleBandRow && (waveTier === "deepseek" || waveTier === "unknown") && style === "wave") {
+				const spark = deepseekWaveSpark(waveTick);
+				const lastIndex = cellIndexAtColumn(cells, bandWidth - 1);
+				if (spark !== null && lastIndex !== void 0 && cells[lastIndex].char === " ") {
+					cells[lastIndex].char = spark;
+					cells[lastIndex].color = promptColor;
+					cells[lastIndex].bold = true;
+					cells[lastIndex].dim = false;
+				}
+			}
+			return (0, import_react.createElement)(Text, {
+				key: `editor-${sourceIndex}`,
+				wrap: "truncate-end"
+			}, ...waveRowSpans(cells));
 		});
-		if (deepseekWaveWordVisible(waveTick, waveTier, style)) {
-			const word = waveTier === "unknown" ? "Into the Unknown" : "deepseek";
-			const start = Math.max(2, Math.floor((bandWidth - word.length) / 2));
-			let clear = true;
-			for (let at = 0; at < word.length; at += 1) {
-				const cell = cells[start + at];
-				if (cell === void 0 || cell.char !== " " && cell.dim !== true) {
-					clear = false;
-					break;
-				}
-			}
-			if (clear) for (let at = 0; at < word.length; at += 1) {
-				const cell = cells[start + at];
-				cell.char = word[at];
-				cell.color = inkColor(deepseekWaveWordHue(at, hues));
-				cell.bold = true;
-				cell.dim = false;
-			}
-		}
-		if ((waveTier === "deepseek" || waveTier === "unknown") && style === "wave") {
-			const spark = deepseekWaveSpark(waveTick);
-			if (spark !== null) {
-				const last = cells[cells.length - 1];
-				if (last !== void 0 && last.char === " ") {
-					last.char = spark;
-					last.color = promptColor;
-					last.bold = true;
-					last.dim = false;
-				}
-			}
-		}
 		return (0, import_react.createElement)(Box, {
 			flexDirection: "column",
 			width: bandWidth
-		}, blankBandRow(0), (0, import_react.createElement)(Text, { wrap: "truncate-end" }, ...waveRowSpans(cells)), blankBandRow(2));
+		}, blankBandRow(0), ...editorWaveRows, blankBandRow(totalBandRows - 1));
 	};
-	return (0, import_react.createElement)(Box, { flexDirection: "column" }, menu, waveTick !== null && waveTier !== null && !busy ? waveRow() : band(staticEditor));
+	return (0, import_react.createElement)(Box, { flexDirection: "column" }, menu, waveTick !== null && waveTier !== null && waveStyle !== null && !busy && !preparingImages ? waveRow() : band(staticEditor));
 }
 /** Build one settled row (row Box plus its roomy-prompt spacers and row count). */
 function buildSettledRow(entry, index, showReasoning, columns) {
@@ -33992,7 +34441,9 @@ function isSlashLine(line) {
 /** Substitutable runner effects; production values write to the real terminal. */
 const internals = {
 	mount: (element) => {
-		process.stdout.write("\x1B[>4;0m\x1B[>5u\x1B[?2004h");
+		const keyboardEnhanced = shouldEnableKeyboardEnhancement();
+		const focusReporting = isVsCodeTerminalEnv();
+		process.stdout.write((keyboardEnhanced ? KEYBOARD_ENHANCE_ENABLE : "") + BRACKETED_PASTE_ENABLE + (focusReporting ? TERMINAL_FOCUS_REPORT_ENABLE : ""));
 		const instance = render(element, { exitOnCtrlC: false });
 		return {
 			rerender(element) {
@@ -34000,7 +34451,7 @@ const internals = {
 			},
 			unmount() {
 				instance.unmount();
-				process.stdout.write("\x1B[<u\x1B[>4;0m\x1B[?2004l");
+				process.stdout.write((keyboardEnhanced ? KEYBOARD_ENHANCE_DISABLE : "") + BRACKETED_PASTE_DISABLE + (focusReporting ? TERMINAL_FOCUS_REPORT_DISABLE : ""));
 			}
 		};
 	},
@@ -34504,83 +34955,6 @@ async function removeProviderSettings(ctx, target) {
 	}
 }
 //#endregion
-//#region src/mentions.ts
-/** Menu cap on file rows; the service owns ranking and default rows. */
-const MAX_FILE_ROWS = 20;
-/**
-* Create the mention API for one agent's workspace. A missing
-* `fileReferences` service (with an agent present) or `sessionReferenceResolver`
-* degrades that half to empty rows; `prepare` passes text through untouched
-* without references. An undefined agent (a bare launch before any session
-* exists) runs the official WorkspaceFileSearch over the launch cwd — the
-* same class the mounted service uses per agent — so `@` file completion
-* works from the first keystroke; session references wait for the session.
-*
-* `candidates` never reaches for `this` — the runner hands it to the input
-* editor as a detached callback, and a `this`-bound method would throw on
-* every `@` key.
-* @param ctx - context carrying the optional `fileReferences` and
-* `sessionReferenceResolver` services.
-* @param agent - the session owner; excluded from its own session candidates.
-* @param cwd - launch working directory; bounds the pre-session search.
-*/
-function createMentions(ctx, agent, cwd) {
-	const resolver = ctx.get("sessionReferenceResolver");
-	const fileReferences = ctx.get("fileReferences");
-	const sessionCapable = agent !== void 0 && resolver !== void 0;
-	let preSessionSearch;
-	const preSessionFiles = (query, signal) => {
-		preSessionSearch ??= new WorkspaceFileSearch(cwd, {
-			maxResults: DEFAULT_FILE_SEARCH_MAX_RESULTS,
-			maxEntries: DEFAULT_FILE_SEARCH_MAX_ENTRIES,
-			excludedDirectories: [...DEFAULT_FILE_SEARCH_EXCLUDED_DIRECTORIES]
-		});
-		return preSessionSearch.list(query, signal ?? new AbortController().signal);
-	};
-	return {
-		async candidates(query, signal) {
-			const needle = query.trim();
-			const [files, sessions] = await Promise.all([agent !== void 0 && fileReferences !== void 0 ? fileReferences.list(agent, needle, signal ?? new AbortController().signal).catch(() => []) : agent === void 0 ? preSessionFiles(needle, signal).catch(() => []) : Promise.resolve([]), sessionCapable && needle !== "" && agent !== void 0 ? resolver.listCandidates(agent, needle, 10, signal).catch(() => []) : Promise.resolve([])]);
-			const fileRows = files.slice(0, MAX_FILE_ROWS).map((candidate) => ({
-				label: candidate.path,
-				description: candidate.kind === "directory" ? "Folder" : "File",
-				kind: candidate.kind,
-				...candidate.kind === "file" ? { path: isAbsolute(candidate.path) ? candidate.path : resolve(cwd, candidate.path) } : {}
-			}));
-			const sessionRows = sessions.map((candidate) => ({
-				label: formatSessionReferenceMention(candidate),
-				description: `Session · ${candidate.cwd ?? "(no cwd)"}`,
-				kind: "session"
-			}));
-			return [...fileRows, ...sessionRows];
-		},
-		parse(text) {
-			return parseSessionReferenceText(text);
-		},
-		async prepare(parsed, signal) {
-			if (parsed.references.length === 0 || resolver === void 0 || agent === void 0) return {
-				text: parsed.text,
-				references: parsed.references
-			};
-			const prepared = await resolver.prepare(agent, [{
-				type: "text",
-				text: parsed.text
-			}], parsed.references, signal);
-			return {
-				text: prepared.content.filter((block) => block.type === "text").map((block) => block.text).join(""),
-				references: parsed.references,
-				additionalContext: prepared.additionalContext
-			};
-		},
-		sessionMention(candidate) {
-			return formatSessionReferenceMention({
-				sessionId: candidate.sessionId,
-				label: candidate.label
-			});
-		}
-	};
-}
-//#endregion
 //#region src/questions.ts
 const ABORT_ERROR = new UserQuestionError("ask_user_question was interrupted before the user answered", "ASK_ABORTED");
 /**
@@ -36331,7 +36705,7 @@ async function run(ctx, startup, io) {
 			copyTextValue: copyText,
 			loadMentions: (query, signal) => mentions.candidates(query, signal),
 			inspectImages: (paths) => inspectImagePaths(paths, ctx.get("attachments"), session?.header.cwd ?? cwd),
-			prepareImages: (paths) => saveImagePaths(paths, ctx.get("attachments")),
+			prepareImages: (paths, signal) => saveImagePaths(paths, ctx.get("attachments"), signal),
 			cyclePermission: cyclePermission$1,
 			setPermission: setPermissionAction,
 			selectModel,