mocode-ai 1.7.6 → 1.7.8

package/dist/context/vision-window.js

@@ -22,6 +22,13 @@ const ATTACHMENT_TAIL = '. Analyze the attached image content directly.';
 const UNKNOWN_FRAME_NAME = 'frame';
 /** 恢复提示只写进**第一条**被剪占位,避免 N 条占位重复同一句话侵蚀 token。 */
 const RECOVERY_HINT = ' Call computer{screenshot} if you need the current screen.';
+/**
+ * 帧被剪枝后占位行的固定前缀(见 pruneFrameMessage,完整行为 `[screenshot omitted: <帧名> · step N]`)。
+ * 剪枝会把合成附件消息整个 content 换成占位(前言 ATTACHMENT_PREAMBLE 随之消失),
+ * rollback 对齐真实用户轮时必须认出这个占位、不把它算成一轮——那里因循环依赖无法
+ * import 本模块,故在 rollback/store.ts 内联了同一行格式(按整行正则判定),修改此串时两处必须同步。
+ */
+const PRUNED_FRAME_PREFIX = '[screenshot omitted: ';
 /**
  * 白名单:参与滑动窗口的屏幕帧名前缀。
  *
@@ -139,11 +146,11 @@ function pruneFrameMessage(message, names, step, withHint) {
     for (const part of parts) {
         if (part.type !== 'image_url')
             continue;
-        lines.push(`[screenshot omitted: ${names[index] ?? UNKNOWN_FRAME_NAME} · step ${step}]`);
+        lines.push(`${PRUNED_FRAME_PREFIX}${names[index] ?? UNKNOWN_FRAME_NAME} · step ${step}]`);
         index++;
     }
     if (lines.length === 0)
-        lines.push(`[screenshot omitted: ${names[0] ?? UNKNOWN_FRAME_NAME} · step ${step}]`);
+        lines.push(`${PRUNED_FRAME_PREFIX}${names[0] ?? UNKNOWN_FRAME_NAME} · step ${step}]`);
     if (withHint)
         lines[0] = `${lines[0]}${RECOVERY_HINT}`;
     const content = [{ type: 'text', text: lines.join('\n') }];

package/dist/i18n/index.js

@@ -161,6 +161,7 @@ const zhCN = {
     'intervention.emptyInput': '自动返回空输入',
     'intervention.nonInteractive': '[介入] {title}（非交互环境，{kind}）',
     'repl.idle': '空闲',
+    'repl.queuedCommandHeld': '排队的是斜杠命令，已填入输入框，请确认后手动发送',
     'repl.loadFailed': '（加载失败）',
     'repl.resumeAnchor': '已恢复会话 {id} · {count} 条消息 · 当前模型 {model}（/model switch 可切换）',
     'repl.noSessions': '（没有已保存的会话）',
@@ -208,6 +209,8 @@ const zhCN = {
     'banner.disabled': '关闭',
     'status.modeSwitch': 'Shift+Tab 切换',
     'status.history': '历史 ↑{count}（PgDn 回底）',
+    'status.queued': '排队 ·',
+    'status.queuePlanTag': '（Plan）',
     'status.measured': '实测',
     'status.estimated': '估算',
     'status.messages': '{count} 条消息',
@@ -548,6 +551,7 @@ const en = {
     'intervention.emptyInput': 'automatically returned empty input',
     'intervention.nonInteractive': '[intervention] {title} (non-interactive; {kind})',
     'repl.idle': 'Idle',
+    'repl.queuedCommandHeld': 'Queued text is a slash command; filled into the input for you to send manually',
     'repl.loadFailed': '(load failed)',
     'repl.resumeAnchor': 'Resumed session {id} · {count} messages · model {model} (/model switch to change)',
     'repl.noSessions': '(no saved sessions)',
@@ -595,6 +599,8 @@ const en = {
     'banner.disabled': 'Disabled',
     'status.modeSwitch': 'Shift+Tab Switch',
     'status.history': 'History ↑{count} (PgDn to bottom)',
+    'status.queued': 'queued ·',
+    'status.queuePlanTag': ' (Plan)',
     'status.measured': 'measured',
     'status.estimated': 'estimated',
     'status.messages': '{count} messages',

package/dist/repl/running-input.js

@@ -4,6 +4,7 @@ import * as layout from '../ui/layout.js';
 import * as mouse from '../ui/mouse.js';
 import { promptComposer } from '../ui/composer.js';
 import { appendCurrentSessionRuntimeEvent } from '../session/index.js';
+import { getAgentMode } from '../agent/mode.js';
 const emitter = stdin;
 // ── 运行态交互(typeahead 输入 + 滚动回看 + Ctrl+C 中断 + Ctrl+G 输入面板)──
 // 只在 await runAgent() 期间挂载;/resume /rollback /compact 等走 askLine(cooked readline)的分支不挂(避免抢 stdin)。
@@ -12,6 +13,12 @@ let runningCursor = 0; // 缓冲内光标字符索引(0..len);运行态支持任
 let runningPlaceholder = '';
 let currentAbort = null;
 let listening = false; // onRunningKey 是否处于挂载期(start → stop 之间)
+/**
+ * 运行态「预加载/排队」消息:运行中打字后按 Enter 入队(单条,再次入队即替换),
+ * 当前 agent 结束后由主循环自动发送,无需用户在 INPUT 态再按一次 Enter。
+ * null = 没有排队。mode 快照入队那一刻的模式,自动执行时沿用(用户选「沿用当前模式」)。
+ */
+let queuedTurn = null;
 /** 运行态打开的输入面板(Ctrl+G);非 null = 面板仍开着。主循环进 INPUT 态前须等它关闭,否则两个 keypress 监听抢键。 */
 let composerPending = null;
 /** 获取运行中输入缓冲(agent 结束后预填下一轮 INPUT 态)。 */
