@deepseek-harness-tui/dsh-tui 0.9.3 → 0.10.0-beta.2

package/lib/types/components/PromptInput.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import React from 'react';
+import stripAnsi from 'strip-ansi';
 import { readFile, unlink } from 'node:fs/promises';
 import { basename } from 'node:path';
 import { t } from '../i18n.js';
@@ -10,6 +11,8 @@ import { EffortTierBadge } from './EffortTierBadge.js';
 import { isLightThemeActive } from '../theme.js';
 import { sessionColorHex } from '../cc/sessionColors.js';
 import { useDeclaredCursor } from '../ink/hooks/use-declared-cursor.js';
+import { TerminalWriteContext } from '../ink/useTerminalNotification.js';
+import { setClipboard } from '../ink/termio/osc.js';
 import { noteAuxNumber } from '../ink/geometry-trace.js';
 import instances from '../ink/instances.js';
 import { stringWidth } from '../ink/stringWidth.js';
@@ -17,6 +20,7 @@ import { truncateToWidth } from '../ink/truncateToWidth.js';
 import { getGraphemeSegmenter } from '../utils/intl.js';
 import { formatClipboardInsert, readClipboard } from '../utils/clipboard.js';
 import { editInExternalEditor } from '../utils/externalEditor.js';
+import { setPromptEditorNode, EditorButton } from './PromptEditor.js';
 import { isHiddenCommandName, parseCommandName } from '../commands.js';
 import { appendHistory } from '../history.js';
 import { mentionAtCaret } from '../utils/mentions.js';
@@ -41,6 +45,25 @@ const HISTORY_LIMIT = 50;
 const FOLD_MIN_LINES = 6;
 const FOLD_MIN_CHARS = 600;
 const isBigInput = (text) => text.split('\n').length >= FOLD_MIN_LINES || text.length >= FOLD_MIN_CHARS;
+/**
+ * Editable prompt text must have one stable source-to-screen geometry. The
+ * renderer interprets ANSI as zero-width styling and expands tabs relative to
+ * global tab stops; keeping either in `value` would let wrapping/click mapping
+ * count different cells and could split an escape sequence during selection.
+ * Strip terminal controls and expand tabs at ingress while preserving newlines.
+ */
+const EDITABLE_CONTROL = /[\u0000-\u0009\u000b-\u001f\u007f]/u;
+/** Normalize editable text so no terminal control characters remain in state. */
+function sanitizeEditableText(text) {
+    // Fast path for ordinary and multi-line drafts: newline is intentionally
+    // absent from the probe, so a large clean paste returns without regex work.
+    if (!EDITABLE_CONTROL.test(text))
+        return text;
+    return stripAnsi(text)
+        .replace(/\r\n?/gu, '\n')
+        .replace(/\t/gu, '        ')
+        .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/gu, '');
+}
 function clipboardImageMediaType(path) {
     if (/\.png$/iu.test(path))
         return 'image/png';
@@ -71,6 +94,58 @@ function wordBoundaryRight(text, cursor) {
         index++;
     return index;
 }
+// --- vim normal-mode helpers -----------------------------------------------
+// `/vim` 编辑模式的 normal 键位几何：行/词移动与删除目标。空白分词
+// （不区分 vim 的 word/WORD），对输入框场景足够且行为直观。
+/** Offset of the current line's first character. */
+function vimLineStart(text, cursor) {
+    return text.lastIndexOf('\n', cursor - 1) + 1;
+}
+/** Offset of the current line's last character (exclusive, no '\n'). */
+function vimLineEnd(text, cursor) {
+    const next = text.indexOf('\n', cursor);
+    return next === -1 ? text.length : next;
+}
+/** Offset of the line's first non-whitespace character (`^`). */
+function vimLineFirstNonBlank(text, cursor) {
+    const start = vimLineStart(text, cursor);
+    const end = vimLineEnd(text, cursor);
+    let i = start;
+    while (i < end && /\s/.test(text[i]))
+        i++;
+    return i;
+}
+/** Next word start (`w`): skip the rest of the current word, then leading
+ *  whitespace. Whitespace-delimited, vim-style. */
+function vimWordForward(text, cursor) {
+    const len = text.length;
+    let i = cursor;
+    if (i < len && !/\s/.test(text[i])) {
+        while (i < len && !/\s/.test(text[i]))
+            i++;
+    }
+    while (i < len && /\s/.test(text[i]))
+        i++;
+    return i;
+}
+/** Previous word start (`b`): from inside a word, its own start; from
+ *  whitespace, the preceding word's start. */
+function vimWordBackward(text, cursor) {
+    let i = cursor;
+    while (i > 0 && /\s/.test(text[i - 1]))
+        i--;
+    while (i > 0 && !/\s/.test(text[i - 1]))
+        i--;
+    return i;
+}
+/** End of the current word (`dw`): the whitespace boundary after `cursor`. */
+function vimWordEnd(text, cursor) {
+    const len = text.length;
+    let i = cursor;
+    while (i < len && !/\s/.test(text[i]))
+        i++;
+    return i;
+}
 // --- grapheme-cluster geometry ---------------------------------------------
 // The caret, editing keys, and wrapping MUST agree on one text unit. Mixing
 // UTF-16 code units (arrows/backspace), code points (wrap), and display
@@ -160,6 +235,20 @@ function normalizeCursorOffset(text, offset) {
 /** Max input rows before the visible viewport starts scrolling (CC's
  *  maxVisibleLines behavior — the box keeps a stable height). */
 const MAX_VISIBLE_LINES = 5;
+/**
+ * Fixed chrome rows around the expanded editor's text area: round border
+ * (top+bottom), the title row, the status row, and the button row. The
+ * editor viewport gets `terminalRows - this` rows.
+ */
+const EDITOR_CHROME_ROWS = 5;
+/**
+ * Double-click self-detection window: two clicks within this many ms and
+ * one cell (in either axis) of each other count as a double-click and
+ * select the word under the pointer. The drag protocol resets the ink
+ * multi-click chain on every press inside a drag target (the value box
+ * carries onDragStart), so the prompt detects the double-click itself.
+ */
+const DOUBLE_CLICK_MS = 500;
 /**
  * Claude Code style prompt input: rounded border box (top+bottom borders
  * only), `❯ ` prompt char (dimmed while a turn is working), the text with a
@@ -193,8 +282,44 @@ const MAX_VISIBLE_LINES = 5;
  */
 export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, selectionActive, fillText, onFillConsumed, onRewindRequest, controllerRef, }) {
     const [themeName] = useTheme();
+    // Raw stdout writer for OSC 52 clipboard writes (selection copy) — must
+    // bypass the frame pipeline; null outside a mounted Ink App.
+    const writeRaw = React.useContext(TerminalWriteContext);
     const [value, setValue] = React.useState('');
     const [cursor, setCursor] = React.useState(0);
+    /**
+     * Mouse text selection: UTF-16 offsets [start, end) in `value`, snapped
+     * to grapheme boundaries, start ≤ end. Null = no selection. Created by
+     * drag, Shift+click extension and double-click word select; consumed by
+     * Backspace/Delete/typing; Esc clears it without touching the text.
+     * With a fold block the range always stays inside the head or the tail
+     * (it never crosses the chip row — clamped on every write).
+     */
+    const [selection, setSelection] = React.useState(null);
+    const selectionRef = React.useRef(null);
+    /** Anchor offset of the in-flight drag gesture (set by dragstart). */
+    const dragAnchorRef = React.useRef(null);
+    /** Double-click self-detection: last click's timestamp/screen cell. */
+    const lastClickAtRef = React.useRef(0);
+    const lastClickColRef = React.useRef(-1);
+    const lastClickRowRef = React.useRef(-1);
+    /**
+     * vim editing mode (`/vim` toggle): when on, Esc switches the prompt to
+     * its NORMAL submode where bare keys are vim keys instead of text, and
+     * i/a/o (…) return to INSERT. Enabled in insert mode so the transition
+     * is seamless; the mode is session-scoped (not persisted).
+     */
+    const [vimEnabled, setVimEnabled] = React.useState(false);
+    /** Insert submode (false = vim NORMAL). */
+    const [vimInsert, setVimInsert] = React.useState(true);
+    const vimEnabledRef = React.useRef(false);
+    const vimInsertRef = React.useRef(true);
+    vimEnabledRef.current = vimEnabled;
+    vimInsertRef.current = vimInsert;
+    /** Undo stack: vim editing ops push {value, cursor}; `u` pops. */
+    const vimUndoRef = React.useRef([]);
+    /** Pending vim operator: `d` pressed, awaiting its second key. */
+    const vimPendingRef = React.useRef('');
     /**
      * CC-style fold block: the [start, end) span of `value` that renders as
      * a one-line chip while the text around it stays fully editable. Created
@@ -202,6 +327,39 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
      * delete removes it — typing NEVER unfolds the block.
      */
     const [foldBlock, setFoldBlock] = React.useState(null);
+    /** Synchronous mirror used by batched keys, controller clear, and mouse drag. */
+    const foldBlockRef = React.useRef(null);
+    /**
+     * Fullscreen draft editor (`expandEditor`, default Ctrl+Shift+E, or the
+     * ⛶ affordance at the end of the input row). While expanded the SAME
+     * editing state renders into the PromptEditorLayer cover (published via
+     * setPromptEditorNode each render): Enter inserts a newline, Ctrl+Enter
+     * submits, Esc collapses. The fold chip is bypassed (full text shown).
+     */
+    const [expanded, setExpanded] = React.useState(false);
+    const expandedRef = React.useRef(false);
+    /** First visible row of the expanded viewport (merged with caret-follow
+     *  during render; wheel events advance it and tick a re-render). */
+    const expandedScrollRef = React.useRef(0);
+    /**
+     * Free-scroll latch: wheel browsing parks the viewport anywhere; the
+     * caret-follow merge skips while it is set, and the next real caret move
+     * (typing, arrows, click) re-engages following (GUI-editor semantics).
+     */
+    const editorFreeScrollRef = React.useRef(false);
+    const prevCaretLineRef = React.useRef(-1);
+    const [, setExpandedTick] = React.useState(0);
+    const prevExpandedRef = React.useRef(false);
+    /**
+     * Feature gate (settings `dsh-tui.expandEditor`, on by default; a mock
+     * channel without the field also reads as on). Off hides the ⛶
+     * affordance and refuses the shortcut — the editor cannot open.
+     */
+    const expandEnabled = channel.expandEditor !== false;
+    /** Latest expanded viewport metrics for the useInput wheel branch. */
+    const editorViewportRef = React.useRef(null);
+    /** Hover state of the ⤢/⛶ expand affordance in the input row. */
+    const [expandHovered, setExpandHovered] = React.useState(false);
     /** Pointer over the input box (drives the hover peek card). */
     const [hovered, setHovered] = React.useState(false);
     /** 120ms grace so the pointer crossing the input border row from the
@@ -233,9 +391,48 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
             clear: () => {
                 valueRef.current = '';
                 cursorRef.current = 0;
+                selectionRef.current = null;
+                foldBlockRef.current = null;
+                dragAnchorRef.current = null;
+                lastClickAtRef.current = 0;
+                lastClickColRef.current = -1;
+                lastClickRowRef.current = -1;
+                // Chat's idle Ctrl+C clear also withdraws the fullscreen editor —
+                // the draft it was editing is gone, the cover must not linger.
+                expandedRef.current = false;
+                setSelection(null);
+                setFoldBlock(null);
+                setExpanded(false);
                 setValue('');
                 setCursor(0);
             },
+            consumeSelectionCopy: () => {
+                const sel = selectionRef.current;
+                if (!sel)
+                    return false;
+                const text = valueRef.current.slice(sel.start, sel.end);
+                void setClipboard(text).then(raw => {
+                    if (raw)
+                        writeRaw?.(raw);
+                });
+                // The selection stays: copy never clears it (Esc/typing/delete do).
+                return true;
+            },
+            toggleVim: () => {
+                const next = !vimEnabledRef.current;
+                vimEnabledRef.current = next;
+                setVimEnabled(next);
+                // Every toggle lands in INSERT: a fresh vim user keeps typing
+                // normally until they press Esc for the first time. Turning the
+                // mode off also clears the undo stack — a later re-enable must
+                // never `u` its way back past edits made while vim was off.
+                vimInsertRef.current = true;
+                setVimInsert(true);
+                vimPendingRef.current = '';
+                vimUndoRef.current = [];
+                return next;
+            },
+            vimActive: () => vimEnabledRef.current,
         };
         return () => {
             controllerRef.current = null;
@@ -274,6 +471,14 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
         };
     }, []);
     const { columns, rows: terminalRows } = useTerminalSize();
+    React.useEffect(() => {
+        // PromptInput self-detects double-clicks because its drag target resets
+        // App's global chain. Geometry changed across resize, so the same screen
+        // cell no longer identifies the same grapheme.
+        lastClickAtRef.current = 0;
+        lastClickColRef.current = -1;
+        lastClickRowRef.current = -1;
+    }, [columns, terminalRows]);
     const helpScrollRef = React.useRef(null);
     // Help viewport budget: the overlay anchors at the composer's top edge
     // (OverlayAbove bottom:'100%') and grows UP, so its budget is the space
@@ -291,6 +496,7 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
     const helpViewportHeight = Math.max(3, Math.min(terminalRows - 7, 15));
     const suggestions = value.startsWith('/') ? channel.commandCompletions(value) : [];
     const overlayOpen = suggestions.length > 0 &&
+        !expanded &&
         !helpOpen &&
         !selectionActive &&
         !value.includes('\n');
@@ -330,13 +536,13 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
         fileEscRef.current = -1;
     }, [value]);
     const fileOverlayOpen = fileMatches.length > 0 &&
+        !expanded &&
         !helpOpen &&
         !selectionActive &&
         fileEscRef.current !== mention?.start;
     /** Fold-block state + a synchronous mirror (setInput reads the ref).
      *  Creating a block also drags a caret that sits inside it out to the
      *  block's end (the block is atomic; typing continues after it). */
-    const foldBlockRef = React.useRef(null);
     const updateFoldBlock = (block) => {
         foldBlockRef.current = block;
         setFoldBlock(block);
@@ -349,6 +555,12 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
         }
     };
     const setInput = (next, cursorOffset = next.length) => {
+        // Apply the same ingress normalization to fills/history/editor results as
+        // to paste. Map the requested caret through the sanitized prefix so an
+        // ANSI sequence removed before it cannot leave the caret past the text.
+        const sanitizedCursor = sanitizeEditableText(next.slice(0, cursorOffset)).length;
+        next = sanitizeEditableText(next);
+        cursorOffset = sanitizedCursor;
         const prev = valueRef.current;
         const prevCursor = cursorRef.current;
         const block = foldBlockRef.current;
@@ -384,9 +596,51 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
         // read → several keys, no render in between) read on their next turn.
         valueRef.current = next;
         cursorRef.current = offset;
+        // Every real edit drops the selection: its offsets describe the OLD
+        // text. Selection-consuming callers (delete/replace) read it first.
+        selectionRef.current = null;
+        setSelection(null);
         setValue(next);
         setCursor(offset);
     };
