mocode-ai 1.2.9 → 1.3.0

package/dist/agent/index.js

@@ -255,7 +255,11 @@ onContextUpdate) {
     // 经 setStatus 注入状态行(spinnerFrame + statusText),composeStatus 把帧 + 文字放 lead 位;
     // 不画内容区续写位——内容区在等待期间保持干净,首 token 到达即从续写位开始写正文。
     const spinner = new Spinner((msg, frame) => {
-        layout.setStatus(frame ? `${msg}…` : '', frame ?? undefined);
+        // frame 在转:msg + … + 帧字符;stop() 时 frame=null,去帧,保留 msg 作为状态文字
+        // (spinner.ts line 71 注释:"状态行去帧,保留状态文字")。旧版用 '' 会把 statusText 清空,
+        // 导致流式期间(spinner 已停、走时由 turnTimer 兜底)状态行只剩心跳帧字符,
+        // 再叠加 composeSpinnerLine scrolled 分支无 fallback,滚动态左侧像"蒸发"了。
+        layout.setStatus(frame ? `${msg}…` : msg, frame ?? undefined);
     });
     // lastChar 镜像:core 跟踪流式末字符决定补换行,但 TUI hooks 需读它决定 layout.contentWrite('\n')。
     // core 的 onTextEnd hook 只在 lastChar !== '\n' 时才调,调后置 '\n';镜像与此同步。

package/dist/i18n/index.js

@@ -122,6 +122,10 @@ const zhCN = {
     'repl.themeList': '可用主题：',
     'repl.themeCurrent': '（当前：{theme}；用 /theme <名称> 切换）',
     'repl.themeChanged': '（已切换主题 {theme}）',
+    'repl.modeCurrent': '当前模式：{mode}；/plan 切到只读探查并产出计划，/auto 切回全工具执行',
+    'repl.unknownCommand': '未知命令：{value}',
+    'repl.didYouMean': '你是不是想输入 {value}？',
+    'repl.unknownCommandHint': '输入 /help 查看全部命令（普通文本直接打字发送，不必加 /）',
     'theme.default': '16 色原版（深底）',
     'theme.light': '浅底终端',
     'theme.solarized': 'Solarized 强调色',
@@ -381,6 +385,10 @@ const en = {
     'repl.themeList': 'Available themes:',
     'repl.themeCurrent': '(current: {theme}; use /theme <name> to switch)',
     'repl.themeChanged': '(switched theme to {theme})',
+    'repl.modeCurrent': 'Current mode: {mode}; /plan for read-only planning, /auto for full tool access',
+    'repl.unknownCommand': 'Unknown command: {value}',
+    'repl.didYouMean': 'Did you mean {value}?',
+    'repl.unknownCommandHint': 'Run /help for all commands (plain text is sent as-is, no slash needed)',
     'theme.default': 'Original 16-color theme (dark)',
     'theme.light': 'Light terminal',
     'theme.solarized': 'Solarized accents',

package/dist/permissions/index.js

@@ -146,6 +146,9 @@ export async function checkPermission(tool, args, signal, options = {}) {
         detail: summarizeArgs(args) + (dangerous ? `\n\n${t('permission.dangerWarning')}` : ''),
         options: choices,
         allowCustom: false,
+        // dangerous 默认落在「拒绝」:面板一弹出就高亮"允许一次"时,用户顺手回车就把命令放出去了。
+        // 放行必须是一次明确的选择(↑↓ 移到某一项,或按数字键),而不是默认项的惯性。
+        defaultIndex: dangerous ? choices.indexOf(denyOption) : 0,
     });
     if (signal?.aborted || result.action === 'cancelled' || result.value === denyOption)
         return 'deny';

package/dist/repl/index.js

@@ -144,6 +144,73 @@ function slashHelpLines(nodes = buildSlashCommands(), parentPath = '', depth = 0
     }
     return lines;
 }
+/**
+ * 菜单树里全部可用命令名(含分支路径与叶子的真实命令),供未知命令纠错建议用。
+ * /quit、/frontend 确实可用但没登记进菜单树,单独补上——否则用户照提示打了却仍被判未知。
+ */
+function knownCommandNames() {
+    const out = [];
+    const walk = (nodes, parent) => {
+        for (const node of nodes) {
+            const path = parent ? `${parent} ${node.name}` : node.name;
+            out.push(path);
+            const actual = node.value?.trim();
+            if (actual)
+                out.push(actual.split(/\s+/)[0]);
+            if (node.children?.length)
+                walk(node.children, path);
+        }
+    };
+    walk(buildSlashCommands(), '');
+    out.push('/quit', '/frontend');
+    return [...new Set(out)];
+}
+/**
+ * 是否"长得像一条斜杠命令":单个前导 / + 词字符(字母开头,可含数字/下划线/连字符)。
+ * 用来把 /hepl 这类拼写错误与 /tmp/foo、/src/index.ts:12:5 这类路径区分开——
+ * 后者在编码 agent 里很常见,同样以 / 开头,绝不能被当成命令拦下。
+ */
+function isCommandShape(cmd) {
+    return /^\/[A-Za-z][\w-]*$/.test(cmd);
+}
+/** Levenshtein 距离(标准 DP)。短命令字符串,直接两行数组滚动即可。 */
+function editDistance(a, b) {
+    if (a === b)
+        return 0;
+    if (!a.length)
+        return b.length;
+    if (!b.length)
+        return a.length;
+    let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        const cur = [i];
+        for (let j = 1; j <= b.length; j++) {
+            cur[j] = Math.min(prev[j] + 1, // 删
+            cur[j - 1] + 1, // 插
+            prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+        }
+        prev = cur;
+    }
+    return prev[b.length];
+}
+/** 未知命令的纠错建议:返回编辑距离最近且在阈值内的命令名,没有则 null(不要瞎猜)。 */
+export function suggestCommand(input) {
+    // 阈值随长度放宽,但对短命令保持严格:/hepl(5) vs /help 距离 2 → 命中;
+    // /x(2) 不该被建议成任何东西。
+    const threshold = Math.max(1, Math.ceil(input.length / 3));
+    let best = null;
+    let bestDist = Infinity;
+    for (const name of knownCommandNames()) {
+        if (name === input)
+            continue; // 别建议"你自己"(分支节点如 /mode 也在候选里)
+        const d = editDistance(input, name);
+        if (d < bestDist) {
+            bestDist = d;
+            best = name;
+        }
+    }
+    return bestDist <= threshold ? best : null;
+}
 /** 主题名 → 本地化描述。 */
 function themeDescription(name) {
     const key = `theme.${name}`;
@@ -1150,7 +1217,6 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
             input = await promptWithSlashMenu({
                 prompt: PROMPT,
                 commands: buildSlashCommands(),
-                queryHistory,
                 onCycleMode: cycleMode,
                 // /rollback 预填优先;否则上一轮运行中 typeahead 打的字 → 预填进输入框,用户可改可发
                 ...(pendingPrefill
@@ -1176,6 +1242,8 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
             break;
         // RUNNING 态:回显输入 → 底栏改 dim 占位、光标回内容续写位
         const cmd = line.split(/\s+/)[0];
+        // 命令被刻意改写成别的内容后转发给 agent(如 /init)。这类不算"未知命令"。
+        let forwardToAgent = false;
         // 语言命令把视觉分隔放在确认文案之后；避免回显后先空一行、下一条命令却紧贴确认。
         echoInput(input, cmd !== '/language');
         const state = runningStateFor(cmd);
@@ -1217,6 +1285,7 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
         if (line === '/init') {
             // /init:把 init 指令当 user 输入发给 agent(扫描项目 + 生成 AGENTS.md),fall through 走 runAgent
             joined = buildInitPrompt();
+            forwardToAgent = true; // 不是"没匹配上",别被下方未知命令兜底拦掉
         }
         if (line === '/upgrade' || line.startsWith('/upgrade ')) {
             const arg = line === '/upgrade' ? '' : line.slice('/upgrade '.length).trim().toLowerCase();
@@ -1317,6 +1386,12 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
             }
             continue;
         }
+        if (line === '/mode') {
+            // /mode:菜单里的分支节点(本身不切换,只挂 /plan 与 /auto)。/help 会把它列出来,
+            // 所以直接敲它必须给点有用的东西——打印当前模式与两个子命令,而不是报未知命令。
+            layout.contentWrite(`${ui.dim}${t('repl.modeCurrent', { mode: getAgentMode() })}${ui.reset}\n`);
+            continue;
+        }
         if (line === '/pet quit') {
             // /pet quit:完全关闭桌宠进程(区别于 /pet 的仅断开本连接)。方案C的 CLI 侧退出入口,
             // 另一入口是桌宠托盘菜单"退出桌宠"(见 packages/pet-app/src/main.ts)。
@@ -2293,6 +2368,19 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
             }
             continue;
         }
+        // 未知斜杠命令兜底:命令分派是一串独立的 if(…){ …continue },没有 else,
+        // 拼错的 /hepl 会一路走到这里被当成普通 prompt 送给模型——白烧一轮还拿不到任何提示。
+        // 只拦「长得像命令」的输入:单个前导 / + 词字符。像 /tmp/foo/bar、/src/index.ts:12:5 这类
+        // 路径(在编码 agent 里很常见,且同样以 / 开头)必须放行,不能当成拼错的命令。
+        if (isCommandShape(cmd) && !forwardToAgent) {
+            const suggestion = suggestCommand(cmd);
+            layout.contentWrite(`${ui.yellow}${t('repl.unknownCommand', { value: cmd })}${ui.reset}\n`);
+            if (suggestion) {
+                layout.contentWrite(`${ui.dim}${t('repl.didYouMean', { value: suggestion })}${ui.reset}\n`);
+            }
+            layout.contentWrite(`${ui.dim}${t('repl.unknownCommandHint')}${ui.reset}\n`);
+            continue; // 与其他命令一致:回 INPUT 态由循环顶部的 normalizeInputBoundary + enterInputMode 负责
+        }
         const bubbleRows = input.length + 2 + pendingAttachments.length; // N 行 message + 2 行尾随空(含 \n\n 留下的 open current 行) + 每附件 1 行
         const shouldCommit = await awaitPendingRecall(input, pendingAttachments.length, placeholder);
         if (!shouldCommit) {

package/dist/ui/intervention.js

@@ -33,7 +33,10 @@ export async function promptIntervention(req) {
     const startMode = req.type === 'choice' && options.length > 0 ? 'choice' : 'input';
     let mode = startMode;
     // choice:选中下标(0..options.length-1 为各选项,options.length 为"自定义"项)。
-    let selected = 0;
+    // 初始选中项:默认 0(首项);调用方可传 defaultIndex 改。危险操作用它把默认落在「拒绝」上,
+    // 否则面板一弹出就高亮「允许一次」,用户顺手回车就把 rm -rf 放出去了。只认真实选项,不含"自定义"项。
+    const defaultIndex = Math.max(0, Math.min(req.defaultIndex ?? 0, Math.max(0, options.length - 1)));
+    let selected = defaultIndex;
     // input:可编辑文本 + 光标(UTF-16 码元索引;显示位置由 displayWidth 算,见 paintInput)。
     let text = req.seed ?? '';
     let cursor = text.length;

package/dist/ui/layout.js

@@ -873,6 +873,13 @@ export function scrollBy(delta) {
     repaintViewport();
     repaint();
 }
+/**
+ * 滚动一格「滚轮量」(WHEEL_LINES 行):dir=+1 看更旧(等同 ↑ / PgUp),dir=-1 看更新(等同 ↓ / PgDn)。
+ * 鼠标滚轮与键盘裸 ↑/↓ 共用同一入口,保证两者行为与步长恒一致。
+ */
+export function scrollWheel(dir) {
+    scrollBy(dir > 0 ? WHEEL_LINES : -WHEEL_LINES);
+}
 /** 清活跃选区(不复制),若原有选区则重画去掉反白。供 ESC / 点击别处 / 退出滚动态等场景调。 */
 export function clearSelection() {
     if (!selection && !inputSelection)
@@ -1153,7 +1160,7 @@ function handleMouseEvent(e) {
     if (e.type === 'wheel') {
         // 滚轮始终可用:面板/picker 期间也允许上下查看 agent 输出,
         // 与 onRunningKey 的 PgUp/PgDn 行为一致;mouseEnabled 仅管选区/拖拽。
-        scrollBy(e.dir * WHEEL_LINES);
+        scrollWheel(e.dir);
         return;
     }
     // 输入行左键点击:即使 mouseEnabled=false(如 intervention 面板期间)也允许定位光标,
@@ -1357,13 +1364,18 @@ function composeSpinnerLine(status, cols) {
     let lead;
     let leadW;
     if (scrolled) {
-        // 滚动回看:左段 = 符号(● 或 心跳帧) + 状态名(灰,无走时);右段 = 历史指示。
-        // 跟非回看的 INPUT/RUNNING 态保持一致——避免「● 留下、状态字蒸发」的视觉错觉。
+        // 滚动回看:左段 = 符号(● 或 心跳帧) + 状态名 + (运行态)走时;右段 = 历史指示。
+        // 跟非回看态严格对齐——RUNNING 态显示走时,INPUT 态不显示,避免滚动时信息降级。
         const symbol = spinning
             ? `${ui.bold}${ui.accent}${RUNNING_FRAMES[runningFrame]}${ui.reset}`
             : `${ui.accent}●${ui.reset}`;
-        lead = `${symbol} ${ui.dim}${status.status}${ui.reset}`;
-        leadW = 1 + 1 + displayWidth(status.status);
+        // spinning(运行态流式中 spinner 已停,靠 turnTimer 心跳):同非滚动 spinning 分支加
+        // || '生成中' fallback——流式首 token 到即 spinner.stop(),若 stop() 回调未留状态字,
+        // 此处兜底不再让 lead 只剩心跳帧字符(用户误读为"左侧蒸发了")。
+        const label = spinning ? (status.status || '生成中') : status.status;
+        const ePart = elapsed ? ` ${ui.dim}${elapsed}${ui.reset}` : '';
+        lead = `${symbol} ${ui.dim}${label}${ui.reset}${ePart}`;
+        leadW = 1 + 1 + displayWidth(label) + (elapsed ? 1 + displayWidth(elapsed) : 0);
     }
     else if (hasSpinner) {
         // spinner 激活(思考中/执行工具…):帧 + 状态 + 走时

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,34 @@ export async function promptWithSlashMenu(opts) {
         }
     }
     function redraw() {
+        const { lines } = buildDisplay();
+        const cur = cursorDisp();
         layout.paintInput({
             prompt: opts.prompt,
-            lines: dispLines(),
-            cursorLine: dispCursorLine(),
-            cursorCol: dispCursorCol(),
+            lines,
+            cursorLine: cur.line,
+            cursorCol: cur.col,
             menu: menuLines().length ? { lines: menuLines() } : null,
         });
     }
     /** 鼠标点击输入框: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 +373,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 +439,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 +458,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 +547,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 +597,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 +615,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 +672,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 +744,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 +763,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 +782,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();
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mocode-ai",
-  "version": "1.2.9",
+  "version": "1.3.0",
   "description": "终端编码 agent:LLM + tool-call 循环 + 流式输出(含思考)+ 16 个工具,接任意 OpenAI 兼容后端。",
   "type": "module",
   "bin": {