@@ -23,6 +30,20 @@ export function clearRunningInput() {
     runningInput = '';
     runningCursor = 0;
 }
+/** 当前排队消息(运行中按 Enter 预加载);无则 null。主循环在 agent 结束后取走并自动发送。 */
+export function getQueuedTurn() {
+    return queuedTurn;
+}
+/** 取走并清空排队消息(消费一次)。 */
+export function consumeQueuedTurn() {
+    const queued = queuedTurn;
+    queuedTurn = null;
+    return queued;
+}
+/** 取消排队(运行态 Esc 在已有排队时优先取消排队,而不是只清 typeahead)。 */
+export function clearQueuedTurn() {
+    queuedTurn = null;
+}
 /**
  * 等待运行态打开的输入面板关闭(无则立即返回)。
  * agent 可能在面板打开期间结束:主循环在进入 INPUT 态(promptWithSlashMenu 挂自己的 keypress)前必须 await,
@@ -99,6 +120,11 @@ function onRunningKey(_str, key) {
             paint();
         }
         else if (currentAbort && !currentAbort.signal.aborted) {
+            // 中断当前任务 = 明确要停下,排队的下一跳也一并取消,避免 agent 一停又自动发新需求。
+            if (queuedTurn) {
+                queuedTurn = null;
+                layout.setQueuedTurn(undefined); // 只撤状态行 chip,不在内容区写提示
+            }
             appendCurrentSessionRuntimeEvent('abort', { phase: 'requested', source: 'keyboard' });
             currentAbort.abort();
         }
@@ -153,13 +179,32 @@ function onRunningKey(_str, key) {
         return;
     }
     if (key.name === 'escape') {
-        runningInput = '';
-        runningCursor = 0;
-        paint();
+        // 有排队消息时 Esc 只取消排队,不清空 typeahead 草稿(避免误删正在打的字);
+        // 无排队时维持原语义:清空 typeahead。
+        if (queuedTurn) {
+            queuedTurn = null;
+            layout.setQueuedTurn(undefined); // 只撤状态行 chip,不在内容区写提示
+            paint();
+        }
+        else {
+            runningInput = '';
+            runningCursor = 0;
+            paint();
+        }
         return;
     }
-    // Enter / Ctrl+J:运行中 no-op(单行 typeahead;agent 结束后预填,用户在 INPUT 态按 Enter 提交)
+    // Enter / Ctrl+J:把 typeahead 内容入队(单条,再次入队即替换)。当前 agent 结束后
+    // 主循环经 consumeQueuedTurn 自动发送,无需在 INPUT 态再按一次 Enter。空内容 no-op。
     if (key.name === 'return' || key.name === 'enter' || (key.ctrl && key.name === 'j')) {
+        const text = runningInput.trim();
+        if (!text)
+            return;
+        queuedTurn = { text: runningInput, mode: getAgentMode() }; // 单条:再次入队即替换
+        runningInput = '';
+        runningCursor = 0;
+        // 入队只反映在状态行 `● 状态` 右侧的常驻 chip(含预览/模式),不往 agent 输出区写行。
+        layout.setQueuedTurn(queuedTurn.text, queuedTurn.mode);
+        paint(); // 清空底部 typeahead 回显
         return;
     }
     // 可打印字符(>= 空格,非 ctrl/meta)→ 光标处插入 + 非 dim 回显(与空闲态一致)

package/dist/repl/runtime.js

@@ -32,7 +32,7 @@ import { PROMPT, buildSlashCommands, LLM_ERROR_HINT_KEYS, isCommandShape, sugges
 import { dispatchCommand } from './commands/registry.js';
 import { settlePlanStatus, refreshStatusBase, runningStateFor } from './status-bar.js';
 import { messageAttachments, formatUserMessage, textOf, queryHistoryFromMessages, renderHistory, } from './message-format.js';
-import { startRunningListener, stopRunningListener, getRunningInput, clearRunningInput, waitForRunningComposer, } from './running-input.js';
+import { startRunningListener, stopRunningListener, getRunningInput, clearRunningInput, waitForRunningComposer, consumeQueuedTurn, } from './running-input.js';
 const emitter = stdin;
 // ── 运行态交互已移到 ./running-input.ts ──
 // ── pendingPrefill / pendingTimer / pendingAttachments 保留在此(awaitPendingRecall / echoInput 用)
@@ -352,12 +352,6 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
             layout.contentWrite(`${ui.dim}(没有可回滚的轮次)${ui.reset}\n`);
             return;
         }
-        // 各轮 user 全文(预填用;按 user 消息顺序与 turnList 对齐)
-        const userTexts = [];
-        for (const m of history) {
-            if (m.role === 'user')
-                userTexts.push(textOf(m.content));
-        }
         const items = turnList.map((t) => ({ firstLine: t.firstLine }));
         let picked;
         try {
@@ -368,8 +362,11 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
         }
         if (picked === null)
             return; // Esc 取消
-        // picked(0-based)= 第 (picked+1) 轮:删该轮及之后(planRollback(picked) 保 1..picked),预填该轮 user 输入
-        const prefillText = userTexts[picked] ?? '';
+        // picked(0-based)= 第 (picked+1) 轮:删该轮及之后(planRollback(picked) 保前 picked 轮),
+        // 预填该轮 user 输入。必须经 store 按"尾部对齐的真实用户轮消息"定位——直接按 history 里
+        // role==='user' 数下标会把工具附件的合成 user 消息/被剪枝老轮算进去,预填错轮。
+        const pickedMessage = runtime.rollback.turnUserMessage(picked, history);
+        const prefillText = pickedMessage ? textOf(pickedMessage.content) : '';
         const plan = runtime.rollback.plan(picked, history);
         // 清屏(擦选轮菜单 + /rollback 回显)+ 复位 lastView(dim 空),给文件询问一个干净、resize 安全的画面
         layout.clearContent();
@@ -679,7 +676,19 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
         // 运行态 Ctrl+G 打开的输入面板可能在 agent 结束时仍开着:等它关闭再进 INPUT 态,
         // 否则面板与 promptWithSlashMenu 两个 keypress 监听抢键;面板确认的内容随后经 getRunningInput 预填。
         await waitForRunningComposer();
-        // INPUT 态:画底栏输入框 + 状态行,光标入输入框
+        // 消息预加载:上一轮运行中用户按 Enter 排了队(consumeQueuedTurn),agent 一结束就自动发送,
+        // 跳过 INPUT 态输入框与撤回窗口(入队那一刻即已确认)。非空才自动发;排队时正在打的 typeahead
+        // 草稿经 pendingPrefill 保住,留到下一轮输入框。
+        const queued = consumeQueuedTurn();
+        const autoSend = !!queued && queued.text.trim().length > 0;
+        if (queued)
+            layout.setQueuedTurn(undefined); // chip 已被消费(或为空丢弃),从状态行撤下
+        if (autoSend && queued) {
+            // 排队时仍在输入框草稿里的字(typeahead)不能丢:回填为下一轮预填。
+            if (getRunningInput().trim())
+                pendingPrefill = [getRunningInput()];
+            clearRunningInput();
+        }
         refreshStatusBase(history);
         // 后台反思若已完成(上轮 fire-and-forget),在安全点 flush 一行 dim 摘要:
         // 不在 RUNNING 态写——防与正在跑的 agent 争屏(contentWrite / 状态行)。
@@ -688,39 +697,54 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
             layout.contentWrite(`  ${ui.gray}↳ ${formatReflectResult(reflectRes)}${ui.reset}\n`);
             clearLastReflectResult();
         }
-        // 所有斜杠命令和 Agent 轮次共用同一个输出→输入边界，避免某条命令漏写第二个 \n
-        // 后下一条 ❯ 气泡紧贴确认文案；已有多余空行也会收敛为恰好一行。
-        if (hasSubmittedInput)
-            layout.normalizeInputBoundary();
-        layout.enterInputMode(t('repl.idle'));
-        let input = null;
-        try {
-            input = await promptWithSlashMenu({
-                prompt: PROMPT,
-                commands: buildSlashCommands(),
-                onCycleMode: cycleMode,
-                // Ctrl+R / Ctrl+P 历史搜索候选源:惰性工厂——当前会话内存 queryHistory + 最近落盘会话,
-                // 聚合要读盘,只有面板真正打开(Ctrl+R/P)才求值,平常轮次零开销
-                history: () => collectQueryHistory(queryHistory).map((e) => e.text),
-                // /rollback 预填优先;否则上一轮运行中 typeahead 打的字 → 预填进输入框,用户可改可发
-                ...(pendingPrefill
-                    ? { initialLines: pendingPrefill }
-                    : getRunningInput()
-                        ? { initialLines: [getRunningInput()] }
-                        : {}),
-            });
+        let input;
+        let queuedMode = null;
+        if (autoSend && queued) {
+            input = queued.text.split('\n');
+            queuedMode = queued.mode;
         }
-        catch {
-            break; // Ctrl+C(SIGINT)/ 异常 → 退出
+        else {
+            // 所有斜杠命令和 Agent 轮次共用同一个输出→输入边界，避免某条命令漏写第二个 \n
+            // 后下一条 ❯ 气泡紧贴确认文案；已有多余空行也会收敛为恰好一行。
+            if (hasSubmittedInput)
+                layout.normalizeInputBoundary();
+            layout.enterInputMode(t('repl.idle'));
+            try {
+                const picked = await promptWithSlashMenu({
+                    prompt: PROMPT,
+                    commands: buildSlashCommands(),
+                    onCycleMode: cycleMode,
+                    // Ctrl+R / Ctrl+P 历史搜索候选源:惰性工厂——当前会话内存 queryHistory + 最近落盘会话,
+                    // 聚合要读盘,只有面板真正打开(Ctrl+R/P)才求值,平常轮次零开销
+                    history: () => collectQueryHistory(queryHistory).map((e) => e.text),
+                    // /rollback 预填优先;否则上一轮运行中 typeahead 打的字 → 预填进输入框,用户可改可发
+                    ...(pendingPrefill
+                        ? { initialLines: pendingPrefill }
+                        : getRunningInput()
+                            ? { initialLines: [getRunningInput()] }
+                            : {}),
+                });
+                if (picked === null)
+                    break; // 空 prompt Ctrl+D
+                input = picked;
+            }
+            catch {
+                break; // Ctrl+C(SIGINT)/ 异常 → 退出
+            }
+            pendingPrefill = null; // 预填已消费,清空
+            clearRunningInput(); // 预填已消费,清空(下轮运行态从空开始)
         }
-        pendingPrefill = null; // 预填已消费,清空
-        clearRunningInput(); // 预填已消费,清空(下轮运行态从空开始)
-        if (input === null)
-            break; // 空 prompt Ctrl+D
         let joined = input.join('\n');
         const line = joined.trim();
         if (!line)
             continue;
+        // 排队预加载只对「发给 agent 的需求」自动执行;斜杠命令不静默自动跑
+        // (否则排队 /clear、/exit、/rollback 会在用户没看着时触发),改为填回输入框由用户显式确认。
+        if (autoSend && isCommandShape(line.split(/\s+/)[0] ?? '')) {
+            pendingPrefill = input;
+            layout.contentWrite(`${ui.dim}  ↳ ${t('repl.queuedCommandHeld')}${ui.reset}\n`);
+            continue;
+        }
         hasSubmittedInput = true;
         if (line === '/exit' || line === '/quit')
             break;
@@ -833,7 +857,8 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
             continue; // 与其他命令一致:回 INPUT 态由循环顶部的 normalizeInputBoundary + enterInputMode 负责
         }
         const bubbleRows = input.length + 2 + pendingAttachments.length; // N 行 message + 2 行尾随空(含 \n\n 留下的 open current 行) + 每附件 1 行
-        const shouldCommit = await awaitPendingRecall(input);
+        // 排队消息入队时即已确认 → 跳过 500ms 撤回窗口,直接发送。
+        const shouldCommit = autoSend || (await awaitPendingRecall(input));
         if (!shouldCommit) {
             // 撤回:气泡从内容区擦掉 + 行放回输入框(下轮 promptWithSlashMenu 经 initialLines 消费)+ 切回 INPUT 视觉。
             // pendingAttachments **保留** —— 撤回的是输入文本不是意图,再发时随消息一起带走
@@ -845,7 +870,8 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
         }
         // 只记录已过撤回窗口的真实用户 query；slash 命令和合成执行轮不会走到这里。
         queryHistory.push(joined);
-        const initialPlan = getAgentMode() === 'plan'; // 轮首模式(在 runTurn 之前读)
+        // 排队消息沿用「入队那一刻」的模式(用户在运行中预加载时选的模式);普通消息读当前模式。
+        const initialPlan = (queuedMode ?? getAgentMode()) === 'plan';
         const turn = await runTurn(joined, initialPlan, placeholder);
         if (turn.routedCancel) {
             // 路由阶段 Ctrl+C 撤回:与 500ms 撤回窗口同语义——气泡擦掉 + 行回填输入框

package/dist/rollback/store.js

@@ -47,6 +47,61 @@ const EXCLUDED_WORKSPACE_DIRS = Object.freeze([
     '.ruff_cache',
     '.gradle',
 ]);
+/**
+ * 工具经 modelAttachments 注入的合成 user 消息前言(见 agent/tool-turn.ts 的
+ * ATTACHMENT_PREAMBLE)。这类消息 role 也是 'user',但不对应 beginTurn 的真实用户轮,
+ * 回滚按 role==='user' 数轮次会与 turns 数组错位,导致"回退一条却连带删掉好几轮"。
+ * 两处常量必须保持一致;不 import tool-turn 是为避免 rollback→agent 的层级反向依赖。
+ */
+const TOOL_ATTACHMENT_PREAMBLE = 'The read_file tool loaded the following visual input: ';
+/**
+ * 视觉滑动窗口剪枝占位的机器固定格式(必须与 context/vision-window.ts 的
+ * pruneFrameMessage 输出逐字一致):一行或多行 `[screenshot omitted: <帧名> · step <数字>]`,
+ * 首行可能再跟固定恢复提示后缀。用整串正则而不是前缀匹配,避免把恰好以
+ * "[screenshot omitted: " 开头的真实用户输入误判成占位。
+ *
+ * 这里内联而不是 import vision-window:vision-window → llm → … → rollback/index 会形成
+ * 循环依赖,在共享进程的测试里触发 "Cannot access 'defaultRollbackStore' before initialization"。
+ */
+const PRUNED_FRAME_LINE_RE = /^\[screenshot omitted: .+? · step \d+\]$/;
+const PRUNED_FRAME_HINT_SUFFIX = ' Call computer{screenshot} if you need the current screen.';
+function isPrunedFrameText(text) {
+    if (typeof text !== 'string')
+        return false;
+    const lines = text.split('\n');
+    return lines.every((line, i) => {
+        const core = i === 0 && line.endsWith(PRUNED_FRAME_HINT_SUFFIX) ? line.slice(0, -PRUNED_FRAME_HINT_SUFFIX.length) : line;
+        return PRUNED_FRAME_LINE_RE.test(core);
+    });
+}
+/**
+ * 判断一条 user 消息是否对应一个真实用户轮(= beginTurn 记进 turns 的那一条)。
+ *
+ * 排除两种合成 user 消息(都是 role:'user' 但不计轮次):
+ *  1. 工具批次提交时由 modelAttachments 注入的附件消息:ContentPart[] 的 text part
+ *     以工具附件前言开头;
+ *  2. 上述附件消息经视觉滑动窗口剪枝后的占位:整个 content 被替换成
+ *     "[screenshot omitted: …]" 文本,前言已不存在(见 vision-window.pruneFrameMessage),
+ *     形态可能是数组 text part,也可能是纯字符串。
+ *
+ * 用户自己发的多模态消息没有这两个标记,不会被误判。
+ */
+function isRealTurnUserMessage(message) {
+    if (message.role !== 'user')
+        return false;
+    const content = message.content;
+    if (typeof content === 'string')
+        return !isPrunedFrameText(content);
+    if (!Array.isArray(content))
+        return false;
+    for (const part of content) {
+        if (part && typeof part === 'object' && part.type === 'text' && typeof part.text === 'string') {
+            if (part.text.startsWith(TOOL_ATTACHMENT_PREAMBLE) || isPrunedFrameText(part.text))
+                return false;
+        }
+    }
+    return true;
+}
 const CAPTURE_FILE_LIMIT = 1024 * 1024;
 const CAPTURE_TOTAL_LIMIT = 32 * 1024 * 1024;
 const CAPTURE_ENTRY_LIMIT = 20000;