+    /**
+     * Write the selection [start, end) (snapped to grapheme boundaries,
+     * start ≤ end); a degenerate range clears it. With a fold block the
+     * range is clamped into the side that holds `start` — the block is
+     * atomic and a selection may never cross the chip row.
+     */
+    const updateSelection = (start, end) => {
+        const text = valueRef.current;
+        const anchor = normalizeCursorOffset(text, start);
+        let lo = normalizeCursorOffset(text, Math.min(start, end));
+        let hi = normalizeCursorOffset(text, Math.max(start, end));
+        const block = foldBlockRef.current;
+        if (block) {
+            // Clamp by the ORIGINAL anchor side, not sorted `lo`: for a reverse
+            // tail→head drag, `lo` is in the head even though the gesture belongs
+            // to the tail. Both selection and caret must stay on the anchor side.
+            if (anchor <= block.start) {
+                hi = Math.min(hi, block.start);
+            }
+            else {
+                lo = Math.max(lo, block.end);
+                hi = Math.max(hi, block.end);
+            }
+        }
+        if (lo >= hi) {
+            selectionRef.current = null;
+            setSelection(null);
+        }
+        else {
+            selectionRef.current = { start: lo, end: hi };
+            setSelection({ start: lo, end: hi });
+        }
+    };
+    /** Drop the selection without touching text or caret. */
+    const clearSelection = () => {
+        selectionRef.current = null;
+        setSelection(null);
+    };
     /**
      * Accept the selected file suggestion: replace ONLY the mention token at
      * the caret (prefix/suffix text survives), quoting whitespace paths. A
@@ -541,14 +795,106 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
         }
         return handled;
     };
+    /**
+     * The Enter main path, shared by the inline prompt, the expanded
+     * editor's Ctrl+Enter, and its Send button:
+     * - command menu open → run the SELECTED command (never send `/mo`);
+     * - model working → STEER into the running turn (next step boundary,
+     *   agent continues — the "immediate" send; Codex/pi semantics);
+     * - otherwise → submit directly (or run a unique command).
+     * Reads valueRef so a key batch (typing + Enter in one stdin read)
+     * operates on the text the preceding keys produced.
+     */
+    const handleEnter = () => {
+        // A single Enter can arrive as two events in cmd pipelines (`\r`
+        // parsed as return + a raw `\n` line): collapse them so one keypress
+        // never sends the message twice.
+        const now = Date.now();
+        if (now - lastEnterAtRef.current < 80)
+            return;
+        lastEnterAtRef.current = now;
+        const value = valueRef.current;
+        if (overlayOpen) {
+            const command = suggestions[selectedCommand];
+            if (command) {
+                tryRunCommand(command.commandLine);
+                return;
+            }
+        }
+        // File-completion overlay open → Enter accepts the selection (same
+        // contract as the command menu: the overlay owns Enter while open).
+        if (fileOverlayOpen) {
+            const file = fileMatches[fileSelected];
+            if (file) {
+                acceptFile(file);
+                return;
+            }
+        }
+        if (channel.working && value.trim() !== '') {
+            // CC's immediate-command semantics: /btw and /skills are exempt from
+            // steering — neither command interrupts the running turn. Hidden
+            // UI-only easter eggs (e.g. /deepseek) are also safe to run while
+            // streaming. Every other input keeps the steer behavior so /new
+            // /model etc. stay idle-only.
+            const parsed = value.startsWith('/') ? parseCommandName(value) : undefined;
+            if (parsed !== undefined && (((parsed.name === 'btw' || parsed.name === 'skills')
+                && channel.commandList.some(c => c.name === parsed.name))
+                || isHiddenCommandName(parsed.name))) {
+                if (tryRunCommand(value))
+                    return;
+            }
+            steerSend(value);
+            return;
+        }
+        if (!tryRunCommand(value))
+            submitText(value);
+    };
+    /** Expand/collapse the fullscreen editor (shortcut + ⛶ affordance).
+     *  Expanding also DROPS any fold block: the fullscreen view shows and
+     *  edits the full text, and the block's atomic-clamp semantics (caret
+     *  pushed to its edges, selection clamped to one side) would contradict
+     *  that — the chip's own click-to-expand already means "unfold". */
+    const toggleExpand = () => {
+        const next = !expandedRef.current;
+        expandedRef.current = next;
+        setExpanded(next);
+        if (next) {
+            expandedScrollRef.current = 0;
+            if (foldBlockRef.current)
+                updateFoldBlock(null);
+        }
+        // Geometry changed wholesale (a fullscreen cover): the double-click
+        // self-detection's screen-cell memory is void, same as on resize.
+        lastClickAtRef.current = 0;
+        lastClickColRef.current = -1;
+        lastClickRowRef.current = -1;
+    };
+    /** Withdraw the fullscreen editor, keeping text/caret/selection intact. */
+    const collapseEditor = () => {
+        expandedRef.current = false;
+        setExpanded(false);
+        lastClickAtRef.current = 0;
+        lastClickColRef.current = -1;
+        lastClickRowRef.current = -1;
+    };
+    /** The editor's explicit send (Ctrl+Enter / Send button): the Enter main
+     *  path, then collapse — an empty draft just collapses. */
+    const submitFromEditor = () => {
+        handleEnter();
+        collapseEditor();
+    };
     /** Clipboard reads are asynchronous; insert against the latest render so
      * typing while PowerShell owns the clipboard never gets overwritten.
-     * Returns the resulting value and the insertion offset so callers can
-     * apply the paste fold. */
+     * An active selection is replaced by the insert. Returns the resulting
+     * value and the insertion offset so callers can apply the paste fold. */
     const insertClipboardAtCaret = (text) => {
+        text = sanitizeEditableText(text);
         const current = valueRef.current;
-        const position = cursorRef.current;
-        const next = current.slice(0, position) + text + current.slice(position);
+        const sel = selectionRef.current;
+        const position = sel ? sel.start : cursorRef.current;
+        const next = sel
+            ? current.slice(0, sel.start) + text + current.slice(sel.end)
+            : current.slice(0, position) + text + current.slice(position);
         setInput(next, position + text.length);
         setSelectedCommand(0);
         setFileSelected(0);
@@ -573,11 +919,48 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
         // setValue can never overwrite fresh typing (and vice versa).
         if (editorBusyRef.current)
             return;
+        // Ctrl+Shift+E (remappable via /settings): toggle the fullscreen draft
+        // editor. Matched before anything else so it works both while editing
+        // and from an idle prompt; selectionActive has already returned above.
+        // Refused while the feature is turned off in /settings.
+        if (expandEnabled && actionMatches('expandEditor', input, key)) {
+            event?.stopImmediatePropagation();
+            toggleExpand();
+            return;
+        }
         // App deliberately dispatches every parsed key from one stdin read in a
         // single React update. Read the synchronous mirrors so each event sees
         // the text/caret produced by the preceding event in that batch.
         const value = valueRef.current;
         const cursor = cursorRef.current;
+        const selection = selectionRef.current;
+        // ── mouse selection (drag / Shift+click / double-click) ─────────────
+        // Layered ahead of the fold-block rules: with an active selection, Esc
+        // ONLY drops the highlight (text untouched), and Backspace/Delete
+        // delete the selected span. Arrows/typing handle the selection at their
+        // own arms below.
+        if (key.escape && selection && !helpOpen && !overlayOpen && !fileOverlayOpen) {
+            event.stopImmediatePropagation();
+            clearSelection();
+            return;
+        }
+        if ((key.backspace || key.delete) && selection) {
+            const next = value.slice(0, selection.start) + value.slice(selection.end);
+            setInput(next, selection.start);
+            setSelectedCommand(0);
+            setFileSelected(0);
+            return;
+        }
+        // ── 全屏草稿编辑（expandEditor，默认 Ctrl+Shift+E / 输入行 ⛶）─────
+        // 展开态拥有屏幕；Esc 收起（有选区时上面的 selection 分支已先行只清
+        // 选区）。滚轮不经此——编辑区的 onWheel 位置路由直接驱动滚动窗口。
+        if (key.escape && expandedRef.current) {
+            // Collapse runs AHEAD of the fold-block/vim Esc meanings: the
+            // fullscreen cover is the outermost modal layer.
+            event?.stopImmediatePropagation();
+            collapseEditor();
+            return;
+        }
         // Fold block (CC-style): Esc expands it — it must NEVER clear text
         // that LOOKS like one line; Backspace at the block's tail / Delete at
         // its head deletes the WHOLE block in one key; ←/→ jump over the
@@ -614,25 +997,36 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
         // Grapheme boundaries of the current text: every caret move / delete
         // below snaps onto one of these offsets (never mid-cluster).
         const bounds = graphemeBoundaries(value);
-        /** Insert text at the caret (typing, paste) and dismiss overlays. */
+        /** Insert text at the caret (typing, paste) and dismiss overlays. An
+         *  active selection is REPLACED by the insert (standard editor
+         *  semantics). Returns the insertion offset so callers can derive the
+         *  inserted span (paste fold). */
         const insertAtCaret = (text) => {
             if (helpOpen)
                 onToggleHelp();
-            const next = value.slice(0, cursor) + text + value.slice(cursor);
-            setInput(next, cursor + text.length);
+            const sel = selectionRef.current;
+            const at = sel ? sel.start : cursor;
+            const next = sel
+                ? value.slice(0, sel.start) + text + value.slice(sel.end)
+                : value.slice(0, cursor) + text + value.slice(cursor);
+            setInput(next, at + text.length);
             setSelectedCommand(0);
             setFileSelected(0);
+            return at;
         };
         // Bracketed paste (terminal paste — Ctrl+Shift+V / right-click): insert
-        // verbatim at the caret. Paste content may contain newlines — that is
-        // NOT Enter — so this branch runs before the whole-line submit rule.
+        // at the caret after removing terminal controls and expanding tabs.
+        // Newlines remain data — they are NOT Enter — so this branch runs before
+        // the whole-line submit rule.
         if (event?.isPasted && input.length > 0) {
-            const text = input.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
-            insertAtCaret(text);
+            const text = sanitizeEditableText(input.replace(/\r\n/g, '\n').replace(/\r/g, '\n'));
+            const at = insertAtCaret(text);
             // A big paste becomes a CC-style fold block right away (hover peeks
             // at it); an existing block is replaced by the new paste's span.
-            if (isBigInput(text))
-                updateFoldBlock({ start: cursor, end: cursor + text.length });
+            // The EXPANDED editor never folds — pasting there is plain text
+            // (fold semantics would clamp the caret out of the pasted span).
+            if (!expandedRef.current && isBigInput(text))
+                updateFoldBlock({ start: at, end: at + text.length });
             return;
         }
         // Clipboard paste (default Ctrl+V / Cmd+V, plus the Alt+V alias for
@@ -683,11 +1077,11 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
                 }
                 // Insert against the LIVE input state: the read above resolved
                 // asynchronously and the user may have typed while waiting.
