mocode-ai 1.2.10 → 1.3.1

package/dist/ui/prompt.js

@@ -73,76 +73,24 @@ export async function promptWithSlashMenu(opts) {
     }
     const emitter = stdin;
     const promptW = displayWidth(opts.prompt);
-    // initialLines(运行中 typeahead 预填):用调用方给的行初始化,光标置末行末尾。
-    let lines = opts.initialLines && opts.initialLines.length > 0
-        ? [...opts.initialLines]
-        : [''];
-    let cl = lines.length - 1; // 光标行(0-based)= 末行
-    let cc = lines[cl].length; // 光标在该行的字符索引 = 末行末尾
+    // initialLines(运行中 typeahead 预填):用调用方给的行初始化;光标置文末。
+    // 整篇输入是一个 Seg[]:可编辑段与粘贴块交替。光标永远落在某个可编辑段(segs[curSeg].frozen===false)上。
+    let segs = opts.initialLines && opts.initialLines.length > 0
+        ? [{ frozen: false, text: opts.initialLines.join('\n') }]
+        : [{ frozen: false, text: '' }];
+    let curSeg = 0; // 光标所在段(始终可编辑)
+    let curOff = segs[0].text.length; // 段内字符偏移 = 文末
     let justSawCR = false; // \r\n 合一:粘贴的 \r 折行后,紧跟的 \n 吞掉(避免折两行)
-    let chip = null; // 原子粘贴块:整段封进 [预览…],不可编辑;提交时拼回全文
-    let chipPre = ''; // chip 之前已存在的文本(粘贴发生时光标前的原文,原样多行保留,不截断);随 chip 一起提交/删除
     let menuOpen = false;
     let selected = 0;
     let filtered = [];
     const MENU_MAX_VISIBLE = 7;
     let menuTop = 0; // 窗口首项在 filtered 中的索引,菜单最多显示 MENU_MAX_VISIBLE 条
+    /** Ctrl+C 清空前的缓冲快照(Ctrl+Z 还原一次);单次生效,还原后即清。 */
+    let undoSnapshot = null;
     let resolved = false;
     let resolve;
     let reject;
-    const queryHistory = opts.queryHistory ?? [];
-    let historyIndex = queryHistory.length; // length = 草稿哨兵；0..length-1 = 历史项
-    let historyDraft = null;
-    /** 用历史 query 替换编辑缓冲；历史内容恢复为普通可编辑文本。 */
-    function loadHistoryEntry(value) {
-        lines = value.split('\n');
-        cl = lines.length - 1;
-        cc = lines[cl].length;
-        chip = null;
-        chipPre = '';
-        selected = 0;
-        menuTop = 0;
-        justSawCR = false;
-        computeFiltered();
-        redraw();
-    }
-    /** 在首次离开最新位置时保存完整草稿，然后向更旧的 query 移动。 */
-    function recallPrevious() {
-        if (queryHistory.length === 0 || historyIndex <= 0)
-            return;
-        if (historyIndex === queryHistory.length) {
-            historyDraft = {
-                lines: [...lines],
-                cl,
-                cc,
-                chip,
-                chipPre,
-            };
-        }
-        historyIndex--;
-        loadHistoryEntry(queryHistory[historyIndex]);
-    }
-    /** 向更新的 query 移动；越过最新历史时恢复进入历史前的草稿。 */
-    function recallNext() {
-        if (historyIndex >= queryHistory.length)
-            return;
-        historyIndex++;
-        if (historyIndex < queryHistory.length) {
-            loadHistoryEntry(queryHistory[historyIndex]);
-            return;
-        }
-        const draft = historyDraft;
-        lines = draft ? [...draft.lines] : [''];
-        cl = draft?.cl ?? 0;
-        cc = draft?.cc ?? 0;
-        chip = draft?.chip ?? null;
-        chipPre = draft?.chipPre ?? '';
-        selected = 0;
-        menuTop = 0;
-        justSawCR = false;
-        computeFiltered();
-        redraw();
-    }
     /** 菜单行(预渲染,带色)——向上展开进内容区底,由 layout 贴入。最多显示 MENU_MAX_VISIBLE 条,支持上下滚动。 */
     function menuLines() {
         if (!menuOpen || filtered.length === 0)
@@ -180,90 +128,163 @@ export async function promptWithSlashMenu(opts) {
             return `${marker} ${color}${name}${ui.reset}  ${color}${descStr}${ui.reset}${ui.dim}${scrollHint}${ui.reset}`;
         });
     }