@@ -440,6 +495,32 @@ export class RollbackStore {
     listTurns() {
         return this.turns.slice();
     }
+    /**
+     * 取菜单第 pickedIndex(0-based)轮对应的真实用户消息(用于 /rollback 后预填)。
+     * 与 findCutoffIndex 同一套尾对齐规则。无对应消息(续接历史缺轮)时返回 undefined。
+     */
+    turnUserMessage(pickedIndex, history) {
+        const index = this.findTurnUserIndex(pickedIndex, history);
+        return index < 0 ? undefined : history[index];
+    }
+    /**
+     * 菜单第 pickedIndex(0-based)轮对应的真实用户消息在 history 中的下标。
+     * turns 是真实轮次的尾部连续子集(滚动剪枝/压缩只丢旧轮),故菜单第 k 轮 =
+     * history 中倒数第 (turns.length-k) 条真实用户轮消息。找不到返回 -1。
+     */
+    findTurnUserIndex(pickedIndex, history) {
+        let wantReverseRank = this.turns.length - pickedIndex;
+        if (wantReverseRank <= 0)
+            return -1;
+        for (let i = history.length - 1; i >= 0; i--) {
+            if (!isRealTurnUserMessage(history[i]))
+                continue;
+            wantReverseRank -= 1;
+            if (wantReverseRank === 0)
+                return i;
+        }
+        return -1;
+    }
     /**
      * 只读侧门(供 /diff 渲染):返回 turnId > sinceTurnId 的全部快照,浅拷贝数组。
      * 快照内容含 before 原文,调用方不得 mutate 返回值;用于展示,不影响回滚语义。
@@ -447,19 +528,21 @@ export class RollbackStore {
     snapshotsSince(sinceTurnId) {
         return this.snapshots.filter((snapshot) => snapshot.turnId > sinceTurnId);
     }
+    /**
+     * 回滚切点:保留菜单前 n 轮,从第 n+1 轮(菜单下标 n,0-based)的真实 user 消息处切断。
+     *
+     * turns(菜单)= 当前仍可回滚的轮次,是真实轮次的**尾部连续子集**(滚动剪枝/压缩只丢旧轮),
+     * 故从尾部倒数定位,而不是正数第 n 条——压缩的「user 逐字通道」会把更老的 user 原文
+     * 捞回保留区,正数下标与 turns 不再连续对齐。找不到(无第 n+1 轮)时返回 history.length。
+     */
     findCutoffIndex(n, history) {
-        let seen = 0;
-        for (let i = 0; i < history.length; i++) {
-            if (history[i].role === 'user') {
-                seen += 1;
-                if (seen === n + 1)
-                    return i;
-            }
-        }
-        return history.length;
+        const index = this.findTurnUserIndex(n, history);
+        return index < 0 ? history.length : index;
     }
     planRollback(n, history) {
         const cutoffTurnId = this.turns[n - 1]?.turnId ?? 0;
+        // turns 与 history 真实 user 消息尾对齐后再取切点:滚动剪枝(>50 轮)/压缩/续接后
+        // turns 只是尾部子集,不能再把 n 当成全局第 n 条 user 消息,否则会多删 offset 轮。
         const cutoffIndex = this.findCutoffIndex(n, history);
         const order = [];
         const map = new Map();
@@ -587,7 +670,9 @@ export class RollbackStore {
         return { deletedMsgs, revertedFiles, conflictedFiles };
     }
     pruneAfterCompaction(history) {
-        const count = history.filter((message) => message.role === 'user').length;
+        // 只数真实用户轮(排除工具附件合成 user 消息);压缩会整体丢弃旧轮,
+        // 保留下来的总是最近的轮次,故 turns 同样从尾部对齐截取。
+        const count = history.filter((message) => isRealTurnUserMessage(message)).length;
         this.turns = count >= this.turns.length ? this.turns : this.turns.slice(-count);
         const alive = new Set(this.turns.map((turn) => turn.turnId));
         this.snapshots = this.snapshots.filter((snapshot) => alive.has(snapshot.turnId));
@@ -603,7 +688,9 @@ export class RollbackStore {
     rebuildFromHistory(history) {
         const rebuilt = [];
         for (const message of history) {
-            if (message.role !== 'user')
+            // 跳过工具附件注入的合成 user 消息,否则 turns 比真实轮次多,
+            // /rollback 菜单与 history 切点(planRollback 按 turns[n-1])整体错位。
+            if (!isRealTurnUserMessage(message))
                 continue;
             const first = toText(message.content).split('\n')[0] ?? '';
             rebuilt.push({ turnId: rebuilt.length + 1, firstLine: truncateDisplay(first, 40) });

package/dist/runtime/runtime.js

@@ -90,6 +90,10 @@ export class Runtime {
                 this.assertOpen();
                 return this.context.rollbackStore.listTurns();
             },
+            turnUserMessage: (pickedIndex, history) => {
+                this.assertOpen();
+                return this.context.rollbackStore.turnUserMessage(pickedIndex, history);
+            },
             plan: (n, history) => {
                 this.assertIdle('plan rollback');
                 const plan = this.context.rollbackStore.planRollback(n, history);

package/dist/ui/layout-internal/core.js

@@ -30,7 +30,7 @@ import { paintInput, repaint } from './input-paint.js';
 import { WHEEL_LINES, screenRowToAbsLine, repaintViewport, scrollBy, scrollWheel, resetScroll, lockScrollToBottom, } from './scroll.js';
 import { contentWrite, contentInsertAfter, contentDeleteFrom, contentReplaceLine, reflowContentForResize, flushMdSegment, } from './content-write.js';
 export { isTuiActive, getGeo, setRegion, contentMode, isStreamingPaused } from './screen.js';
-export { drawStatusBar, setStatus, stopTurnTimer, startTurnTimerIfRunning, paintLiveAtCursor, clearLiveAtCursor, setLiveUsage, setStatusBase, } from './statusbar.js';
+export { drawStatusBar, setStatus, stopTurnTimer, startTurnTimerIfRunning, paintLiveAtCursor, clearLiveAtCursor, setLiveUsage, setQueuedTurn, setStatusBase, } from './statusbar.js';
 export { paintInput, paintRunningInput, repaint } from './input-paint.js';
 export { isScrolled, repaintViewport, repaintContentLine, scrollBy, scrollWheel, resetScroll, lockScrollToBottom, unlockScroll, isScrollLocked, } from './scroll.js';
 export { contentWrite, writeBanner, rewriteBanner, bannerHeight, contentWriteMd, contentWriteMdOnce, clearContent, rewindContent, writeWelcomeBlock, dismissWelcomeBlock, contentInsertAfter, contentDeleteFrom, totalRows, isLastContentRowBlank, normalizeMutationBoundary, normalizeInputBoundary, contentReplaceLine, notifyContentReset, } from './content-write.js';

package/dist/ui/layout-internal/state.js

@@ -61,6 +61,10 @@ export const state = {
      *  composeModelLine 在 RUNNING 态把它画成 chip 放 context 进度条左侧;
      *  不主动触发重画——RUNNING 态 turnTimer 80ms 心跳重画自然取最新值。 */
     liveUsage: undefined,
+    /** 运行态已排队、当前任务结束后自动发送的下一条消息(纯文本摘要,无=undefined)。 */
+    queuedText: undefined,
+    /** 排队消息入队时的模式,用于在 chip 上标注 Plan/Auto。 */
+    queuedMode: undefined,
     statusText: '',
     spinnerFrame: undefined,
     turnStart: null, // RUNNING 态起点(Date.now());INPUT 态为 null。composeStatus 据此拼走时。

package/dist/ui/layout-internal/statusbar.js

@@ -64,6 +64,12 @@ export function composeSpinnerLine(status, cols) {
         lead = `${ui.accent}●${ui.reset} ${ui.dim}${status.status}${ui.reset}`;
         leadW = 1 + 1 + displayWidth(status.status);
     }
+    // 排队下一跳:紧跟「● 状态(+走时)」右侧显示,运行中持续可见,当前任务结束即自动发送。
+    const queued = queuedChip();
+    if (queued) {
+        lead += `  ${queued.str}`;
+        leadW += 2 + queued.w;
+    }
     // ── 右段:仅滚动回看时显历史指示 ──
     let tail = '';
     let tailW = 0;
@@ -371,6 +377,28 @@ export function clearLiveAtCursor() {
 export function setLiveUsage(u) {
     state.liveUsage = u;
 }
+/**
+ * 设置/清除运行态已排队的下一条消息 chip(显示在 `● 状态` 右侧)。
+ * 立即重画一次保证入队瞬间可见;之后 RUNNING 态 80ms 心跳会自然带上。
+ */
+export function setQueuedTurn(text, mode) {
+    state.queuedText = text;
+    state.queuedMode = mode;
+    drawStatusBar();
+}
+/** 排队 chip:▸ 排队: <首行…>（Plan)。只拼左段,宽度另计(不含 ANSI)。 */
+function queuedChip() {
+    const raw = state.queuedText;
+    if (!raw)
+        return null;
+    const firstLine = raw.split('\n')[0] ?? '';
+    const preview = truncateDisplay(firstLine.trim(), 32);
+    const modeTag = state.queuedMode === 'plan' ? t('status.queuePlanTag') : '';
+    const label = t('status.queued');
+    const plain = `${label} ${preview}${modeTag}`;
+    const str = `${ui.yellow}▸ ${plain}${ui.reset}`;
+    return { str, w: 2 + displayWidth(plain) };
+}
 /** 更新状态行基线(模型 / context / cwd / 模式标识 / 活跃 plan chip / 本轮 token chip)。repl 在轮次边界与切模式时调。 */
 export function setStatusBase(b) {
     state.base = b;

package/package.json

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