-                const text = formatClipboardInsert(content);
+                const text = sanitizeEditableText(formatClipboardInsert(content));
                 const { at } = insertClipboardAtCaret(text);
-                // Same fold as bracketed paste: big clipboard text becomes a
-                // fold block covering exactly the pasted span.
-                if (isBigInput(text))
+                // Same fold as bracketed paste — but never inside the expanded
+                // editor (plain text there, see the isPasted branch).
+                if (!expandedRef.current && isBigInput(text))
                     updateFoldBlock({ start: at, end: at + text.length });
             })
                 .catch(() => {
@@ -748,67 +1142,25 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
             })();
             return;
         }
-        /**
-         * CR/LF line from Windows cmd pipelines):
-         * - command menu open → run the SELECTED command (never send `/mo`);
-         * - model working → STEER into the running turn (next step boundary,
-         *   agent continues — the "immediate" send; Codex/pi semantics);
-         * - otherwise → submit directly (or run a unique command).
-         */
-        const handleEnter = () => {
-            // A single Enter can arrive as two events in cmd pipelines (`\r`
-            // parsed as return + a raw `\n` line): collapse them so one keypress
-            // never sends the message twice.
-            const now = Date.now();
-            if (now - lastEnterAtRef.current < 80)
-                return;
-            lastEnterAtRef.current = now;
-            if (overlayOpen) {
-                const command = suggestions[selectedCommand];
-                if (command) {
-                    tryRunCommand(command.commandLine);
-                    return;
-                }
-            }
-            // File-completion overlay open → Enter accepts the selection (same
-            // contract as the command menu: the overlay owns Enter while open).
-            if (fileOverlayOpen) {
-                const file = fileMatches[fileSelected];
-                if (file) {
-                    acceptFile(file);
-                    return;
-                }
-            }
-            if (channel.working && value.trim() !== '') {
-                // CC's immediate-command semantics: /btw is exempt from steering —
-                // the side question never interrupts the running turn. Hidden
-                // UI-only easter eggs (e.g. /deepseek) are also safe to run while
-                // streaming. Every other input keeps the steer behavior so /new
-                // /model etc. stay idle-only.
-                const parsed = value.startsWith('/') ? parseCommandName(value) : undefined;
-                if (parsed !== undefined && ((parsed.name === 'btw' && channel.commandList.some(c => c.name === 'btw'))
-                    || isHiddenCommandName(parsed.name))) {
-                    tryRunCommand(value);
-                    return;
-                }
-                steerSend(value);
-                return;
-            }
-            if (!tryRunCommand(value))
-                submitText(value);
-        };
-        // Ctrl+J is the only portable multiline fallback when a terminal cannot
-        // report modifiers on Enter. The parser names its bare LF `enter`, while
-        // the physical Enter key arrives as CR (`return`).
-        if (input === '\n' && event?.keypress.name === 'enter') {
+        // Ctrl+J is the portable multiline fallback when a terminal cannot
+        // report modifiers on Enter. Legacy terminals deliver bare LF (`enter`),
+        // while kitty/modifyOtherKeys encode it as an exact Ctrl+J key.
+        const isCtrlJ = input === 'j' && key.ctrl && !key.shift && !key.meta && !key.super;
+        if ((input === '\n' && event?.keypress.name === 'enter') || isCtrlJ) {
             insertAtCaret('\n');
             return;
         }
         // Whole-line input from Windows ConPTY pipelines (cmd batch -> node):
         // the trailing CR/LF marks a complete line to submit. A bare CR/CRLF is
         // Enter, while real multi-char piped lines keep the legacy direct-submit
-        // path.
+        // path. The expanded editor treats piped lines as DATA — CR/LF
+        // normalizes to '\n' and inserts (sending needs Ctrl+Enter there), so a
+        // fast batch never dumps raw '\r' into the draft.
         if (input.includes('\n') || input.includes('\r')) {
+            if (expandedRef.current) {
+                insertAtCaret(sanitizeEditableText(input.replace(/\r\n/g, '\n').replace(/\r/g, '\n')));
+                return;
+            }
             if (/^[\r\n]+$/.test(input)) {
                 handleEnter();
                 return;
@@ -826,9 +1178,16 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
             return;
         }
         if (key.return && isMod(key)) {
-            // Ctrl+Enter / Cmd+Enter: interrupt the running turn and process this
-            // message immediately (Windows Terminal sends CSI 13;5u / 13;1;5u).
-            interruptSend();
+            // Ctrl+Enter / Cmd+Enter: in the EXPANDED editor this is the explicit
+            // send (Enter inserts newlines there, so sending needs its own key);
+            // inline it interrupts the running turn and processes this message
+            // immediately (Windows Terminal sends CSI 13;5u / 13;1;5u).
+            if (expandedRef.current) {
+                submitFromEditor();
+            }
+            else {
+                interruptSend();
+            }
             return;
         }
         if (key.return && (key.shift || key.meta)) {
@@ -837,9 +1196,14 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
             // supports extended key reporting (kitty/modifyOtherKeys allowlist in
             // ink/terminal.ts); Option+Enter (ESC CR) is the fallback on terminals
             // that can't report shift — e.g. macOS Terminal.app (issue #110).
-            const next = value.slice(0, cursor) + '\n' + value.slice(cursor);
-            setInput(next, cursor + 1);
-            setSelectedCommand(0);
+            insertAtCaret('\n');
+            return;
+        }
+        if (key.return && expandedRef.current) {
+            // Expanded editor: plain Enter inserts a newline (text-editor
+            // semantics — long-draft editing must never misfire a send). The
+            // shift/meta variants above already newline; Ctrl+Enter sends.
+            insertAtCaret('\n');
             return;
         }
         if (key.return) {
@@ -852,6 +1216,14 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
             event.stopImmediatePropagation();
             return;
         }
+        // Expanded editor: Tab is indentation, Shift+Tab a silent swallow —
+        // neither command completion nor session-mode cycling makes sense on
+        // the fullscreen editor, and both would fire invisibly behind it.
+        if (expandedRef.current && key.tab) {
+            if (!key.shift)
+                insertAtCaret('    ');
+            return;
+        }
         // Shift+Tab cycles the configured session modes (default: 默认 →
         // 计划模式 → 完全访问; each mode bundles plan/sandbox/approval atoms —
         // see the `modes` config). Must precede the plain-Tab arms — the parser
@@ -1031,23 +1403,29 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
         }
         if (isMod(key) && key.leftArrow) {
             // Jump to the previous word boundary (readline alt+b). Must precede the
-            // bare-arrow arms: Ctrl+Left arrives as leftArrow + ctrl.
-            setInput(value, wordBoundaryLeft(value, cursor));
+            // bare-arrow arms: Ctrl+Left arrives as leftArrow + ctrl. An active
+            // selection collapses to its START edge first (editor semantics).
+            const sel = selectionRef.current;
+            setInput(value, sel ? sel.start : wordBoundaryLeft(value, cursor));
             return;
         }
         if (isMod(key) && key.rightArrow) {
             // Jump to the next word boundary (readline alt+f).
-            setInput(value, wordBoundaryRight(value, cursor));
+            const sel = selectionRef.current;
+            setInput(value, sel ? sel.end : wordBoundaryRight(value, cursor));
             return;
         }
         if (key.leftArrow) {
             // Grapheme-step: skip the whole cluster (surrogate pair, ZWJ emoji,
-            // combining mark) so the caret never sits inside one.
-            setInput(value, previousGraphemeBoundary(bounds, cursor));
+            // combining mark) so the caret never sits inside one. With a
+            // selection, collapse to its start edge instead.
+            const sel = selectionRef.current;
+            setInput(value, sel ? sel.start : previousGraphemeBoundary(bounds, cursor));
             return;
         }
         if (key.rightArrow) {
-            setInput(value, nextGraphemeBoundary(bounds, cursor));
+            const sel = selectionRef.current;
+            setInput(value, sel ? sel.end : nextGraphemeBoundary(bounds, cursor));
             return;
         }
         if (key.backspace) {
@@ -1114,6 +1492,256 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
             setInput(value.slice(0, clipped) + value.slice(cursor), clipped);
             return;
         }
+        // ── vim mode (`/vim`) ──────────────────────────────────────────────
+        // INSERT submode: only Esc is intercepted (back to NORMAL — the usual
+        // clear/rewind Esc semantics stay disabled while vim is on).
+        // NORMAL submode: bare characters and Esc are vim keys; help/command/
+        // file overlays, modified combos, Tab, Enter, arrows and other
+        // structured keys keep their existing handlers.
+        const vimNormalEdit = (next, cursorOffset) => {
+            updateFoldBlock(null);
+            setInput(next, cursorOffset);
+            setSelectedCommand(0);
+            setFileSelected(0);
+        };
+        const vimPushUndo = () => {
+            if (vimUndoRef.current.length >= 100)
+                vimUndoRef.current.shift();
+            vimUndoRef.current.push({ value: valueRef.current, cursor: cursorRef.current });
+        };
+        const handleVimNormal = (input) => {
+            // One stdin batch can merge several bare keys into a single event
+            // (fast typing), so re-read the synchronous mirrors and recompute
+            // the grapheme boundaries: every key in the batch operates on the
+            // text/caret its predecessor produced (the outer `value`/`cursor`/
+            // `bounds` reflect only the batch's first key).
+            const value = valueRef.current;
+            const cursor = cursorRef.current;
+            const bounds = graphemeBoundaries(value);
+            const pending = vimPendingRef.current;
+            vimPendingRef.current = '';
+            // Operator pending (`d`): the second key picks the target.
+            if (pending === 'd') {
+                switch (input) {
+                    case 'd': { // delete the whole line, newline included (vim `dd`);
+                        // the last line has no newline — its content is cleared
+                        vimPushUndo();
+                        const lineStart = vimLineStart(value, cursor);
+                        const lineEnd = vimLineEnd(value, cursor);
+                        const end = lineEnd < value.length ? lineEnd + 1 : lineEnd;
+                        vimNormalEdit(value.slice(0, lineStart) + value.slice(end), lineStart);
+                        return;
+                    }
+                    case '$': { // delete to end of line
+                        vimPushUndo();
+                        const end = vimLineEnd(value, cursor);
+                        vimNormalEdit(value.slice(0, cursor) + value.slice(end), cursor);
+                        return;
+                    }
+                    case '0':
+                    case '^': { // delete to start of line
+                        vimPushUndo();
+                        const start = input === '^' ? vimLineFirstNonBlank(value, cursor) : vimLineStart(value, cursor);
+                        vimNormalEdit(value.slice(0, start) + value.slice(cursor), start);
+                        return;
+                    }
+                    case 'w': { // delete to end of word
+                        vimPushUndo();
+                        const end = vimWordEnd(value, cursor);
+                        vimNormalEdit(value.slice(0, cursor) + value.slice(end), cursor);
+                        return;
+                    }
+                    default:
+                        return; // unrecognized second key: cancel the operator, drop it
+                }
+            }
+            switch (input) {
+                case 'h':
+                    setInput(value, previousGraphemeBoundary(bounds, cursor));
+                    return;
+                case 'l':
+                    setInput(value, nextGraphemeBoundary(bounds, cursor));
+                    return;
+                case 'j': { // down one line (single-line input: no-op)
+                    const line = cursorLine(value, cursor);
+                    const lines = value.split('\n');
+                    if (line >= lines.length - 1)
+                        return;
+                    const col = Math.min(cursorColumn(value, cursor), (lines[line + 1] ?? '').length);
+                    setInput(value, vimLineEnd(value, cursor) + 1 + col);
+                    return;
+                }
+                case 'k': { // up one line
+                    const line = cursorLine(value, cursor);
+                    if (line <= 0)
+                        return;
+                    const lines = value.split('\n');
+                    const col = Math.min(cursorColumn(value, cursor), (lines[line - 1] ?? '').length);
+                    const prevStart = vimLineStart(value, vimLineStart(value, cursor) - 1);
+                    setInput(value, prevStart + col);
+                    return;
+                }
+                case '0': {
+                    setInput(value, vimLineStart(value, cursor));
+                    return;
+                }
+                case '^': {
+                    setInput(value, vimLineFirstNonBlank(value, cursor));
+                    return;
+                }
+                case '$': {
+                    setInput(value, vimLineEnd(value, cursor));
+                    return;
+                }
+                case 'w':
+                    setInput(value, vimWordForward(value, cursor));
+                    return;
+                case 'b':
+                    setInput(value, vimWordBackward(value, cursor));
+                    return;
+                case 'x': { // delete the character at the caret; at the very end of
+                    // the text delete the last character (vim: the caret sits ON the
+                    // last char after `$`, so `x` must still delete it). Same rule
+                    // when the caret sits right before a '\n' mid-draft — after `$`
+                    // the caret is on the line's last char, `x` must delete THAT
+                    // char, not the newline (which would join the lines).
+                    if (cursor > 0 && (cursor === value.length || value[cursor] === '\n')) {
+                        const start = previousGraphemeBoundary(bounds, cursor);
+                        vimPushUndo();
+                        vimNormalEdit(value.slice(0, start) + value.slice(cursor), start);
+                        return;
+                    }
+                    const end = nextGraphemeBoundary(bounds, cursor);
+                    if (end === cursor)
+                        return;
+                    vimPushUndo();
+                    vimNormalEdit(value.slice(0, cursor) + value.slice(end), cursor);
+                    return;
+                }
+                case 'X': { // delete the character before the caret
+                    if (cursor === 0)
+                        return;
+                    const start = previousGraphemeBoundary(bounds, cursor);
+                    vimPushUndo();
+                    vimNormalEdit(value.slice(0, start) + value.slice(cursor), start);
+                    return;
+                }
+                case 'd':
+                    vimPendingRef.current = 'd';
+                    return;
+                case 'u': { // undo the last vim edit
+                    const prev = vimUndoRef.current.pop();
+                    if (prev === undefined)
+                        return;
+                    updateFoldBlock(null);
+                    setInput(prev.value, prev.cursor);
+                    setSelectedCommand(0);
+                    setFileSelected(0);
+                    return;
+                }
+                case 'i': // insert at the caret
+                    vimInsertRef.current = true;
+                    setVimInsert(true);
+                    return;
+                case 'I': { // insert at the line's first non-blank (vim `I`)
+                    setInput(value, vimLineFirstNonBlank(value, cursor));
+                    vimInsertRef.current = true;
+                    setVimInsert(true);
+                    return;
+                }
+                case 'a': { // insert after the caret
+                    setInput(value, nextGraphemeBoundary(bounds, cursor));
+                    vimInsertRef.current = true;
+                    setVimInsert(true);
+                    return;
+                }
+                case 'A': { // insert at the line end
+                    setInput(value, vimLineEnd(value, cursor));
+                    vimInsertRef.current = true;
+                    setVimInsert(true);
+                    return;
+                }
+                case 'o': { // new line below, then insert
+                    vimPushUndo();
+                    const end = vimLineEnd(value, cursor);
+                    vimNormalEdit(value.slice(0, end) + '\n' + value.slice(end), end + 1);
+                    vimInsertRef.current = true;
+                    setVimInsert(true);
+                    return;
+                }
+                case 'O': { // new line above, then insert
+                    vimPushUndo();
+                    const start = vimLineStart(value, cursor);
+                    vimNormalEdit(value.slice(0, start) + '\n' + value.slice(start), start);
+                    vimInsertRef.current = true;
+                    setVimInsert(true);
+                    return;
+                }
+                default:
+                    return; // unrecognized key: ignored (never inserts in NORMAL)
+            }
+        };
+        if (vimEnabledRef.current) {
+            if (vimInsertRef.current) {
+                // INSERT: Esc returns to NORMAL instead of the clear/rewind path.
+                if (key.escape && !helpOpen && !overlayOpen && !fileOverlayOpen) {
+                    event.stopImmediatePropagation();
+                    vimInsertRef.current = false;
+                    setVimInsert(false);
+                    return;
+                }
+            }
+            else if (!helpOpen && !overlayOpen && !fileOverlayOpen) {
+                if (key.escape) {
+                    // NORMAL: Esc cancels a pending operator and otherwise no-ops
+                    // (the clear/rewind double-Esc semantics belong to non-vim mode).
+                    vimPendingRef.current = '';
+                    event.stopImmediatePropagation();
+                    return;
+                }
+                const plainChar = input.length > 0 &&
+                    !key.ctrl && !key.meta && !key.super && !key.tab && !key.return;
+                if (plainChar) {
+                    // `?` on an empty input falls through to the help shortcut below.
+                    if (input === '?' && value.length === 0)
+                        return;
+                    // `/` opens the slash-command menu even in NORMAL: insert it and
+                    // switch to INSERT so the rest of the command types normally
+                    // (the menu then owns the keys while it is open).
+                    if (input === '/') {
+                        const text = valueRef.current;
+                        const pos = cursorRef.current;
+                        const next = text.slice(0, pos) + '/' + text.slice(pos);
+                        setInput(next, pos + 1);
+                        setSelectedCommand(0);
+                        setFileSelected(0);
+                        vimInsertRef.current = true;
+                        setVimInsert(true);
+                        return;
+                    }
+                    event.stopImmediatePropagation();
+                    // A merged multi-char event (fast typing) is one vim key per
+                    // character — handleVimNormal re-reads the refs each call, so a
+                    // batch like `dd` works exactly like two separate keypresses.
+                    // Once a key switches back to INSERT (i/a/o/…), the remaining
+                    // characters of the batch are ordinary typing and insert as text.
+                    for (let i = 0; i < input.length; i++) {
+                        if (vimInsertRef.current) {
+                            const rest = input.slice(i);
+                            const text = valueRef.current;
+                            const pos = cursorRef.current;
+                            const next = text.slice(0, pos) + rest + text.slice(pos);
+                            setInput(next, pos + rest.length);
+                            setSelectedCommand(0);
+                            setFileSelected(0);
+                            break;
+                        }
+                        handleVimNormal(input[i]);
+                    }
+                    return;
+                }
+            }
+        }
         if (key.escape) {
             if (helpOpen) {
                 onToggleHelp();
@@ -1182,7 +1810,7 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
             }, 3000);
             return;
         }