-    /** 当前光标在该行的显示列(供 layout 定位光标)。 */
-    function cursorCol() {
-        return displayWidth(lines[cl].slice(0, cc));
-    }
-    /** chip 预览前缀:行数 + 字符数(字符 <1K 直出,≥1K 缩为 X.XK)。比"前 20 字符截断"对 CJK 更友好
-     * ——后者在中文里 20 列只够 10 个汉字就截没,几乎看不到内容;元信息密度更高、长度可预测。 */
-    function chipPrefix() {
-        if (!chip)
-            return '';
-        const lines = chip.split('\n').length;
-        const chars = chip.length;
-        const lineText = t('prompt.lines', { count: lines });
+    /** 单个 chip 的展示 token:[📋 行数 · 字符数] (含尾部空格,使相邻 chip 之间留空隙)。 */
+    function chipToken(text) {
+        const lineCount = text.split('\n').length;
+        const charCount = text.length;
+        const lineText = t('prompt.lines', { count: lineCount });
         const charText = t('prompt.chars', {
-            count: chars < 1000 ? chars : `${(chars / 1000).toFixed(1)}K`,
+            count: charCount < 1000 ? charCount : `${(charCount / 1000).toFixed(1)}K`,
         });
         return `[📋 ${lineText} · ${charText}] `;
     }
-    /** chipPre 按行拆分(粘贴发生前光标之前已有的文本,可能多行,原样保留在 chip 之前)。 */
-    function chipPreLines() {
-        return chip ? chipPre.split('\n') : [];
+    /** 构建整段显示:可编辑段按原文(含换行)展开,粘贴块(chip)折叠成一行 token 内联在光标原位。
+     *  返回展示行数组,以及每个段在"展示串"(= 展示行以 \n 拼接)中的字符起点,供光标正/反向映射。
+     *  关键不变量:展示串与 segs 的"段贡献"长度一致(可编辑段贡献其原文长度,含其中 \n;
+     *  chip 贡献其 token 长度,无 \n),故 segStart 同时是 dispLines.join('\n') 内的字符偏移。 */
+    function buildDisplay() {
+        const out = [];
+        const segStart = [];
+        let gLen = 0;
+        for (const s of segs) {
+            segStart.push(gLen);
+            if (!s.frozen) {
+                const ls = s.text.split('\n');
+                if (out.length === 0)
+                    out.push(...ls);
+                else {
+                    out[out.length - 1] += ls[0];
+                    for (let k = 1; k < ls.length; k++)
+                        out.push(ls[k]);
+                }
+                gLen += s.text.length;
+            }
+            else {
+                const tok = chipToken(s.text);
+                if (out.length === 0)
+                    out.push(tok);
+                else
+                    out[out.length - 1] += tok;
+                gLen += tok.length;
+            }
+        }
+        if (out.length === 0)
+            out.push('');
+        return { lines: out, segStart };
+    }
+    /** 当前光标段内显示列。 */
+    function cursorCol() {
+        return displayWidth(segs[curSeg].text.slice(0, curOff));
     }
-    /** 供 layout 画的行:chipPre 的行原样排在前面,最后一行接上 chip 前缀 + suffix 第 0 行
-     * (chip 原子显示,不可编辑;chipPre 同样不可直接编辑,光标只活在 suffix)。 */
-    function dispLines() {
-        if (!chip)
-            return lines;
-        const pre = chipPreLines();
-        const lastPre = pre[pre.length - 1];
-        const mergedRow = lastPre + chipPrefix() + lines[0];
-        return [...pre.slice(0, -1), mergedRow, ...lines.slice(1)];
+    /** 光标 → 展示 (行, 列)。展示行内的列以显示宽度计。 */
+    function cursorDisp() {
+        const { lines: dispLines, segStart } = buildDisplay();
+        const off = segStart[curSeg] + curOff;
+        let remaining = off;
+        let dl = 0;
+        let dispColChars = 0;
+        for (; dl < dispLines.length; dl++) {
+            const L = dispLines[dl].length;
+            if (remaining <= L) {
+                dispColChars = remaining;
+                break;
+            }
+            remaining -= L + 1;
+        }
+        if (dl >= dispLines.length) {
+            dl = Math.max(0, dispLines.length - 1);
+            dispColChars = dispLines[dl].length;
+        }
+        return { line: dl, col: displayWidth(dispLines[dl].slice(0, dispColChars)) };
     }
-    /** 供 layout 定位光标行:chipPre 多出的行数计入偏移(suffix 的 cl=0 对应 chipPre 最后一行所在的合并行)。 */
-    function dispCursorLine() {
-        return chip ? chipPreLines().length - 1 + cl : cl;
+    /** 展示 (行, 显示列) → 段内字符偏移。供 ↑/↓ 移动后重新定位,以及鼠标点击的反向映射。 */
+    function dispColToCharInLine(dispLine, dispCol) {
+        const { lines } = buildDisplay();
+        const ln = lines[dispLine] ?? '';
+        return visColToCharCol(ln, dispCol);
     }
-    /** 供 layout 定位光标列:chip 在合并行(cl===0)时偏移 chipPre 末行宽度 + chipPrefix 宽度。 */
-    function dispCursorCol() {
-        if (!chip || cl !== 0)
-            return cursorCol();
-        const pre = chipPreLines();
-        return displayWidth(pre[pre.length - 1]) + displayWidth(chipPrefix()) + cursorCol();
+    /** 展示 (行, 字符内偏移) → 段+偏移。光标永远落在可编辑段;点中 chip 则吸附到最近的可编辑边界。 */
+    function mapDispToCursor(dispLine, charInLine) {
+        const { lines: dispLines, segStart } = buildDisplay();
+        let off = 0;
+        for (let k = 0; k < dispLine && k < dispLines.length; k++)
+            off += dispLines[k].length + 1;
+        off += Math.max(0, Math.min(charInLine, (dispLines[dispLine] ?? '').length));
+        for (let i = 0; i < segs.length; i++) {
+            const start = segStart[i];
+            const len = segs[i].frozen ? chipToken(segs[i].text).length : segs[i].text.length;
+            // 可编辑段用闭区间;只读块用半开区间——其结束边界归紧随其后的可编辑段,
+            // 否则光标恰好停在 chip 后的可编辑段开头时,会被误判落在 chip 上(边界争用)。
+            const inside = segs[i].frozen ? off >= start && off < start + len : off >= start && off <= start + len;
+            if (inside) {
+                if (!segs[i].frozen)
+                    return { seg: i, off: off - start };
+                // 落在只读块内:按就近原则吸附——靠近左沿→其前可编辑段末尾,靠近右沿→其后可编辑段开头。
+                const distStart = off - start;
+                const distEnd = start + len - off;
+                return distStart <= distEnd ? editableEndBefore(i) : editableStartAfter(i);
+            }
+        }
+        return lastEditableEnd();
     }
-    /** 在光标处插入文本(含换行则拆行)。供短粘贴 finalize 落为可编辑文本。 */
+    function editableStartAfter(i) {
+        let j = i + 1;
+        while (j < segs.length && segs[j].frozen)
+            j++;
+        if (j < segs.length)
+            return { seg: j, off: 0 };
+        return lastEditableEnd();
+    }
+    function editableEndBefore(i) {
+        let j = i - 1;
+        while (j >= 0 && segs[j].frozen)
+            j--;
+        if (j >= 0)
+            return { seg: j, off: segs[j].text.length };
+        return firstEditableStart();
+    }
+    function firstEditableStart() {
+        for (let j = 0; j < segs.length; j++)
+            if (!segs[j].frozen)
+                return { seg: j, off: 0 };
+        return { seg: 0, off: 0 };
+    }
+    function lastEditableEnd() {
+        for (let j = segs.length - 1; j >= 0; j--)
+            if (!segs[j].frozen)
+                return { seg: j, off: segs[j].text.length };
+        return { seg: 0, off: 0 };
+    }
+    /** 在光标处插入文本(含换行则落进当前可编辑段,原样保留)。供短粘贴与可打印字符共用。 */
     function insertText(text) {
-        const parts = text.split('\n');
-        const before = lines[cl].slice(0, cc);
-        const after = lines[cl].slice(cc);
-        const newLines = [before + parts[0]];
-        for (let i = 1; i < parts.length; i++)
-            newLines.push(parts[i]);
-        newLines[newLines.length - 1] += after;
-        lines.splice(cl, 1, ...newLines);
-        cl = cl + parts.length - 1;
-        // 光标置于插入文本末尾 = 原 before + 末段长度(指向插入文本之后、after 之前)。
-        // 旧值 parts[...].length 漏算 before → 光标落到插入文本内部(行中间)→ 后续打字插到中间(bug)。
-        cc = before.length + parts[parts.length - 1].length;
+        const s = segs[curSeg].text;
+        segs[curSeg].text = s.slice(0, curOff) + text + s.slice(curOff);
+        curOff += text.length;
     }
-    /** 落一段粘贴文本(长/短判定与 chip 逻辑,finalizePaste 与鼠标点击贴入共用)。
-     * 长粘贴落 chip 时不再吞掉用户已打的字:光标前的文本并入 chipPre(原样保留,与 chip 一起原子化),
-     * 光标后的文本留在 suffix(lines)——即"前段文字 [长文本…] 后段文字"而非清空覆盖。 */
+    /** 落一段粘贴文本:长粘贴 → 在此处插入一个只读 chip(把当前可编辑段从光标切开成「前段 + chip + 后段」),
+     *  短粘贴 → 作为可编辑文本插入。连续长粘贴会产生相邻 chip,各自独立;两次粘贴之间敲的字是可编辑段,
+     *  可直接编辑、也可退格删掉任一 chip。光标落在 chip 之后的可编辑段(即使为空也保留,保证光标有落点)。 */
     function applyPastedText(buf) {
         if (!buf)
             return;
         const isLong = buf.split('\n').length > 8 || buf.length > 200;
-        if (isLong) {
-            const before = lines[cl].slice(0, cc);
-            const after = lines[cl].slice(cc);
-            if (chip == null) {
-                // 首次起 chip:光标前的行(含之前的整行)转入 chipPre,光标后的部分留作 suffix 首行。
-                chipPre = [...lines.slice(0, cl), before].join('\n');
-                chip = buf;
-            }
-            else {
-                // 已有 chip:光标前若已打了字(chip 之后、本次粘贴之前),并入 chip 尾部保留(不丢字),
-                // 光标后的部分仍留作 suffix 首行。
-                chip = before ? chip + '\n' + before + '\n' + buf : chip + '\n' + buf;
-            }
-            lines = [after, ...lines.slice(cl + 1)];
-            cl = 0;
-            cc = 0;
-        }
-        else {
+        if (!isLong) {
             insertText(buf);
+            computeFiltered();
+            redraw();
+            return;
         }
+        const s = segs[curSeg].text;
+        const before = s.slice(0, curOff);
+        const after = s.slice(curOff);
+        const newSegs = [];
+        if (before)
+            newSegs.push({ frozen: false, text: before });
+        newSegs.push({ frozen: true, text: buf });
+        newSegs.push({ frozen: false, text: after }); // 始终保留可编辑后缀(可为空),保证光标有落点
+        segs.splice(curSeg, 1, ...newSegs);
+        curSeg = curSeg + (before ? 2 : 1); // 落到 chip 之后的可编辑段
+        curOff = 0;
         computeFiltered();
         redraw();
     }
@@ -297,11 +318,12 @@ export async function promptWithSlashMenu(opts) {
         }
     }
     function computeFiltered() {
-        if (cl === 0 && lines[0].startsWith('/')) {
-            const { nodes, prefix } = menuContext(lines[0]);
+        const firstLine = buildDisplay().lines[0] ?? '';
+        if (firstLine.startsWith('/')) {
+            const { nodes, prefix } = menuContext(firstLine);
             filtered = nodes
                 .map((node) => ({ node, input: `${prefix}${node.name}` }))
-                .filter((item) => item.input.startsWith(lines[0]));
+                .filter((item) => item.input.startsWith(firstLine));
             menuOpen = filtered.length > 0;
             if (selected >= filtered.length) {
                 selected = 0;
@@ -315,37 +337,38 @@ export async function promptWithSlashMenu(opts) {
         }
     }
     function redraw() {
+        const { lines } = buildDisplay();
+        const cur = cursorDisp();
+        // 空输入引导:缓冲为空时输入框内画 dim ghost 占位(含 /help 提示),让用户知道怎么开始;
+        // 一旦有输入(打字/粘贴/补全)isEmpty 变 false,下一帧占位即消失。
+        const isEmpty = segs.length === 1 && !segs[0].frozen && segs[0].text === '';
         layout.paintInput({
             prompt: opts.prompt,
-            lines: dispLines(),
-            cursorLine: dispCursorLine(),
-            cursorCol: dispCursorCol(),
+            lines,
+            cursorLine: cur.line,
+            cursorCol: cur.col,
             menu: menuLines().length ? { lines: menuLines() } : null,
+            placeholder: isEmpty ? t('prompt.emptyPlaceholder') : undefined,
         });
     }
     /** 鼠标点击输入框:layout 已把"屏 tap 位置"以 (flatIdx, inSegVis) 形式传进来
-     *  (flatIdx = flat 中的绝对段号;inSegVis = 段内显示列)。
-     *  本函数在 prompt 自己的 (lines + chip) 上复刻 wrap/flat 还原 (cl, cc)→ redraw。
-     *  chip 模式自动扣 chip prefix:
-     *  - dispLines() 把 chipPre 末行 + chipPrefix + suffix[0] 拼成一行 "mergedRow"
-     *  - flat 中对应的"合并行段"是 mergedRow 的折行段,段内 inChar 累加从 mergedRow 起
-     *  - 要得到 lines[cl=0] 内的字符索引,扣掉 mergedRow 起始到 lines[0] 起始的字符数
-     *    = chipPre 末行字符数 + chipPrefix 字符数。 */
+     *  (flatIdx = flat 中的绝对段号;inSegVis = 段内显示列)。本函数把点击位还原成 (段, 偏移) → redraw。
+     *  点中只读粘贴块时吸附到最近的可编辑边界(见 mapDispToCursor)。 */
     function applyExternalCursor(flatIdx, inSegVis) {
         const g = layout.getGeo();
         const promptW = displayWidth(opts.prompt);
         const W = Math.max(1, g.cols - promptW);
-        const dispLs = dispLines();
+        const { lines: dispLs } = buildDisplay();
         const lineVis = dispLs.map((l) => wrapByDisplayWidth(l, W));
         const flat = [];
         for (const lv of lineVis)
             for (const r of lv)
                 flat.push(r);
-        let newCl;
-        let newCc;
+        let dispLine;
+        let charInLine;
         if (flat.length === 0) {
-            newCl = 0;
-            newCc = 0;
+            dispLine = 0;
+            charInLine = 0;
         }
         else {
             const safeIdx = Math.max(0, Math.min(flatIdx, flat.length - 1));
@@ -354,60 +377,26 @@ export async function promptWithSlashMenu(opts) {
             const safeInSeg = Math.max(0, Math.min(inSegVis, segW));
             const inChar = visColToCharCol(seg, safeInSeg);
             // safeIdx → (dispLine, segInLine)
-            let dispLine = 0;
+            let dl = 0;
             let segInLine = safeIdx;
-            while (dispLine < lineVis.length && segInLine >= lineVis[dispLine].length) {
-                segInLine -= lineVis[dispLine].length;
-                dispLine++;
-            }
-            if (dispLine >= lineVis.length) {
-                dispLine = lineVis.length - 1;
-                segInLine = lineVis[dispLine].length - 1;
-            }
-            // dispLine → cl(chip-aware)
-            if (chip) {
-                const preLen = chipPreLines().length;
-                if (dispLine < preLen - 1) {
-                    // 落在 chipPre 内(非末行)→ 走出 chip 到 suffix 起点
-                    newCl = 0;
-                }
-                else if (dispLine === preLen - 1) {
-                    // 合并行 = suffix 第 0 行(cl=0)
-                    newCl = 0;
-                }
-                else {
-                    newCl = dispLine - (preLen - 1);
-                }
+            while (dl < lineVis.length && segInLine >= lineVis[dl].length) {
+                segInLine -= lineVis[dl].length;
+                dl++;
             }
-            else {
-                newCl = dispLine;
+            if (dl >= lineVis.length) {
+                dl = lineVis.length - 1;
+                segInLine = lineVis[dl].length - 1;
             }
-            newCl = Math.max(0, Math.min(newCl, lines.length - 1));
-            const lineText = lines[newCl] ?? '';
-            // cc 必须在 lines[newCl] 内。flat 中 seg 是 dispLs[dispLine] 的某折行段,
-            // seg 内 inChar 是段内字符偏移,但 lines[newCl] 的字符是按 (dispLs 前段累加) + (本段 inChar) 算的。
-            // ——非 chip 模式下:dispLine = newCl, segStartChars = sum(lineVis[dispLine][0..segInLine-1].length)
-            //   ccInLine = segStartChars + inChar
-            // ——chip 模式下 newCl=0(合并行):dispLine 是合并行 dispLine,segStartChars 同上,
-            //   但 lines[0] 在合并行中"起始处"在 (mergedRow.length - lines[0].length) 字符处,
-            //   故 ccInLine = segStartChars + inChar - chipOverheadChars。
             let segStartChars = 0;
-            const segs = lineVis[dispLine];
+            const segsVis = lineVis[dl];
             for (let s = 0; s < segInLine; s++)
-                segStartChars += segs[s]?.length ?? 0;
-            let ccInLine = segStartChars + inChar;
-            if (chip && newCl === 0) {
-                const pre = chipPreLines();
-                const mergedRow = pre[pre.length - 1] ?? '';
-                const prefix = chipPrefix();
-                // mergedRow 起始到 lines[0] 起始的字符数 = (chipPreLast + chipPrefix) 字符数
-                const chipOverheadChars = mergedRow.length + prefix.length - lineText.length;
-                ccInLine = ccInLine - chipOverheadChars;
-            }
-            newCc = Math.max(0, Math.min(ccInLine, lineText.length));
+                segStartChars += segsVis[s]?.length ?? 0;
+            charInLine = Math.max(0, Math.min(segStartChars + inChar, dispLs[dl]?.length ?? 0));
+            dispLine = dl;
         }
-        cl = newCl;
-        cc = newCc;
+        const { seg, off } = mapDispToCursor(dispLine, charInLine);
+        curSeg = seg;
+        curOff = off;
         // 收起菜单/过滤态:点击输入框关闭菜单,回到纯文本编辑。
         if (menuOpen) {
             menuOpen = false;
@@ -454,18 +443,18 @@ export async function promptWithSlashMenu(opts) {
         if (!menuOpen || !item)
             return submitLeaf;
         if (item.node.children?.length) {
-            lines = [`${item.input} `];
-            cl = 0;
-            cc = lines[0].length;
+            segs = [{ frozen: false, text: `${item.input} ` }];
+            curSeg = 0;
+            curOff = segs[0].text.length;
             selected = 0;
             menuTop = 0;
             computeFiltered();
             redraw();
             return false;
         }
-        lines = [item.node.value ?? item.input];
-        cl = 0;
-        cc = lines[0].length;
+        segs = [{ frozen: false, text: item.node.value ?? item.input }];
+        curSeg = 0;
+        curOff = segs[0].text.length;
         computeFiltered();
         if (!submitLeaf || item.node.submit === false) {
             redraw();
@@ -473,44 +462,85 @@ export async function promptWithSlashMenu(opts) {
         }
         return true;
     }
-    /** 提交:菜单打开时先应用选中项；分支进入子菜单，需要参数的叶子只补全。 */
+    /** 提交:菜单打开时先应用选中项;分支进入子菜单,需要参数的叶子只补全。
+     *  段序列直接按原文(可编辑段原文 + 粘贴块原文)拼接——所见即所得,不再额外插换行。 */
     function submit() {
         if (menuOpen && !applySelected(true))
             return;
-        const suffix = lines.join('\n');
-        let content = suffix;
-        if (chip) {
-            content = suffix.length > 0 ? chip + '\n' + suffix : chip;
-            if (chipPre)
-                content = chipPre + '\n' + content;
-        }
+        const content = segs.map((s) => s.text).join('');
         finish(content === '' ? [''] : content.split('\n'));
     }
-    /** 插换行:在光标处断行。 */
+    /** 插换行:在光标处断行(落进当前可编辑段)。 */
     function insertNewline() {
-        const after = lines[cl].slice(cc);
-        lines[cl] = lines[cl].slice(0, cc);
-        lines.splice(cl + 1, 0, after);
-        cl++;
-        cc = 0;
+        insertText('\n');
         computeFiltered();
         redraw();
     }
-    /** 清空输入(含 chip / 斜杠菜单 / 粘贴缓冲):Ctrl+C 在有内容时调用——清空而非退出。 */
+    /** 光标移到当前可编辑段内的行首/行尾(不含段内 \n)。 */
+    function moveToLineStart() {
+        const s = segs[curSeg].text;
+        curOff = s.lastIndexOf('\n', curOff - 1) + 1;
+        redraw();
+    }
+    function moveToLineEnd() {
+        const s = segs[curSeg].text;
+        const ne = s.indexOf('\n', curOff);
+        curOff = ne < 0 ? s.length : ne;
+        redraw();
+    }
+    /** Ctrl+U:删到行首(当前可编辑段内的当前行;已在行首则 no-op,不跨入相邻粘贴块)。 */
+    function deleteToLineStart() {
+        const s = segs[curSeg].text;
+        const ls = s.lastIndexOf('\n', curOff - 1) + 1;
+        if (ls === curOff)
+            return;
+        segs[curSeg].text = s.slice(0, ls) + s.slice(curOff);
+        curOff = ls;
+        computeFiltered();
+        redraw();
+    }
+    /** Ctrl+K:删到行尾(当前可编辑段内的当前行;已在行尾则 no-op,不跨入相邻粘贴块)。 */
+    function deleteToLineEnd() {
+        const s = segs[curSeg].text;
+        const ne = s.indexOf('\n', curOff);
+        if (ne < 0) {
+            if (curOff === s.length)
+                return;
+            segs[curSeg].text = s.slice(0, curOff);
+        }
+        else {
+            segs[curSeg].text = s.slice(0, curOff) + s.slice(ne + 1);
+        }
+        computeFiltered();
+        redraw();
+    }
+    /** Ctrl+Z:还原被 Ctrl+C 清掉的输入(单次)。 */
+    function restoreUndo() {
+        const snap = undoSnapshot;
+        if (!snap)
+            return;
+        segs = snap.segs.map((s) => ({ ...s }));
+        curSeg = Math.min(snap.curSeg, segs.length - 1);
+        curOff = Math.min(snap.curOff, segs[curSeg].text.length);
+        undoSnapshot = null;
+        computeFiltered();
+        redraw();
+    }
+    /**
+     * 清空输入(含粘贴块 / 斜杠菜单 / 粘贴缓冲):Ctrl+C 在有内容时调用——清空而非退出。
+     * 清空前留一份快照供 Ctrl+Z 还原——手滑按在输入框上时,正在写的长 prompt 不至于白打。
+     */
     function clearInput() {
         if (layout.isScrolled())
             layout.resetScroll(); // 回尾(若滚动回看),再清空
-        lines = [''];
-        cl = 0;
-        cc = 0;
-        chip = null;
-        chipPre = '';
+        undoSnapshot = { segs: segs.map((s) => ({ ...s })), curSeg, curOff };
+        segs = [{ frozen: false, text: '' }];
+        curSeg = 0;
+        curOff = 0;
         menuOpen = false;
         filtered = [];
         selected = 0;
         menuTop = 0;
-        historyIndex = queryHistory.length;
-        historyDraft = null;
         if (pasteTimer) {
             clearTimeout(pasteTimer);
             pasteTimer = null;
@@ -521,13 +551,10 @@ export async function promptWithSlashMenu(opts) {
         computeFiltered();
         redraw();
     }
-    /** Ctrl+C:有内容(已打字 / 多行 / chip / 菜单草稿 / 粘贴缓冲 / 粘贴中)则清空,再按一次(空)才退出(仿 fish)。 */
+    /** Ctrl+C:有内容(已打字 / 多行 / 粘贴块 / 菜单草稿 / 粘贴缓冲 / 粘贴中)则清空,再按一次(空)才退出(仿 fish)。 */
     function onCtrlC() {
-        const hasContent = chip != null ||
-            lines.length > 1 ||
-            lines.some((l) => l !== '') ||
-            pasteParts.length > 0 ||
-            pasting;
+        const flat = segs.map((s) => s.text).join('');
+        const hasContent = flat.length > 0 || menuOpen || pasteParts.length > 0 || pasting;
         if (hasContent) {
             clearInput();
             return;
@@ -574,7 +601,7 @@ export async function promptWithSlashMenu(opts) {
             return;
         }
         // 滚动回看键(优先;不触发回尾):PgUp/PgDn 翻页，Ctrl+↑/↓ 每次 5 行。
-        // 裸 ↑/↓ 留给斜杠菜单、多行光标和 query 历史导航；鼠标滚轮由 SGR mouse 事件处理。
+        // 裸 ↑/↓ 优先给斜杠菜单与多行光标，二者都不适用时按滚轮量滚动回看(与鼠标滚轮同一入口)。
         if (key.name === 'pageup' ||
             key.name === 'pagedown' ||
             (key.ctrl && (key.name === 'up' || key.name === 'down'))) {
@@ -592,18 +619,38 @@ export async function promptWithSlashMenu(opts) {
         // 滚动回看时打字 / 编辑不回尾(保持历史视图,便于边看历史边编辑);仅 Enter 提交时回尾(见下方 submit 前)。
         // Ctrl+C 已在 onKey 顶部统一处理(清空或退出);Ctrl+D:空缓冲退出,否则忽略
         if (key.ctrl && key.name === 'd') {
-            if (lines.every((l) => l === '') && cl === 0 && cc === 0)
+            if (segs.map((s) => s.text).join('') === '')
                 finish(null);
             return;
         }
         if (key.ctrl && key.name === 'a') {
-            cc = 0;
-            redraw();
+            moveToLineStart();
+            return;
+        }
+        if (key.ctrl && key.name === 'q') {
+            // 行首的对称搭档:与 Ctrl+E(行尾)同处顶行相邻(Q/E),左=起始右=结束。
+            // Ctrl+A 仍作别名保留(全 app 一致:运行中预填、权限面板都用 Ctrl+A 跳开头)。
+            moveToLineStart();
             return;
         }
         if (key.ctrl && key.name === 'e') {
-            cc = lines[cl].length;
-            redraw();
+            moveToLineEnd();
+            return;
+        }
+        // Ctrl+Z:还原被 Ctrl+C 清掉的输入。无快照时 no-op。
+        if (key.ctrl && key.name === 'z') {
+            restoreUndo();
+            return;
+        }
+        // 行级删除:Ctrl+U 删到行首,Ctrl+K 删到行尾(均在当前可编辑段内,不跨入相邻粘贴块)。
+        // 词级删除/跳转(Ctrl+W / Ctrl+← 等)刻意不做:终端序列各终端发得不一样
+        // (Ctrl+Backspace 在多数终端发 \x08,与裸退格无从区分),做一半会变成按了没反应的哑键。
+        if (key.ctrl && key.name === 'u') {
+            deleteToLineStart();
+            return;
+        }
+        if (key.ctrl && key.name === 'k') {
+            deleteToLineEnd();
             return;
         }
         const isReturn = key.name === 'return' || key.name === 'enter';
@@ -629,48 +676,71 @@ export async function promptWithSlashMenu(opts) {
             return;
         }
         switch (key.name) {
-            case 'backspace':
-                if (cc > 0) {
-                    lines[cl] = lines[cl].slice(0, cc - 1) + lines[cl].slice(cc);
-                    cc--;
+            case 'backspace': {
+                const s = segs[curSeg].text;
+                if (curOff > 0) {
+                    segs[curSeg].text = s.slice(0, curOff - 1) + s.slice(curOff);
+                    curOff--;
                     computeFiltered();
                     redraw();
                 }
-                else if (cl > 0) {
-                    // 行首退格:并入上一行
-                    const cur = lines[cl];
-                    cc = lines[cl - 1].length;
-                    lines[cl - 1] = lines[cl - 1] + cur;
-                    lines.splice(cl, 1);
-                    cl--;
+                else if (curSeg > 0) {
+                    const prev = segs[curSeg - 1];
+                    if (prev.frozen) {
+                        // 紧贴粘贴块后沿退格:删整块(原子)
+                        segs.splice(curSeg - 1, 1);
+                        curSeg--;
+                        curOff = 0;
+                    }
+                    else {
+                        // 并回上一个可编辑段
+                        prev.text += segs[curSeg].text;
+                        const joinOff = prev.text.length - segs[curSeg].text.length;
+                        segs.splice(curSeg, 1);
+                        curSeg--;
+                        curOff = joinOff;
+                    }
                     computeFiltered();
                     redraw();
                 }
-                else if (chip) {
-                    // 光标在 suffix 开头(紧贴 ] 后):退格删整个 chip(原子),chipPre 还原为可编辑行,
-                    // 光标落在 chipPre 末尾(紧接原来打的字继续编辑)。
-                    const preLines = chipPre ? chipPre.split('\n') : [''];
-                    lines = [...preLines.slice(0, -1), preLines[preLines.length - 1] + lines[0], ...lines.slice(1)];
-                    cl = preLines.length - 1;
-                    cc = preLines[preLines.length - 1].length;
-                    chip = null;
-                    chipPre = '';
+                return;
+            }
+            case 'delete': {
+                const s = segs[curSeg].text;
+                if (curOff < s.length) {
+                    segs[curSeg].text = s.slice(0, curOff) + s.slice(curOff + 1);
+                    computeFiltered();
+                    redraw();
+                }
+                else if (curSeg < segs.length - 1) {
+                    const next = segs[curSeg + 1];
+                    if (next.frozen)
+                        segs.splice(curSeg + 1, 1); // 并掉下一个粘贴块
+                    else {
+                        segs[curSeg].text += next.text;
+                        segs.splice(curSeg + 1, 1);
+                    }
                     computeFiltered();
                     redraw();
                 }
                 return;
+            }
             case 'up':
                 if (menuOpen && filtered.length) {
                     selected = (selected - 1 + filtered.length) % filtered.length;
                     redraw();
                 }
-                else if (cl > 0) {
-                    cl--;
-                    cc = Math.min(cc, lines[cl].length);
-                    redraw();
-                }
                 else {
-                    recallPrevious();
+                    const { line, col } = cursorDisp();
+                    if (line > 0) {
+                        const m = mapDispToCursor(line - 1, dispColToCharInLine(line - 1, col));
+                        curSeg = m.seg;
+                        curOff = m.off;
+                        redraw();
+                    }
+                    else {
+                        layout.scrollWheel(1); // 等同鼠标滚轮上滚一格
+                    }
                 }
                 return;
             case 'down':
@@ -678,13 +748,18 @@ export async function promptWithSlashMenu(opts) {
                     selected = (selected + 1) % filtered.length;
                     redraw();
                 }
-                else if (cl < lines.length - 1) {
-                    cl++;
-                    cc = Math.min(cc, lines[cl].length);
-                    redraw();
-                }
                 else {
-                    recallNext();
+                    const { lines: dispLines } = buildDisplay();
+                    const { line, col } = cursorDisp();
+                    if (line < dispLines.length - 1) {
+                        const m = mapDispToCursor(line + 1, dispColToCharInLine(line + 1, col));
+                        curSeg = m.seg;
+                        curOff = m.off;
+                        redraw();
+                    }
+                    else {
+                        layout.scrollWheel(-1); // 等同鼠标滚轮下滚一格
+                    }
                 }
                 return;
             case 'tab':
@@ -692,12 +767,12 @@ export async function promptWithSlashMenu(opts) {
                     applySelected(false);
                 return;
             case 'escape': {
-                const { prefix } = menuContext(lines[0]);
+                const { prefix } = menuContext(buildDisplay().lines[0] ?? '');
                 if (prefix) {
                     // 子层 Esc 回到父节点；例如 /model sw → /model。
-                    lines = [prefix.trimEnd()];
-                    cl = 0;
-                    cc = lines[0].length;
+                    segs = [{ frozen: false, text: prefix.trimEnd() }];
+                    curSeg = 0;
+                    curOff = segs[0].text.length;
                     selected = 0;
                     menuTop = 0;
                     computeFiltered();
@@ -711,42 +786,52 @@ export async function promptWithSlashMenu(opts) {
                 redraw();
                 return;
             }
-            case 'left':
-                if (cc > 0) {
-                    cc--;
+            case 'left': {
+                if (curOff > 0) {
+                    curOff--;
                     redraw();
                 }
-                else if (cl > 0) {
-                    cl--;
-                    cc = lines[cl].length;
-                    redraw();
+                else if (curSeg > 0) {
+                    let p = curSeg - 1;
+                    while (p >= 0 && segs[p].frozen)
+                        p--;
+                    if (p >= 0) {
+                        curSeg = p;
+                        curOff = segs[p].text.length;
+                        redraw();
+                    }
                 }
                 return;
-            case 'right':
-                if (cc < lines[cl].length) {
-                    cc++;
+            }
+            case 'right': {
+                const s = segs[curSeg].text;
+                if (curOff < s.length) {
+                    curOff++;
                     redraw();
                 }
-                else if (cl < lines.length - 1) {
-                    cl++;
-                    cc = 0;
-                    redraw();
+                else if (curSeg < segs.length - 1) {
+                    let nx = curSeg + 1;
+                    while (nx < segs.length && segs[nx].frozen)
+                        nx++;
+                    if (nx < segs.length) {
+                        curSeg = nx;
+                        curOff = 0;
+                        redraw();
+                    }
                 }
                 return;
+            }
             case 'home':
-                cc = 0;
-                redraw();
+                moveToLineStart();
                 return;
             case 'end':
-                cc = lines[cl].length;
-                redraw();
+                moveToLineEnd();
                 return;
         }
         // 可打印字符(>= 空格,非 ctrl/meta)
         const s = key.sequence ?? '';
         if (s && s >= ' ' && !key.ctrl && !key.meta) {
-            lines[cl] = lines[cl].slice(0, cc) + s + lines[cl].slice(cc);
-            cc += s.length;
+            insertText(s);
             computeFiltered();
             redraw();
         }