-        if (input === '?' && value.length === 0) {
+        if (input === '?' && value.length === 0 && !expandedRef.current) {
             onToggleHelp();
             return;
         }
@@ -1190,8 +1818,13 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
             // Typing anything else dismisses the help menu (CC behavior).
             if (helpOpen)
                 onToggleHelp();
-            const next = value.slice(0, cursor) + input + value.slice(cursor);
-            setInput(next, cursor + input.length);
+            // An active selection is REPLACED by the typed text, caret after it.
+            const sel = selectionRef.current;
+            const at = sel ? sel.start : cursor;
+            const next = sel
+                ? value.slice(0, sel.start) + input + value.slice(sel.end)
+                : value.slice(0, cursor) + input + value.slice(cursor);
+            setInput(next, at + input.length);
             setSelectedCommand(0);
             setFileSelected(0);
         }
@@ -1202,8 +1835,28 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
     // Narrow terminals: the usable width follows the real terminal down to a
     // single column — a fixed floor of 10 would wrap far too early and park
     // the declared cursor past the value box's actual width.
-    const inputWidth = Math.max(1, columns - 3);
-    const block = foldBlock;
+    // The vim badge ('INSERT '/'NORMAL ', 7 cols) sits BEFORE the value box in
+    // the same row, so the wrap budget must shrink by its width or long lines
+    // would be clipped at the value box's right edge.
+    const vimBadgeCols = vimEnabled ? 7 : 0;
+    // 补全卡片边框与输入框 idle 边框同色（plan 模式下整套面板一起变 sage
+    // 绿）。`/color` 会话强调色优先于主题 promptBorder（plan 模式仍整体走
+    // sage 绿）。`?? ''` 防御最小 mock channel（只声明用到的字段的回归脚
+    // 本）。声明在渲染派生区之前：展开编辑器的行号高亮与边框同用此色。
+    const sessionAccent = sessionColorHex(channel.sessionColor ?? '');
+    const promptAccent = channel.mode.plan === true ? 'planMode' : (sessionAccent ?? 'promptBorder');
+    // 展开态布局参数：编辑器独占整屏 —— 行号槽（宽度随逻辑行数伸缩）+
+    // 圆角边框 2 + 两侧 padding 各 1 占列，❯ 前缀 / vim 徽标 / ⛶ 按钮
+    // 全部让位；收起态额外扣掉行尾 ⛶ 按钮的 2 列。
+    const editorLogicalLines = expanded ? value.split('\n').length : 1;
+    const editorNoWidth = Math.max(2, String(editorLogicalLines).length);
+    const editorGutterCols = editorNoWidth + 3;
+    const inputWidth = expanded
+        ? Math.max(1, columns - 4 - editorGutterCols)
+        : Math.max(1, columns - 3 - vimBadgeCols - (expandEnabled ? 2 : 0));
+    // 展开态无视折叠块：全屏编辑就是为了看全文（foldBlock 状态保留，
+    // 收起后折叠显示恢复）。
+    const block = expanded ? null : foldBlock;
     // Fold-block model: the value renders as [head rows][chip row][tail rows]
     // — the block is ONE atomic visual row regardless of its text size; text
     // before/after it stays fully editable and never unfolds it.
@@ -1216,11 +1869,20 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
     const visualLines = block
         ? [...headRows, '', ...tailRows]
         : wrapToWidth(value, inputWidth);
-    const caretVisualLine = block
+    // Caret geometry uses the FULL wrap (not `value.slice(0, cursor)`):
+    // word-wrap carry moves already-placed clusters, so a prefix wrap would
+    // disagree with the displayed rows whenever the cursor sits inside a
+    // carried word.
+    const caretPlaced = block
         ? cursor <= block.start
-            ? wrapToWidth(value.slice(0, cursor), inputWidth).length - 1
-            : headRows.length + 1 + wrapToWidth(value.slice(block.end, cursor), inputWidth).length - 1
-        : wrapToWidth(value.slice(0, cursor), inputWidth).length - 1;
+            ? caretInText(head, inputWidth, cursor)
+            : caretInText(tail, inputWidth, Math.max(0, cursor - block.end))
+        : caretInText(value, inputWidth, cursor);
+    const caretVisualLine = block && cursor > block.start
+        ? headRows.length + 1 + caretPlaced.line
+        : caretPlaced.line;
+    const caretCharCol = caretPlaced.charCol;
+    const caretVisualCol = caretPlaced.visualCol;
     // Fold stats describe the BLOCK (or the whole input when expanded and
     // the ▾ prefix offers a manual whole-input fold). The chip shows the
     // block's own line/char count + first-line preview — the preview text
@@ -1230,26 +1892,40 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
         ? t('input-fold-stats', { lines: foldText.split('\n').length, chars: foldText.length })
         : '';
     const peekOpen = block !== null && hovered && !selectionActive;
-    const windowStart = Math.max(0, Math.min(caretVisualLine - MAX_VISIBLE_LINES + 1, visualLines.length - MAX_VISIBLE_LINES));
-    const visibleLines = visualLines.slice(windowStart, windowStart + MAX_VISIBLE_LINES);
-    // Caret position in the caret's visual row, in two units:
-    // - char index (for slicing the row's characters in the render below)
-    // - visual column (for the physical cursor declaration — CJK characters
-    //   occupy TWO terminal columns, so the raw char count would park the
-    //   cursor mid-character and Windows Terminal would paint the IME
-    //   preedit (pinyin) over the surrounding text).
-    const caretCharCol = () => {
-        const before = block && cursor >= block.end ? value.slice(block.end, cursor) : value.slice(0, cursor);
-        const rows = wrapToWidth(before, inputWidth);
-        const last = rows[rows.length - 1] ?? '';
-        return last.length;
-    };
-    const caretVisualCol = () => {
-        const before = block && cursor >= block.end ? value.slice(block.end, cursor) : value.slice(0, cursor);
-        const rows = wrapToWidth(before, inputWidth);
-        const last = rows[rows.length - 1] ?? '';
-        return stringWidth(last);
-    };
+    // 展开态的编辑区行高预算：圆角边框 2 + 标题行 1 + 状态行 1 + 按钮行 1。
+    const editorMaxRows = Math.max(1, terminalRows - EDITOR_CHROME_ROWS);
+    if (expanded && caretVisualLine !== prevCaretLineRef.current) {
+        // A real caret move re-engages following after wheel browsing.
+        editorFreeScrollRef.current = false;
+        prevCaretLineRef.current = caretVisualLine;
+    }
+    let windowStart;
+    let visibleCount;
+    if (expanded) {
+        // 滚轮推动的窗口与 caret 跟随合并：自由滚动（滚轮浏览）期间不强制
+        // caret 可见；caret 移动后恢复跟随。写回 ref，滚轮分支读到的就是
+        // 合并后的基线。
+        let win = expandedScrollRef.current;
+        if (!editorFreeScrollRef.current) {
+            if (caretVisualLine < win)
+                win = caretVisualLine;
+            if (caretVisualLine >= win + editorMaxRows)
+                win = caretVisualLine - editorMaxRows + 1;
+        }
+        win = Math.max(0, Math.min(win, Math.max(0, visualLines.length - editorMaxRows)));
+        expandedScrollRef.current = win;
+        windowStart = win;
+        visibleCount = editorMaxRows;
+    }
+    else {
+        windowStart = Math.max(0, Math.min(caretVisualLine - MAX_VISIBLE_LINES + 1, visualLines.length - MAX_VISIBLE_LINES));
+        visibleCount = MAX_VISIBLE_LINES;
+    }
+    const visibleLines = visualLines.slice(windowStart, windowStart + visibleCount);
+    // useInput 的滚轮分支需要这份几何（它在这些派生之前注册）。
+    if (expanded) {
+        editorViewportRef.current = { maxRows: editorMaxRows, total: visualLines.length };
+    }
     // Folded chip content: block stats + first-line preview + hover hint,
     // all pre-truncated to the input width (the row is one line, always).
     const foldBadge = `▸ ${stats}`;
@@ -1262,7 +1938,71 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
     // row (only while the window is at the top and no block exists); its
     // cells fold the whole input into a block again on click.
     const prefixLabel = `▾ ${stats} · `;
-    const prefixCols = !block && big && windowStart === 0 ? stringWidth(prefixLabel) : 0;
+    const prefixCols = !block && !expanded && big && windowStart === 0 ? stringWidth(prefixLabel) : 0;
+    // Offset range [start, end) of every visual row — the SAME break rule as
+    // wrapToWidth — so the selection highlight can intersect each row. With a
+    // fold block, the chip row maps to the block's own span (never selected:
+    // updateSelection clamps the selection into the head or the tail side).
+    const lineRanges = block
+        ? [
+            ...visualLineRanges(head, inputWidth),
+            [block.start, block.end],
+            ...visualLineRanges(tail, inputWidth).map(([s, e]) => [s + block.end, e + block.end]),
+        ]
+        : visualLineRanges(value, inputWidth);
+    /**
+     * Inverse runs for one rendered row, shared by the inline prompt and the
+     * expanded editor: the selection's intersection (if any) and the caret
+     * cluster on the caret's row. Both render <Text inverse>; overlapping
+     * intervals merge so a caret inside the selection stays one continuous
+     * highlight. The caret row inverts the WHOLE cluster at the caret column
+     * (solid block) — [col, next boundary) covers a surrogate pair or ZWJ
+     * emoji as one glyph; at the text end it shows a blank inverse cell like
+     * the empty-input caret (appended after everything, so a selection
+     * ending there cannot swallow it).
+     */
+    const rowHighlightPieces = (text, absoluteLine) => {
+        const intervals = [];
+        const sel = selection;
+        if (sel) {
+            const [rowStart, rowEnd] = lineRanges[absoluteLine] ?? [0, 0];
+            const lo = Math.min(Math.max(sel.start - rowStart, 0), text.length);
+            const hi = Math.min(Math.max(sel.end - rowStart, 0), text.length);
+            if (hi > lo)
+                intervals.push([lo, hi]);
+        }
+        let endBlankCaret = false;
+        if (absoluteLine === caretVisualLine) {
+            const col = Math.min(caretCharCol, text.length);
+            const clusterEnd = nextGraphemeBoundary(graphemeBoundaries(text), col);
+            if (clusterEnd > col)
+                intervals.push([col, clusterEnd]);
+            else
+                endBlankCaret = col === text.length;
+        }
+        intervals.sort((a, b) => a[0] - b[0]);
+        const runs = [];
+        for (const [s, e] of intervals) {
+            const last = runs[runs.length - 1];
+            if (last && s <= last[1])
+                last[1] = Math.max(last[1], e);
+            else
+                runs.push([s, e]);
+        }
+        const pieces = [];
+        let pos = 0;
+        for (const [s, e] of runs) {
+            if (s > pos)
+                pieces.push({ text: text.slice(pos, s), inverse: false });
+            pieces.push({ text: text.slice(s, e), inverse: true });
+            pos = Math.max(pos, e);
+        }
+        if (pos < text.length)
+            pieces.push({ text: text.slice(pos), inverse: false });
+        if (endBlankCaret)
+            pieces.push({ text: ' ', inverse: true });
+        return pieces;
+    };
     const rendered = visibleLines.map((line, index) => {
         const absoluteLine = windowStart + index;
         if (block && absoluteLine === chipRow) {
@@ -1276,23 +2016,35 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
         const withPrefix = absoluteLine === 0 && prefixCols > 0;
         const text = withPrefix ? truncateToWidth(line, inputWidth - prefixCols) : line;
         const prefix = withPrefix ? _jsx(Text, { dimColor: true, children: prefixLabel }) : null;
-        if (absoluteLine !== caretVisualLine) {
-            return (_jsxs(Text, { wrap: "truncate-end", children: [prefix, text] }, absoluteLine));
-        }
-        // Caret row: invert the grapheme cluster at the caret column (solid
-        // block). `col` is a cluster boundary by construction (the cursor is
-        // normalized onto boundaries and wrapping only breaks between
-        // graphemes), so [col, next boundary) covers the WHOLE cluster — a
-        // surrogate pair or ZWJ emoji inverts as one glyph, never two broken
-        // halves. Clamped into the prefix-shortened row text so the block
-        // caret never renders under the fold prefix.
-        const col = Math.min(caretCharCol(), text.length);
-        const clusterEnd = nextGraphemeBoundary(graphemeBoundaries(text), col);
-        const before = text.slice(0, col);
-        const at = clusterEnd > col ? text.slice(col, clusterEnd) : ' ';
-        const after = text.slice(clusterEnd);
-        return (_jsxs(Text, { wrap: "truncate-end", children: [prefix, before, _jsx(Text, { inverse: true, children: at }), after] }, absoluteLine));
+        const pieces = rowHighlightPieces(text, absoluteLine);
+        return (_jsxs(Text, { wrap: "truncate-end", children: [prefix, pieces.length === 0 ? ' ' : pieces.map((piece, pieceIndex) => piece.inverse ? (_jsx(Text, { inverse: true, children: piece.text }, pieceIndex)) : (piece.text))] }, absoluteLine));
     });
+    // ── 展开态编辑行 ────────────────────────────────────────────────────
+    // Logical line number per visual row (a wrapped continuation keeps its
+    // line's number): the row's range end sitting on a '\n' starts a new
+    // logical line from the NEXT row.
+    const editorRowLogical = [];
+    if (expanded) {
+        let count = 0;
+        for (let i = 0; i < lineRanges.length; i++) {
+            editorRowLogical.push(count);
+            const rangeEnd = lineRanges[i][1];
+            if (value[rangeEnd] === '\n')
+                count++;
+        }
+    }
+    const editorRows = expanded
+        ? visibleLines.map((line, index) => {
+            const absoluteLine = windowStart + index;
+            const isCaretRow = absoluteLine === caretVisualLine;
+            const logicalNo = editorRowLogical[absoluteLine];
+            const gutterLabel = logicalNo === undefined
+                ? ' '.repeat(editorNoWidth)
+                : String(logicalNo + 1).padStart(editorNoWidth, ' ');
+            const pieces = rowHighlightPieces(line, absoluteLine);
+            return (_jsxs(Text, { wrap: "truncate-end", backgroundColor: isCaretRow ? 'toolCardBackgroundDim' : undefined, children: [_jsx(Text, { dimColor: !isCaretRow, bold: isCaretRow, color: isCaretRow ? promptAccent : undefined, children: `${gutterLabel} │ ` }), pieces.map((piece, pieceIndex) => piece.inverse ? (_jsx(Text, { inverse: true, children: piece.text }, pieceIndex)) : (piece.text))] }, absoluteLine));
+        })
+        : null;
     // Peek card content: the BLOCK's text wrapped to the card's inner width,
     // capped at PEEK_MAX_ROWS visual rows (a preview — click to expand and
     // edit the real input). The footer reports the clipped remainder.
@@ -1340,9 +2092,46 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
         // Clamp the declared column to the wrap width: a grapheme wider than
         // the last remaining column (emoji at width 1) can push the visual
         // column past inputWidth, and the park must stay inside the value box.
-        column: Math.min(caretVisualCol() + (caretVisualLine === 0 && prefixCols > 0 ? prefixCols : 0), inputWidth),
+        // In the expanded editor the declared box starts at its outer edge
+        // (padding + gutter included), so those columns ride along and the
+        // clamp grows with them.
+        column: Math.min(caretVisualCol +
+            (expanded
+                ? editorGutterCols + 1
+                : caretVisualLine === 0 && prefixCols > 0
+                    ? prefixCols
+                    : 0), expanded ? editorGutterCols + 1 + inputWidth : inputWidth),
         active: !selectionActive,
     });
+    /**
+     * Map a pointer position relative to the value box to a UTF-16 offset
+     * via the same grapheme walk the renderer wraps with — exact under CJK
+     * widths, wrapped rows and multi-codepoint clusters. Rows are clamped to
+     * the VISIBLE window (drag moves never auto-scroll past it in v1); the
+     * fold chip row maps to null (its cells belong to the expand affordance,
+     * not to text).
+     */
+    const localToOffset = (localCol, localRow) => {
+        const lastVisible = Math.min(visualLines.length - 1, windowStart + visibleCount - 1);
+        const clamped = Math.max(windowStart, Math.min(windowStart + localRow, lastVisible));
+        // Fold prefix (▾) row: the rendered first row is truncated by prefixCols,
+        // so both the column and the wrap budget shift — without the correction
+        // a drag starting on the first row lands prefixCols to the right of the
+        // pointer (parity with handleValueClick's click mapping). Presses ON the
+        // prefix cells clamp to the row start (drag-from-0, like selecting the
+        // whole first row backwards).
+        const isPrefixRow = !block && clamped === 0 && prefixCols > 0;
+        const col = isPrefixRow ? Math.max(0, localCol - prefixCols) : localCol;
+        const width = isPrefixRow ? inputWidth - prefixCols : inputWidth;
+        if (block) {
+            if (clamped === chipRow)
+                return null;
+            return clamped < chipRow
+                ? clickToCursorOffset(head, width, clamped, col)
+                : block.end + clickToCursorOffset(tail, width, clamped - chipRow - 1, col);
+        }
+        return clickToCursorOffset(value, width, clamped, col);
+    };
     /**
      * Click-to-position the caret: map a click inside the value box (local
      * row/column relative to the box) to a UTF-16 cursor offset via the same
@@ -1351,38 +2140,141 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
      * the clicked cell (mid-grapheme snaps to its start). With a fold block,
      * clicks map into the head/tail text (the chip row has its own expand
      * onClick); without one, the fold prefix's cells fold the whole input.
+     *
+     * The drag protocol resets ink's multi-click chain on every press inside
+     * the value box (it carries onDragStart), so double-click word selection
+     * is self-detected here: two clicks within DOUBLE_CLICK_MS and one cell.
+     * Shift+click extends the selection from its start edge (or the caret)
+     * to the clicked offset; a plain click clears the selection and moves
+     * the caret.
+     *
+     * `colOffset` shifts the local column origin: the expanded editor's
+     * value box starts at the line-number gutter, so its callers subtract
+     * the gutter width (0 for the inline prompt).
      */
-    const handleValueClick = React.useCallback((e) => {
+    const handleValueClick = (e, colOffset = 0) => {
+        const now = Date.now();
+        const modified = e.shift || e.alt || e.ctrl;
+        const isDouble = !modified &&
+            now - lastClickAtRef.current < DOUBLE_CLICK_MS &&
+            Math.abs(e.col - lastClickColRef.current) <= 1 &&
+            Math.abs(e.row - lastClickRowRef.current) <= 1;
+        if (modified) {
+            // Shift+click is range extension, never a word-select click. It also
+            // breaks the local chain so a following plain click cannot complete a
+            // double-click that started under a modifier.
+            lastClickAtRef.current = 0;
+            lastClickColRef.current = -1;
+            lastClickRowRef.current = -1;
+        }
+        else {
+            lastClickAtRef.current = now;
+            lastClickColRef.current = e.col;
+            lastClickRowRef.current = e.row;
+        }
+        const localCol = e.localCol - colOffset;
         const clickedVisual = windowStart + e.localRow;
         const clamped = Math.max(0, Math.min(clickedVisual, visualLines.length - 1));
         if (block) {
             if (clamped === chipRow)
                 return;
-            if (clamped < chipRow) {
-                setCursor(clickToCursorOffset(head, inputWidth, clamped, e.localCol));
+            const offset = clamped < chipRow
+                ? clickToCursorOffset(head, inputWidth, clamped, localCol, isDouble ? 'grapheme-start' : 'nearest')
+                : block.end + clickToCursorOffset(tail, inputWidth, clamped - chipRow - 1, localCol, isDouble ? 'grapheme-start' : 'nearest');
+            if (isDouble) {
+                // Word select stays inside the clicked side: the block is atomic.
+                const side = offset <= block.start;
+                const w = wordSelectionAt(value, offset, side ? 0 : block.end, side ? block.start : value.length);
+                if (w) {
+                    updateSelection(w.start, w.end);
+                    setCursor(w.end);
+                }
+                return;
             }
-            else {
-                setCursor(block.end + clickToCursorOffset(tail, inputWidth, clamped - chipRow - 1, e.localCol));
+            if (e.shift) {
+                const base = selectionRef.current ? selectionRef.current.start : cursorRef.current;
+                updateSelection(base, offset);
+                setCursor(offset);
+                return;
             }
+            clearSelection();
+            setCursor(offset);
             return;
         }
-        if (clamped === 0 && prefixCols > 0 && e.localCol < prefixCols) {
+        if (clamped === 0 && prefixCols > 0 && localCol < prefixCols) {
+            // Folding hides the entire editable projection, so no selection may
+            // survive invisibly inside the chip and keep owning Ctrl+C/Delete.
+            clearSelection();
+            dragAnchorRef.current = null;
+            setCursor(value.length);
             updateFoldBlock({ start: 0, end: value.length });
             return;
         }
-        const col = clamped === 0 && prefixCols > 0 ? Math.max(0, e.localCol - prefixCols) : e.localCol;
-        setCursor(clickToCursorOffset(value, clamped === 0 && prefixCols > 0 ? inputWidth - prefixCols : inputWidth, clamped, col));
-    }, [windowStart, visualLines.length, value, inputWidth, prefixCols, block, chipRow, head, tail]);
+        const col = clamped === 0 && prefixCols > 0 ? Math.max(0, localCol - prefixCols) : localCol;
+        const offset = clickToCursorOffset(value, clamped === 0 && prefixCols > 0 ? inputWidth - prefixCols : inputWidth, clamped, col, isDouble ? 'grapheme-start' : 'nearest');
+        if (isDouble) {
+            const w = wordSelectionAt(value, offset, 0, value.length);
+            if (w) {
+                updateSelection(w.start, w.end);
+                setCursor(w.end);
+            }
+            return;
+        }
+        if (e.shift) {
+            const base = selectionRef.current ? selectionRef.current.start : cursorRef.current;
+            updateSelection(base, offset);
+            setCursor(offset);
+            return;
+        }
+        clearSelection();
+        setCursor(offset);
+    };
+    /**
+     * Drag selection (component-level drag protocol): the press origin is
+     * derived from the event's start/current delta (dragstart fires on the
+     * FIRST motion), the focus follows every dragmove. The caret rides the
+     * focus edge; updateSelection clamps both ends into one fold side, so a
+     * drag can never cross the chip row. `colOffset` as in handleValueClick.
+     */
+    const handleDragStart = (e, colOffset = 0) => {
+        const anchorLocalCol = e.localCol - (e.col - e.startCol) - colOffset;
+        const anchorLocalRow = e.localRow - (e.row - e.startRow);
+        const anchor = localToOffset(anchorLocalCol, anchorLocalRow);
+        if (anchor === null) {
+            dragAnchorRef.current = null;
+            return;
+        }
+        dragAnchorRef.current = anchor;
+        setCursor(anchor);
+    };
+    const handleDragMove = (e, colOffset = 0) => {
+        const anchor = dragAnchorRef.current;
+        if (anchor === null)
+            return;
+        const focus = localToOffset(e.localCol - colOffset, e.localRow);
+        if (focus === null)
+            return;
+        // The caret rides the focus edge, clamped into the anchor's fold side
+        // exactly like updateSelection clamps the range — the caret must never
+        // jump across the chip row while the selection stays behind.
+        let caret = focus;
+        const block = foldBlockRef.current;
+        if (block) {
+            caret = anchor <= block.start ? Math.min(focus, block.start) : Math.max(focus, block.end);
+        }
+        updateSelection(anchor, focus);
+        setCursor(normalizeCursorOffset(valueRef.current, caret));
+    };
+    const handleDragEnd = () => {
+        dragAnchorRef.current = null;
+    };
     // 浮层整体挂载条件：与内部面板可见条件精确同值。关闭时必须把整个
     // absolute 浮层移除——渲染器的 absolute-removed 检测只看被移除节点自身
     // 的 style.position，常驻浮层 + 移除普通子节点不会触发 blit 解毒，被
-    // 覆盖的转录行会留空（见 Chat.tsx dialogOverlayOpen 注释）。
-    const floatersOpen = helpOpen || channel.pending.length > 0 || fileOverlayOpen || overlayOpen || peekOpen;
-    // 补全卡片边框与输入框 idle 边框同色（plan 模式下整套面板一起变 sage 绿）。
-    // `/color` 会话强调色优先于主题 promptBorder（plan 模式仍整体走 sage 绿）。
-    // `?? ''` 防御最小 mock channel（只声明用到的字段的回归脚本）。
-    const sessionAccent = sessionColorHex(channel.sessionColor ?? '');
-    const promptAccent = channel.mode.plan === true ? 'planMode' : (sessionAccent ?? 'promptBorder');
+    // 覆盖的转录行会留空（见 Chat.tsx dialogOverlayOpen 注释）。展开态由
+    // 全屏编辑器接管，内联浮层全部撤下。
+    const floatersOpen = !expanded &&
+        (helpOpen || channel.pending.length > 0 || fileOverlayOpen || overlayOpen || peekOpen);
     // 顶边框右侧的会话名标签（CC 风格 chip）：色随强调色；超宽截断，宽度
     // 随终端列数伸缩但不超过 28 显示单元。默认关闭——`/settings` 的
     // 「会话名标签」开关（dsh-tui.promptSessionLabel）开启后显示。
@@ -1410,6 +2302,60 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
         ink?.invalidatePrevFrame();
         ink?.reanchorViewport();
     }, [floatersOpen]);
+    // 展开态开关 = 全屏覆盖增删：与浮层开关同款的视口重锚（inline 模式的
+    // 虚屏↔scrollback 映射不漂移），并在展开首帧把滚动窗口归零。
+    React.useLayoutEffect(() => {
+        if (expanded === prevExpandedRef.current)
+            return;
+        prevExpandedRef.current = expanded;
+        if (expanded)
+            expandedScrollRef.current = 0;
+        const ink = instances.get(process.stdout) ?? instances.values().next().value;
+        ink?.invalidatePrevFrame();
+        ink?.reanchorViewport();
+    }, [expanded]);
+    // Feature turned off mid-session while the editor is up: withdraw the
+    // cover (the draft and every other editing state survive).
+    React.useEffect(() => {
+        if (expanded && !expandEnabled)
+            collapseEditor();
+    }, [expanded, expandEnabled]);
+    // ── 全屏草稿编辑节点 ────────────────────────────────────────────────
+    // 每次渲染构造新鲜闭包（value/caret/handlers），经 module store 发布给
+    // Chat 根部末尾的 PromptEditorLayer（树序最后 → 盖住全部后绘兄弟）。
+    // useInsertionEffect 发布：sink 的同步重渲染发生在 layout 阶段之前，
+    // useDeclaredCursor（layout effect）读到的新 ref 已指向编辑区 Box。
+    // 点击/拖拽坐标以内容区为原点（localCol 去掉行号槽宽度）。
+    const editorNode = expanded ? (_jsxs(Box, { flexDirection: "column", width: "100%", height: "100%", borderStyle: "round", borderColor: promptAccent, backgroundColor: "toolCardBackground", children: [_jsxs(Box, { flexDirection: "row", flexShrink: 0, paddingLeft: 1, paddingRight: 1, children: [_jsx(Text, { bold: true, color: promptAccent, children: `✎ ${t('input-expand-editor-title')}` }), _jsx(Box, { flexGrow: 1 }), _jsx(Text, { dimColor: true, children: t('input-fold-stats', {
+                            lines: value.split('\n').length,
+                            chars: value.length,
+                        }) })] }), _jsx(Box, { ref: valueBoxRef, flexDirection: "column", flexGrow: 1, flexShrink: 1, paddingLeft: 1, paddingRight: 1, onClick: (event) => {
+                    handleValueClick(event, editorGutterCols + 1);
+                }, onDragStart: (event) => {
+                    handleDragStart(event, editorGutterCols + 1);
+                }, onDragMove: (event) => {
+                    handleDragMove(event, editorGutterCols + 1);
+                }, onDragEnd: handleDragEnd, onWheel: (event) => {
+                    const viewport = editorViewportRef.current;
+                    if (!viewport)
+                        return;
+                    editorFreeScrollRef.current = true;
+                    const max = Math.max(0, viewport.total - viewport.maxRows);
+                    expandedScrollRef.current = Math.max(0, Math.min(expandedScrollRef.current + Math.round(event.deltaY), max));
+                    setExpandedTick(tick => tick + 1);
+                }, children: editorRows }), _jsxs(Box, { flexDirection: "row", flexShrink: 0, paddingLeft: 1, paddingRight: 1, children: [vimEnabled && (_jsxs(Text, { bold: true, color: vimInsert ? 'success' : 'warning', children: [vimInsert ? 'INSERT' : 'NORMAL', ' '] })), _jsx(Text, { dimColor: true, children: t('input-expand-editor-position', {
+                            line: cursorLine(value, cursor) + 1,
+                            col: cursorColumn(value, cursor) + 1,
+                        }) }), _jsx(Box, { flexGrow: 1 }), _jsx(Text, { dimColor: true, children: `${t('input-expand-editor-hint-send')} · ${t('input-expand-editor-hint-collapse')}` })] }), _jsxs(Box, { flexDirection: "row", flexShrink: 0, paddingLeft: 1, paddingRight: 1, columnGap: 1, children: [_jsx(EditorButton, { label: `⏎ ${t('input-expand-editor-send')}`, hint: "Ctrl+Enter", primary: true, accent: promptAccent, onClick: submitFromEditor }), _jsx(EditorButton, { label: t('input-expand-editor-collapse'), hint: "Esc", onClick: collapseEditor }), _jsx(Box, { flexGrow: 1 }), _jsx(Text, { dimColor: true, children: t('input-expand-editor-scroll') })] })] })) : null;
+    React.useInsertionEffect(() => {
+        setPromptEditorNode(editorNode);
+    });
+    React.useEffect(() => {
+        // 卸载保险：PromptInput 被替换（问卷/面板接管）时撤下全屏浮层。
+        return () => {
+            setPromptEditorNode(null);
+        };
+    }, []);
     return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [floatersOpen && (_jsxs(OverlayAbove, { maxHeight: Math.max(terminalRows - 6, 1), children: [helpOpen && (_jsx(Box, { marginBottom: 1, children: _jsx(HelpMenu, { commands: channel.commandList, viewportHeight: helpViewportHeight, viewportWidth: columns, scrollRef: helpScrollRef, onCommandPick: (name) => {
                                 // 点击命令行 = 填入 /name 并关闭帮助（Tab 补全的鼠标等价）
                                 updateFoldBlock(null);
@@ -1444,85 +2390,174 @@ export function PromptInput({ channel, helpOpen, onToggleHelp, onRunCommand, sel
                                 : undefined, rows: peekVisualLines.map((row, index) => (_jsx(Text, { wrap: "truncate-end", children: row }, index))), onRowPick: () => {
                                 updateFoldBlock(null);
                                 setHovered(false);
-                            } }) }))] })), lastNotification && (_jsx(Box, { position: "absolute", marginTop: -1, height: 1, width: "100%", paddingLeft: 2, paddingRight: 1, flexDirection: "column", justifyContent: "flex-end", overflow: "hidden", children: _jsx(Box, { justifyContent: "flex-end", children: _jsx(Text, { color: lastNotification.color, dimColor: !lastNotification.color, wrap: "truncate", children: lastNotification.text }) }) })), _jsx(EffortInputBorder, { effort: channel.reasoningEffort, levels: channel.effortLevels, columns: columns, onLight: isLightThemeActive(themeName), idleColor: promptAccent, topRightLabel: topRightLabel, children: _jsxs(Box, { flexDirection: "row", alignItems: "flex-start", width: "100%", children: [_jsx(EffortChargeGlyph, { effort: channel.reasoningEffort, levels: channel.effortLevels, working: channel.working }), _jsx(Box, { ref: valueBoxRef, flexGrow: 1, flexShrink: 1, onClick: handleValueClick, children: value.length === 0 ? (_jsxs(_Fragment, { children: [_jsx(Text, { inverse: true, children: " " }), _jsx(EffortTierBadge, { effort: channel.reasoningEffort, levels: channel.effortLevels, onLight: isLightThemeActive(themeName), columns: columns, leadingColumns: 3 })] })) : (_jsx(Box, { flexDirection: "column", children: rendered })) })] }) })] }));
+                            } }) }))] })), lastNotification && (_jsx(Box, { position: "absolute", marginTop: -1, height: 1, width: "100%", paddingLeft: 2, paddingRight: 1, flexDirection: "column", justifyContent: "flex-end", overflow: "hidden", children: _jsx(Box, { justifyContent: "flex-end", children: _jsx(Text, { color: lastNotification.color, dimColor: !lastNotification.color, wrap: "truncate", children: lastNotification.text }) }) })), _jsx(EffortInputBorder, { effort: channel.reasoningEffort, levels: channel.effortLevels, columns: columns, onLight: isLightThemeActive(themeName), idleColor: promptAccent, topRightLabel: topRightLabel, children: _jsxs(Box, { flexDirection: "row", alignItems: "flex-start", width: "100%", children: [_jsx(EffortChargeGlyph, { effort: channel.reasoningEffort, levels: channel.effortLevels, working: channel.working }), vimEnabled && (_jsxs(Text, { bold: true, color: vimInsert ? 'success' : 'warning', children: [vimInsert ? 'INSERT' : 'NORMAL', " "] })), _jsx(Box, { ref: expanded ? undefined : valueBoxRef, flexGrow: 1, flexShrink: 1, onClick: handleValueClick, onDragStart: handleDragStart, onDragMove: handleDragMove, onDragEnd: handleDragEnd, children: value.length === 0 ? (_jsxs(_Fragment, { children: [_jsx(Text, { inverse: true, children: " " }), _jsx(EffortTierBadge, { effort: channel.reasoningEffort, levels: channel.effortLevels, onLight: isLightThemeActive(themeName), columns: columns, leadingColumns: 3 })] })) : (_jsx(Box, { flexDirection: "column", children: rendered })) }), expandEnabled && (_jsx(Box, { flexShrink: 0, onClick: (event) => {
+                                event.stopImmediatePropagation();
+                                toggleExpand();
+                            }, onMouseEnter: () => {
+                                setExpandHovered(true);
+                            }, onMouseLeave: () => {
+                                setExpandHovered(false);
+                            }, children: _jsx(Text, { dimColor: !expandHovered, bold: expandHovered, color: expandHovered ? promptAccent : undefined, children: "\u26F6" }) }))] }) })] }));
 }
 /**
- * Hard-wrap text into visual rows of at most `width` columns (CJK-aware via
- * stringWidth). Used by the input renderer so long lines wrap instead of
- * truncating, with exact caret-row mapping. Wrapping only ever breaks
- * BETWEEN grapheme clusters: iterating code points would split ZWJ emoji
- * and combining sequences across rows, leaving a broken half at each edge
- * and desyncing the caret's row arithmetic (which walks cluster
- * boundaries).
+ * Grapheme word-wrap for one logical line: break at the last space when
+ * the row overflows; hard-wrap a word that cannot fit; never split a
+ * cluster (ZWJ emoji, combining sequences, CJK wide cells stay whole).
  */
-function wrapToWidth(text, width) {
+function wrapLineRows(line, width) {
+    if (line === '')
+        return [{ start: 0, end: 0 }];
     const rows = [];
     const segmenter = getGraphemeSegmenter();
-    for (const line of text.split('\n')) {
-        if (line === '') {
-            rows.push('');
-            continue;
-        }
-        let current = '';
-        let currentWidth = 0;
-        for (const { segment } of segmenter.segment(line)) {
-            const w = stringWidth(segment);
-            if (currentWidth + w > width && current !== '') {
-                rows.push(current);
-                current = segment;
-                currentWidth = w;
+    let rowStart = 0;
+    let currentWidth = 0;
+    let offset = 0;
+    let lastBreak = -1;
+    for (const { segment } of segmenter.segment(line)) {
+        const w = stringWidth(segment);
+        while (currentWidth + w > width && offset > rowStart) {
+            if (lastBreak > rowStart) {
+                rows.push({ start: rowStart, end: lastBreak });
+                rowStart = lastBreak;
+                currentWidth = stringWidth(line.slice(rowStart, offset));
+                lastBreak = -1;
             }
             else {
-                current += segment;
-                currentWidth += w;
+                rows.push({ start: rowStart, end: offset });
+                rowStart = offset;
+                currentWidth = 0;
+                lastBreak = -1;
             }
         }
-        rows.push(current);
+        currentWidth += w;
+        offset += segment.length;
+        if (segment === ' ')
+            lastBreak = offset;
     }
+    rows.push({ start: rowStart, end: offset });
     return rows;
 }
+/** Wrap text to `width` columns via {@link wrapLineRows} (newlines honoured). */
+function wrapToWidth(text, width) {
+    return text.split('\n').flatMap(line => wrapLineRows(line, width).map(r => line.slice(r.start, r.end)));
+}
+/**
+ * Locate `offset` in the wrapped layout of `text`. Uses the full wrap —
+ * not a prefix — so a cursor inside a carried word maps to the displayed
+ * row. At a wrap join the caret stays on the earlier row (after the space).
+ */
+function caretInText(text, width, offset) {
+    let line = 0;
+    let lineBase = 0;
+    let last = { line: 0, charCol: 0, visualCol: 0 };
+    for (const logical of text.split('\n')) {
+        for (const r of wrapLineRows(logical, width)) {
+            const start = lineBase + r.start;
+            const charCol = Math.max(0, offset - start);
+            last = {
+                line,
+                charCol,
+                visualCol: stringWidth(logical.slice(r.start, r.start + charCol)),
+            };
+            if (offset <= lineBase + r.end)
+                return last;
+            line++;
+        }
+        lineBase += logical.length + 1;
+    }
+    return last;
+}
 /**
  * Inverse of {@link wrapToWidth}: map a click position (visual row index +
- * visual column) back to a UTF-16 offset in the original text. Walks the
- * same grapheme boundaries with the same break rule, so every visual row's
- * start offset is known exactly. Within the clicked row, the caret snaps to
- * the boundary nearest the click: a grapheme whose midpoint lies past the
+ * visual column) back to a UTF-16 offset in the original text. Uses the
+ * same {@link wrapLineRows} row boundaries, so every visual row's start
+ * offset is known exactly. Within the clicked row, the caret snaps to the
+ * boundary nearest the click: a grapheme whose midpoint lies past the
  * click column takes the caret before it, otherwise after.
  */
-function clickToCursorOffset(text, width, visualLine, visualCol) {
+function clickToCursorOffset(text, width, visualLine, visualCol, snapWithin = 'nearest') {
     const segmenter = getGraphemeSegmenter();
     let row = 0;
-    let offset = 0;
+    let lineBase = 0;
     for (const line of text.split('\n')) {
-        if (line === '') {
-            if (row === visualLine)
-                return offset;
-            row++;
-            offset++; // the '\n'
-            continue;
-        }
-        let currentWidth = 0;
-        for (const { segment } of segmenter.segment(line)) {
-            const w = stringWidth(segment);
-            if (currentWidth + w > width && currentWidth > 0) {
-                if (row === visualLine)
-                    return offset; // end of the clicked wrapped row
-                row++;
-                currentWidth = 0;
-            }
+        for (const r of wrapLineRows(line, width)) {
             if (row === visualLine) {
-                if (currentWidth + w / 2 > visualCol)
-                    return offset;
-                if (currentWidth + w > visualCol)
-                    return offset + segment.length;
+                let currentWidth = 0;
+                let local = 0;
+                for (const { segment } of segmenter.segment(line.slice(r.start, r.end))) {
+                    const w = stringWidth(segment);
+                    // Caret positioning uses the nearest edge. Double-click selection
+                    // instead needs the grapheme UNDER the cell: on the second cell of a
+                    // CJK/emoji glyph, nearest-edge would point after the glyph (and the
+                    // final glyph would select nothing).
+                    if (snapWithin === 'grapheme-start' && currentWidth + w > visualCol) {
+                        return lineBase + r.start + local;
+                    }
+                    if (currentWidth + w / 2 > visualCol)
+                        return lineBase + r.start + local;
+                    if (currentWidth + w > visualCol)
+                        return lineBase + r.start + local + segment.length;
+                    currentWidth += w;
+                    local += segment.length;
+                }
+                return lineBase + r.end;
             }
-            currentWidth += w;
-            offset += segment.length;
+            row++;
         }
-        if (row === visualLine)
-            return offset;
-        row++;
-        offset++; // the '\n'
+        lineBase += line.length + 1;
+    }
+    return lineBase;
+}
+/**
+ * Offset range [start, end) of every visual row, using the same {@link
+ * wrapLineRows} boundaries as `wrapToWidth`. The selection highlight
+ * intersects each row with these ranges so offsets map 1:1 onto the
+ * rendered row strings.
+ */
+function visualLineRanges(text, width) {
+    const ranges = [];
+    let lineBase = 0;
+    for (const line of text.split('\n')) {
+        for (const r of wrapLineRows(line, width))
+            ranges.push([lineBase + r.start, lineBase + r.end]);
+        lineBase += line.length + 1;
     }
-    return offset;
+    return ranges;
+}
+/** Word characters for double-click selection: letters (any script),
+ *  digits and the punctuation set terminal emulators treat as word-part by
+ *  default (`/usr/bin/bash` selects whole — iTerm2 defaults). */
+const WORD_CHAR = /[\p{L}\p{N}_/.\-+~\\]/u;
+/** Character class for double-click word expansion: whitespace, word
+ *  char, everything else (punctuation/symbols). A same-class grapheme
+ *  run is one word. */
+function selectionCharClass(c) {
+    if (c === '' || /\s/.test(c))
+        return 0;
+    if (WORD_CHAR.test(c))
+        return 1;
+    return 2;
+}
+/**
+ * Word selection around `offset` within [lo, hi): expand left/right over
+ * grapheme clusters of the same class as the clicked one (terminal
+ * double-click semantics — punctuation runs select as one). Returns null
+ * when the offset sits at the range's end (nothing to select).
+ */
+function wordSelectionAt(text, offset, lo, hi) {
+    if (offset < lo || offset >= hi)
+        return null;
+    const bounds = graphemeBoundaries(text.slice(lo, hi)).map(b => b + lo);
+    let i = 0;
+    while (i < bounds.length - 1 && bounds[i + 1] <= offset)
+        i++;
+    const clusterAt = (index) => text.slice(bounds[index], bounds[index + 1]);
+    const cls = selectionCharClass(clusterAt(i));
+    let a = i;
+    while (a > 0 && selectionCharClass(clusterAt(a - 1)) === cls)
+        a--;
+    let b = i;
+    while (b < bounds.length - 2 && selectionCharClass(clusterAt(b + 1)) === cls)
+        b++;
+    return { start: bounds[a], end: bounds[b + 1] };
 }