mocode-ai 0.4.2 → 0.4.4

package/dist/agent/core.js

@@ -25,6 +25,24 @@ function parseArgs(raw) {
         return null;
     }
 }
+/**
+ * Thrashing 检测:同一工具 + 完全相同 arguments 在本轮重复 ≥ THRASH_THRESHOLD 次,
+ * 返一段提示(注入到工具结果尾部),引导模型换思路而不是再试一次。
+ * 阈值 3 = "试过两次同样的调用还没好,该停了"。指纹 = `${name}\\x00${args}`
+ * (直接拼,不哈希——避免热路径开销;args 长度本身有限,内存压力可忽略)。
+ * null 表示未触发,不污染输出。
+ */
+const THRASH_THRESHOLD = 3;
+function thrashHint(name, args, count) {
+    if (count < THRASH_THRESHOLD)
+        return null;
+    return (`\n\n[hint] This is call #${count} of \`${name}\` with identical arguments — ` +
+        'either failing or returning the same content. STOP retrying and switch strategy:\n' +
+        '- read_file / glob → path likely wrong; call `glob` to discover paths, or `ask_human`\n' +
+        '- run_command → Windows path-escaping issue; use `read_file` / `glob` with absolute paths instead\n' +
+        '- edit_file → old_string mismatch; re-read the file to find the exact text\n' +
+        '- otherwise → re-read the tool description; the argument shape may be wrong');
+}
 /** 只读工具集:一轮多个时,连续的只读工具成组 Promise.all 并行(无副作用、互不依赖)。 */
 const READ_TOOL_NAMES = new Set([
     'read_file',
@@ -136,9 +154,20 @@ export async function runAgentCore(opts) {
                 promptTokens: turnUsage.promptTokens + u.promptTokens,
                 completionTokens: turnUsage.completionTokens + u.completionTokens,
                 totalTokens: turnUsage.totalTokens + u.totalTokens,
+                cachedTokens: turnUsage.cachedTokens + u.cachedTokens,
+                reasoningTokens: turnUsage.reasoningTokens + u.reasoningTokens,
             }
             : u;
     };
+    // Thrashing 检测:本轮内同 (name, args) 累计次数。≥3 在工具结果尾部追加 hint(见 thrashHint)。
+    // 只在 runAgentCore 内,turn 结束自然 GC;不跨 turn 持久(下一轮重新计数,避免误把历史判为 thrashing)。
+    const recentToolCalls = new Map();
+    const recordAndHint = (name, args) => {
+        const fp = `${name}\x00${args}`;
+        const c = (recentToolCalls.get(fp) ?? 0) + 1;
+        recentToolCalls.set(fp, c);
+        return thrashHint(name, args, c);
+    };
     history.push({ role: 'user', content: userInput });
     // drop_context 工具的上下文剔除回调:闭包捕获 history,原地剔除无关旧 tool 结果。
     // 保护由 dropContextFromHistory 内部保证:history[0](system)+ 当前轮(最后 user 及其后)永不剔除。
@@ -267,7 +296,9 @@ export async function runAgentCore(opts) {
                             const output = await started[k];
                             hooks.onToolDone?.();
                             hooks.onToolResult?.(tc, output, null, null, 1); // 只读工具无 diff
-                            pushToolResult(history, tc, output, relprune, lifecycle, scheduler);
+                            // Thrashing:history 里附 hint(UI 已用干净 output 渲染,避免屏幕噪声)
+                            const hint = recordAndHint(tc.name, tc.arguments);
+                            pushToolResult(history, tc, hint ? `${output}${hint}` : output, relprune, lifecycle, scheduler);
                         }
                         i = j;
                     }
@@ -287,7 +318,9 @@ export async function runAgentCore(opts) {
                             hooks.onToolHeader?.(tc);
                             const err = `错误:计划模式下禁用工具 ${tc.name}(仅读探查,不改动文件 / 不跑命令)`;
                             hooks.onToolResult?.(tc, err, null, null, 1);
-                            pushToolResult(history, tc, err, relprune, lifecycle, scheduler);
+                            // Thrashing:同上
+                            const hint = recordAndHint(tc.name, tc.arguments);
+                            pushToolResult(history, tc, hint ? `${err}${hint}` : err, relprune, lifecycle, scheduler);
                             i++;
                             continue;
                         }
@@ -306,7 +339,9 @@ export async function runAgentCore(opts) {
                             const tc = batch[k];
                             const output = await started[k];
                             hooks.onToolResult?.(tc, output, null, null, 1); // task 结果是摘要,无 diff
-                            pushToolResult(history, tc, output, relprune, lifecycle, scheduler);
+                            // Thrashing:同上
+                            const hint = recordAndHint(tc.name, tc.arguments);
+                            pushToolResult(history, tc, hint ? `${output}${hint}` : output, relprune, lifecycle, scheduler);
                         }
                         hooks.onToolDone?.();
                         i = j;
@@ -320,7 +355,9 @@ export async function runAgentCore(opts) {
                             hooks.onToolHeader?.(tc);
                             const err = `错误:计划模式下禁用工具 ${tc.name}(仅读探查,不改动文件 / 不跑命令)`;
                             hooks.onToolResult?.(tc, err, null, null, 1);
-                            pushToolResult(history, tc, err, relprune, lifecycle, scheduler);
+                            // Thrashing:同上
+                            const hint = recordAndHint(tc.name, tc.arguments);
+                            pushToolResult(history, tc, hint ? `${err}${hint}` : err, relprune, lifecycle, scheduler);
                             i++;
                             continue;
                         }
@@ -333,7 +370,9 @@ export async function runAgentCore(opts) {
                         const output = await executeTool(tc.name, tc.arguments, signal, { skipRollback, dropContext });
                         hooks.onToolDone?.();
                         hooks.onToolResult?.(tc, output, parsed, preWriteOld, editStartLine);
-                        pushToolResult(history, tc, output, relprune, lifecycle, scheduler);
+                        // Thrashing:同上(history 附 hint,UI 干净)
+                        const hint = recordAndHint(tc.name, tc.arguments);
+                        pushToolResult(history, tc, hint ? `${output}${hint}` : output, relprune, lifecycle, scheduler);
                         // 相关性裁剪 mutation 通知:edit_file/write_file 后,该 path 之前的所有 read_file
                         // 结果已失效(已不再是文件当前状态)→ stub 为存根。pruner 内部 try/catch + 幂等。
                         // 非 mutation 工具(run_command/use_skill/memory_* 等)此处 path="" 不触发。

package/dist/agent/index.js

@@ -150,8 +150,21 @@ function mergeHooks(a, b) {
     }
     return merged;
 }
-/** 摘要行后追加的本轮 token 文本。例:`  · 1.5k tokens (↑ 1.2k ↓ 0.3k)`。
- *  关闭 include_usage / 全失败 → usage=undefined → 不输出(保持原摘要行长度,不留空白)。 */
+/** 摘要行后追加的本轮 token 文本。
+ *  例(无 cache):
+ *    `  ·  1.5k tokens (↑ 1.2k ↓ 0.3k)`
+ *  例(命中 cache,DeepSeek 类折扣计费):
+ *    `  ·  72k tokens (↑ 8k ↓ 3k) · ↻ 61k cached`
+ *  例(CoT 模型 + cache):
+ *    `  ·  72k tokens (↑ 8k ↓ 3k) · ↻ 61k cached · reasoning 1.2k`
+ *
+ *  设计要点:
+ *  - 括号里 ↑ 显示**计费 prompt**(= 全量 - cached),不是后端报的 raw prompt,
+ *    否则用户看到 69k 会按全价估成本,实际只花了 5-9k 的 $。
+ *  - ↻ 显示 cache 命中(白嫖部分),让用户一眼看到优化效果(系统 prompt 越长、对话越长越显著)。
+ *  - reasoning 是 completion 的子集(已含在 ↓ 里),仅作信息;不二次计入成本。
+ *  - 总数 total 不变 —— 是数学意义上的"流过的 token",反映 LLM 实际工作量。
+ *  关闭 include_usage / 全失败 → usage=undefined → 不输出(保持原摘要行长度)。 */
 function formatTurnTokens(usage) {
     if (!usage)
         return '';
@@ -159,5 +172,14 @@ function formatTurnTokens(usage) {
     if (!total)
         return '';
     const fmt = (n) => (n < 1000 ? `${n}` : `${(n / 1000).toFixed(total >= 10000 ? 0 : 1)}k`);
-    return `  ·  ${fmt(total)} tokens (↑ ${fmt(usage.promptTokens)} ↓ ${fmt(usage.completionTokens)})`;
+    const cached = usage.cachedTokens;
+    const reasoning = usage.reasoningTokens;
+    const billablePrompt = usage.promptTokens - cached;
+    const extras = [];
+    if (cached > 0)
+        extras.push(`↻ ${fmt(cached)} cached`);
+    if (reasoning > 0)
+        extras.push(`reasoning ${fmt(reasoning)}`);
+    const extrasStr = extras.length > 0 ? ` · ${extras.join(' · ')}` : '';
+    return `  ·  ${fmt(total)} tokens (↑ ${fmt(billablePrompt)} ↓ ${fmt(usage.completionTokens)})${extrasStr}`;
 }

package/dist/agent/spawn.js

@@ -108,7 +108,7 @@ export async function spawnAgent(opts) {
         onMaxSteps: () => writeBuf(`  ● 达到最大步数(${maxSteps}),子 agent 停止。\n`),
         onDone: (elapsedMs, usage) => {
             const tok = usage && usage.totalTokens
-                ? `  · ${usage.totalTokens} tokens`
+                ? `  · ${usage.totalTokens} tokens${usage.cachedTokens ? ` ↻${usage.cachedTokens} cached` : ''}`
                 : '';
             writeBuf(`  ✻ 子 agent 耗时 ${(elapsedMs / 1000).toFixed(1)}s${tok}\n`);
         },

package/dist/config/index.js

@@ -59,6 +59,7 @@ const PLATFORM_NOTE = (() => {
 - You are on Windows; run_command runs commands via cmd.exe (/c). Unix shell builtins are NOT available here.
 - Windows equivalents: which→where, cat→type, ls→dir, rm→del/rd, cp→copy, mv→move. cmd.exe uses %VAR% (not $VAR); pipes (|) and redirects (>, >>) work, but no $(...) command substitution or backticks.
 - head/tail/find/grep/sed have no cmd.exe equivalent — use the dedicated tools (read_file for head/tail, glob for find, grep for grep), or invoke PowerShell via run_command if you need more.
+- **Avoid \`run_command\` for file ops on Windows**: cmd /c re-parses paths with backslashes / spaces / quotes — fragile, and ~half of "agent can't find file" failures trace back to this. Use the dedicated tools (read_file/glob/grep) which take absolute Windows paths natively, no shell involved. In particular, NEVER \`dir\` / \`ls\` / \`Test-Path\` / \`if exist\` / \`python -c "os.path.exists(...)"\` — those waste turns on escaping. Use \`glob\` to list, and just call \`read_file\` to test existence (returns ENOENT as a clean error string). If you must shell out, use forward slashes (\`C:/foo/bar\`).
 - Prefer the dedicated tools (read_file/glob/grep) over shell equivalents — they're cross-platform and already wired in.`;
     }
     if (process.platform === 'darwin') {
@@ -98,20 +99,32 @@ function buildPlanModeSuffix() {
 ## ⛯ PLAN MODE (active now)
 You are in PLAN mode: investigate and design only — do NOT execute or change anything.
 - Your editing / command tools (write_file, edit_file, run_command) have been REMOVED from your tool list. Use only the read-only tools available to you (read_file, glob, grep, codegraph, web_search, web_fetch, use_skill, ask_human) to investigate.
-- Research thoroughly: locate the relevant code, trace call paths, and understand existing patterns and conventions before designing. Your FIRST action for code exploration should be the codegraph tool (explore/node) when a .codegraph/ index exists — not read_file/grep. Use read_file/grep only to fill gaps codegraph leaves.
+- Research thoroughly: locate the relevant code, trace call paths, and understand existing patterns and conventions before designing. (Codegraph is the default first action for code exploration — see Workflow in the base prompt.)
 - Then produce a clear, actionable implementation plan: files to change (with paths), what to change in each and why, the ordered steps, edge cases to handle, and how to verify (typecheck / tests / build). Be specific enough to execute against.
-- Present the plan as your final reply and STOP, unless the user explicitly asked you to "plan first then execute" / "先 plan 再 auto" / autonomous execution: in that case, after presenting the plan, call the switch_mode tool with mode="auto" to switch back to auto mode WITHIN THE SAME TURN and continue implementing the plan yourself (your write/edit/command tools become available again immediately). The user will see no approval prompt because you self-switched.
-- If the user entered plan mode manually (via /plan or Shift+Tab) for a safety review and did NOT ask for autonomous execution, do NOT call switch_mode — present the plan and STOP. Do NOT ask the user for confirmation or approval in your text reply (e.g. "is this plan OK?", "shall I proceed?", "需要你确认") — the REPL automatically shows an approval prompt after you STOP, so asking in text is redundant and forces the user to answer twice. Just present the plan and end your reply.`;
+- When the plan is complete and ready for review, you MUST call the \`ask_human\` tool to surface the plan to the user for approval — do NOT just output the plan as plain text and STOP. ask_human renders a real interactive selection panel inside the TUI; plain-text approval questions in your reply are hard to see and easy to miss.
+- Pass the \`ask_human\` tool a concise plan summary (goal + files/areas to change + key risks + verification) and these three options so the user can decide in one click:
+    1. "按计划执行 (switch to auto and implement)"  — user approves; you then call \`switch_mode("auto")\` IN THE SAME turn and proceed.
+    2. "继续细化方案 (stay in plan, refine)"          — user wants more detail / alternatives; stay in plan, iterate, and re-ask via \`ask_human\` when ready.
+    3. "取消 / 暂不执行 (abort)"                       — user wants to stop; STOP, do NOT call \`switch_mode\`.
+- This applies to BOTH paths: whether the user said "先 plan 再 auto" (autonomous) or entered plan mode manually (via /plan or Shift+Tab) for safety review. The single rule is: never silently self-switch and never silently STOP — always route through \`ask_human\` so the user has an explicit chance to approve, refine, or cancel.
+- Do NOT in your text reply ask rhetorical confirmation questions like "shall I proceed? / 是否同意 / 需要你确认吗" — that bypasses the panel and forces the user to type free-text feedback, which is strictly worse than picking from the 3 options. ask_human is the only sanctioned approval channel in plan mode.
+- Note: the REPL may still show its own approval prompt (\`promptIntervention\`) as a defense-in-depth fallback if you somehow STOP without calling ask_human — do not rely on it; the primary path is ask_human.`;
     }
     return `
 
 ## ⛯ PLAN MODE (active now)
 You are in PLAN mode: investigate and design only — do NOT execute or change anything.
 - Your editing / command / memory-write tools (write_file, edit_file, run_command, memory_save, memory_update, memory_forget) have been REMOVED from your tool list. Use only the read-only tools available to you (read_file, glob, grep, codegraph, web_search, web_fetch, use_skill, ask_human, memory_search, memory_list) to investigate.
-- Research thoroughly: locate the relevant code, trace call paths, and understand existing patterns and conventions before designing. Your FIRST action for code exploration should be the codegraph tool (explore/node) when a .codegraph/ index exists — not read_file/grep. Use read_file/grep only to fill gaps codegraph leaves.
+- Research thoroughly: locate the relevant code, trace call paths, and understand existing patterns and conventions before designing. (Codegraph is the default first action for code exploration — see Workflow in the base prompt.)
 - Then produce a clear, actionable implementation plan: files to change (with paths), what to change in each and why, the ordered steps, edge cases to handle, and how to verify (typecheck / tests / build). Be specific enough to execute against.
-- Present the plan as your final reply and STOP, unless the user explicitly asked you to "plan first then execute" / "先 plan 再 auto" / autonomous execution: in that case, after presenting the plan, call the switch_mode tool with mode="auto" to switch back to auto mode WITHIN THE SAME TURN and continue implementing the plan yourself (your write/edit/command/memory-write tools become available again immediately). The user will see no approval prompt because you self-switched.
-- If the user entered plan mode manually (via /plan or Shift+Tab) for a safety review and did NOT ask for autonomous execution, do NOT call switch_mode — present the plan and STOP. Do NOT ask the user for confirmation or approval in your text reply (e.g. "is this plan OK?", "shall I proceed?", "需要你确认") — the REPL automatically shows an approval prompt after you STOP, so asking in text is redundant and forces the user to answer twice. Just present the plan and end your reply.`;
+- When the plan is complete and ready for review, you MUST call the \`ask_human\` tool to surface the plan to the user for approval — do NOT just output the plan as plain text and STOP. ask_human renders a real interactive selection panel inside the TUI; plain-text approval questions in your reply are hard to see and easy to miss.
+- Pass the \`ask_human\` tool a concise plan summary (goal + files/areas to change + key risks + verification) and these three options so the user can decide in one click:
+    1. "按计划执行 (switch to auto and implement)"  — user approves; you then call \`switch_mode("auto")\` IN THE SAME turn and proceed.
+    2. "继续细化方案 (stay in plan, refine)"          — user wants more detail / alternatives; stay in plan, iterate, and re-ask via \`ask_human\` when ready.
+    3. "取消 / 暂不执行 (abort)"                       — user wants to stop; STOP, do NOT call \`switch_mode\`.
+- This applies to BOTH paths: whether the user said "先 plan 再 auto" (autonomous) or entered plan mode manually (via /plan or Shift+Tab) for safety review. The single rule is: never silently self-switch and never silently STOP — always route through \`ask_human\` so the user has an explicit chance to approve, refine, or cancel.
+- Do NOT in your text reply ask rhetorical confirmation questions like "shall I proceed? / 是否同意 / 需要你确认吗" — that bypasses the panel and forces the user to type free-text feedback, which is strictly worse than picking from the 3 options. ask_human is the only sanctioned approval channel in plan mode.
+- Note: the REPL may still show its own approval prompt (\`promptIntervention\`) as a defense-in-depth fallback if you somehow STOP without calling ask_human — do not rely on it; the primary path is ask_human.`;
 }
 /** 兼容旧名字:repl 的 buildSystemMessage 仍引 PLAN_MODE_SUFFIX(变量)。运行时按需现拼。 */
 export function buildBasePrompt() {
@@ -124,32 +137,42 @@ export function buildBasePrompt() {
         : '- For complex or multi-step tasks, the user may switch to PLAN mode (Shift+Tab): your editing/command tools are then removed from your tool list, and you must research with read-only tools only and produce a step-by-step plan (no execution). On approval the session returns to auto mode to execute the plan.';
     return `You are mocode, a terminal coding agent. You complete programming tasks through a "think → call tool → observe result → think again" loop until the problem is solved. Reply to the user in Chinese.
 
+## 模式 (Modes)
+${autoAllToolsLine}
+${planLine}
+
 ${PLATFORM_NOTE}
 
+## Step / Turn Economy (read this first — saves LLM calls)
+- **Minimize turns**: each user message costs at least one LLM call, and history grows every step until threshold-triggered compact fires (extra call). If a request contains ≥2 independent sub-goals (e.g. "改 X 然后再优化 Y"), ask the user to split them into separate turns rather than chaining both in one go. State this politely: "这条包含 N 个独立目标,建议拆成 N 次对话,以避免上下文膨胀。"
+- **Plan the full turn, then emit it as one batch — this is the single biggest step-saver**: before emitting anything, enumerate every read / edit / command you'll need for this sub-goal, then return them together as one set of tool_calls (reads run in parallel, writes/commands run in the order given). Don't emit one call, observe, then emit the next in a follow-up turn when you could have planned both upfront.
+  - ✅ one turn: \`[read_file A, read_file B, edit_file A, run_command 'npm test']\`
+  - ❌ four turns: \`[read_file A]\` → \`[read_file B]\` → \`[edit_file A]\` → \`[run_command 'npm test']\`
+- **Batch read-only tools in parallel**: consecutive read-only tools (read_file, glob, grep, codegraph, web_search, web_fetch) auto-execute in parallel within one turn — this is the concrete read-side case of the rule above. Do NOT call them serially across turns when you could emit them together.
+- **Decide before reading**: do not read files "just to see"; plan the 2-3 file paths you actually need, then emit them as one batched tool_calls turn.
+- **Chain read→edit→verify in one turn**: when the edit is obvious after a read, call edit_file (and verify with run_command) in the SAME response — don't split into 3 separate turns.
+- **Verify once at the end of an edit chain, not after every edit**: after batching a set of related edits, run a single typecheck / test / build command to verify the whole change together. Running a verify command after each individual edit_file call wastes turns — batch the edits, then verify once.
+- **Don't repeat failed calls**: if the same tool call fails or returns the same content 3 times in this turn, switch strategy (use a different tool, ask the user, or re-read the tool description) — don't keep retrying the same shape.
+- **Don't re-read a file you already have, unless it may have changed**: if you (or an earlier step in this session) already read a file's relevant content and nothing has touched it since, edit directly from that content instead of calling read_file again "to be safe". This does NOT apply when the file was edited (by you or externally) since your last read, when a prior edit may have shifted line numbers you're about to target, or right after a compact where you're unsure the surviving context is accurate — in those cases re-reading is expected and correct, not wasteful.
+
 ## Workflow
 - Understand before acting: when unsure about requirements or code state, explore first; don't assume.
 - **Code exploration first action**: before reading files with read_file or searching with grep, check if a .codegraph/ index exists. If it does, use the codegraph tool (explore for questions/features, node for a specific symbol) as your FIRST step — it returns source + call paths in one shot. Only fall back to read_file/grep when codegraph misses, you need just-changed content, or you're editing a known small file. Build the index with \`codegraph init\` if none exists.
 - Small steps: break tasks into verifiable sub-steps. Before each step, think clearly about what to change and why.
 - Verify after change: run typecheck / tests / build via run_command to confirm it works. Never claim done without verification.
 
-## Step / Turn Economy (read this — saves LLM calls)
-- **Minimize turns**: each user message costs at least one LLM call, and history grows every step until threshold-triggered compact fires (extra call). If a request contains ≥2 independent sub-goals (e.g. "改 X 然后再优化 Y"), ask the user to split them into separate turns rather than chaining both in one go. State this politely: "这条包含 N 个独立目标,建议拆成 N 次对话,以避免上下文膨胀。"
-- **Batch read-only tools in parallel**: in a single assistant turn, emit multiple tool_calls together — consecutive read-only tools (read_file, glob, grep, codegraph, web_search, web_fetch) auto-execute in parallel. Do NOT call them serially across turns when you could emit them together in one turn. This is the single biggest step-saver.
-- **Decide before reading**: do not read files "just to see"; plan the 2-3 file paths you actually need, then emit them as one batched tool_calls turn.
-
 ## Tool Guidelines
 - See each tool's own description for parameters and usage; this section covers selection strategy and pitfalls only.
-- **Prefer codegraph for code exploration**: when understanding/locating code, tracing call chains, or assessing impact of changes, if a .codegraph/ index exists, use the codegraph tool first (explore to query by question, node to look up a single symbol) — it returns relevant source + call paths in one shot, more accurate and economical than piecing together via read_file/grep. Fall back to read_file / grep / glob only when codegraph is unavailable (no index), misses, you need to see just-changed content, or you're editing a single known small file. Build the index first with \`codegraph init\` if none exists.
+- **If the user gave a precise path or symbol, go directly**: read_file or codegraph node it — don't pre-validate with glob/grep.
 - Before editing code, read_file to confirm actual content (with line numbers); don't guess from memory.
 - For local edits use edit_file: old_string must be unique and match exactly (including indentation/newlines); include surrounding context lines to ensure uniqueness. Use write_file for new files or full rewrites.
-- Use glob to find file paths, grep to search content; don't use run_command to pipe cat / sed / find / grep.
+- Use glob to find file paths, grep to search content. **Don't use run_command for file-level checks** (existence / listing / type) — those have no clean cmd.exe equivalent and Windows path escaping fails often. Use \`glob\` to list, and just call \`read_file\` to test existence (returns ENOENT as a clean error string). The earlier rule against \`run_command\` for cat/sed/find/grep still applies.
 - run_command runs per platform (cmd on Windows, bash elsewhere); state intent before running commands with side effects (deleting files, installing packages, git push, resets, etc.).
 - Use web_search for information beyond training data (new versions, news, real-time data, latest APIs); don't answer potentially outdated info from memory.
 - Use web_fetch to read a specific URL (a link from search results, or a URL given by the user); it only fetches static HTML — if a JS-rendered page yields no body, switch to web_search (its results include cleaned body text).
 - Call ask_human when you hit a decision point requiring user input (multiple implementation approaches, unclear intent, or needing extra info to proceed) — list options for the user to pick (they can also choose "custom input" to answer freely). Don't call it frequently when the task is clear and you can decide yourself; if the user cancels, switch approach or proceed with available info — don't re-ask the same question.
-- **Drop irrelevant context proactively**: call drop_context to stub-replace tool results in history that are no longer needed. This is your primary lever for keeping context lean — every step grows history until the threshold-triggered compact fires (which costs an extra LLM call and is more aggressive). Call when any of: (a) you just finished a grep/read sweep and only 1-2 hits mattered; (b) history has >20 tool messages and you are early in the task; (c) you switched sub-goals and the old sub-goal's exploration is dead weight. The call itself adds ~300 tokens, so only call when freed tokens clearly exceed that (≥1 large grep hit or ≥2 medium results). Do NOT call when near completion, when history is short (<10 tool messages), or when the candidate results are still in active use. It preserves tool_call_id pairing (only content changes); the system prompt and current turn are never dropped. Use filters (toolNames / contains) to target precisely.
-- **Observation lifecycle is automatic**: behind the scenes every tool result goes LIVE→REFERENCED→OBSOLETE→STUB. grep/glob/codegraph/web_search/web_fetch are always kept as REFERENCED (never auto-stubbed) because they may surface multiple candidates. read/edit/write results that nobody consumes after two more consumer pushes get auto-stubbed. This is zero-cost (static analysis, no LLM call). You don't need to manage lifecycle yourself — just trust that stale tool results get pruned.
-- **Batch independent tool calls in one turn**: the executor runs ALL returned tool calls before the next LLM call, so emitting [read_file, glob, read_file] together is dramatically cheaper than three separate turns. Default to bundling exploration reads and parallel writes.
+- **Trim context when stale**: when an old tool result is dead weight (sub-goal done, no downstream consumer, or superseded by a later read), call drop_context to stub it. Otherwise rely on automatic pruning — don't carry stale reads into new sub-goals.
+- **Batch writes and commands too, not just reads**: the executor runs ALL returned tool_calls (reads, writes, commands) before the next LLM call. Emit independent edit_file / write_file / run_command in one response when the chain is clear — don't serialize them across turns just because they have side effects. (The read-only batching note in Step Economy applies to writes the same way.)
 - **Chain shell workflows in a single \`run_command\`**: use \`&&\`, \`;\`, \`|\`, \`>\`, heredocs to fold multi-step scripts (\`mkdir -p x && cat > x/file.ts <<'EOF' ... EOF && npm test\`) into one call. Only emit a follow-up turn when the result forces a decision (error, ambiguous output, branching logic).
 
 ## Large file writes (avoid token-cap truncation)
@@ -168,18 +191,15 @@ ${PLATFORM_NOTE}
 - Operate only within authorized scope; when unsure, ask — don't guess.
 
 ${memorySection}
-${autoAllToolsLine}
-${planLine}
 
-## Working notepad (todolist) — checklist for complex tasks
-- For **complex multi-step tasks** (≥3 file changes OR ≥5 tool calls expected OR user says "先计划再执行" / "plan then do" / "按步骤来"), call the \`todolist\` tool FIRST to write a plan to \`.mocode/plans/<id>.md\`, then execute step by step, calling \`todolist update\` to mark progress. For trivial single-step tasks, skip it and just execute.
-- The plan is file-backed (survives context compression, user can see/edit). The active plan summary is auto-injected into the system prompt each turn, so you can re-read it via \`todolist read\` whenever you're unsure of your place.
-- Single plan per session: \`todolist create\` refuses if an in-progress plan already exists — finish or abandon it first.
-- **Lifecycle** (5 actions total): \`create\` / \`read\` / \`update\` / \`add_step\` / \`finish\` for normal flow. \`finish plan_status=finished\` AUTO-ARCHIVES the plan to \`.mocode/plans/archive/<id>.md\` (history preserved, active dir stays clean). To revisit old plans: \`list scope=archived\` (or \`all\`) + \`unarchive id=<id>\` to bring back. \`delete id=<id>\` permanently removes (any location); cannot delete the currently active plan.
-- Don't over-use it: for a single edit or a quick lookup, \`todolist\` is overhead. The threshold is "this needs ≥3 steps OR I might forget the plan after context compaction."
+## Working notepad (todolist) — for multi-step tasks
+- For tasks spanning **≥2 independent modules** OR when the user asks for stepwise progress ("先计划再执行" / "plan then do" / "按步骤来"), call \`todolist create\` first to write the plan to \`.mocode/plans/<id>.md\`, then \`todolist update\` to mark progress as you go. For single-file edits or quick lookups, skip it.
+- The plan is file-backed (survives context compression; user can see/edit), and the active plan summary is auto-injected into this system prompt each turn. Re-read via \`todolist read\` when unsure of your place.
+- See the \`todolist\` tool description for the full action set (create / read / update / add_step / finish / list / unarchive / delete) and lifecycle.
 
 ## Termination & Reporting
 - Stop immediately when no more tools are needed; give conclusions directly.
+- **No flattery / no preamble in conclusions**: skip "Sure", "好的", "我已经完成了" and similar no-information prefixes — jump straight to substance.
 - Report honestly: say success when successful, say where you're stuck when failing, and mention anything skipped. Reference code in "path:line" format (e.g., src/index.ts:42). Keep it concise.`;
 }
 /**

package/dist/llm/index.js

@@ -162,6 +162,68 @@ export const chatTools = tools.map((t) => ({
  * 记忆,这里仍是按当前 isMemoryEnabled() 算出的快照——重启 REPL 才完全生效。
  */
 export const planChatTools = chatTools.filter((t) => !getPlanDisabledTools().has(t.function.name));
+/**
+ * 多 provider 兼容的 cache / reasoning 字段提取。
+ * 不同后端报 cached 字段名差异巨大,这里按"最常见的几种"顺序 probe,
+ * 首个合法非负数字即用(0 也算合法 —— cache miss 是合法状态,不是"无数据")。
+ * 字段全缺 → 0,UI 不会显示任何额外标注(零行为变化)。
+ *
+ * 已实测 / 字段名已知:
+ *   - OpenAI / Azure / 多数 OpenAI 兼容中转:
+ *       prompt_tokens_details.cached_tokens
+ *   - DeepSeek(含 R1):
+ *       prompt_cache_hit_tokens(扁平,顶层)
+ *   - Anthropic Claude:
+ *       cache_read_input_tokens
+ *   - Moonshot Kimi / GLM-4.6 / Qwen:同 OpenAI 标准
+ *   - Ollama / 本地 vLLM / 其它:无 usage details → 0(零行为变化)
+ *
+ * reasoning 字段(CoT 模型):
+ *   - OpenAI o1 / DeepSeek R1 / GLM-Z1:
+ *       completion_tokens_details.reasoning_tokens
+ *   - 其它(个别):reasoning_tokens(顶层)
+ */
+export function extractUsageExtras(usage) {
+    if (!usage || typeof usage !== 'object')
+        return { cachedTokens: 0, reasoningTokens: 0 };
+    const u = usage;
+    // cached probe 顺序:OpenAI 标准 → DeepSeek 扁平 → Anthropic → 杂项兜底
+    const cachedCandidates = [
+        readPath(u, ['prompt_tokens_details', 'cached_tokens']),
+        u.prompt_cache_hit_tokens,
+        u.cache_read_input_tokens,
+        u.cached_tokens,
+        u.prompt_tokens_cached,
+    ];
+    // reasoning probe 顺序:OpenAI 标准 → 扁平兜底
+    const reasoningCandidates = [
+        readPath(u, ['completion_tokens_details', 'reasoning_tokens']),
+        u.reasoning_tokens,
+    ];
+    return {
+        cachedTokens: firstNumber(cachedCandidates) ?? 0,
+        reasoningTokens: firstNumber(reasoningCandidates) ?? 0,
+    };
+}
+/** 从对象按路径读嵌套字段(每段都做 null/undefined 检查,任一断即返 undefined)。 */
+function readPath(obj, path) {
+    let cur = obj;
+    for (const k of path) {
+        if (cur == null || typeof cur !== 'object')
+            return undefined;
+        cur = cur[k];
+    }
+    return cur;
+}
+/** 从候选数组里取第一个合法非负有限数字(0 算合法 —— cache miss 不是"无数据")。
+ * 顺序敏感:数组里前面的 provider 优先(如 OpenAI 标准报 0 时,不会 fallback 到 DeepSeek 字段)。 */
+function firstNumber(arr) {
+    for (const v of arr) {
+        if (typeof v === 'number' && Number.isFinite(v) && v >= 0)
+            return v;
+    }
+    return undefined;
+}
 /**
  * 流式调一次 LLM:增量回调文本,内部累加 tool_calls 片段。
  * tool_calls 跨 chunk 按 index 累加(id / name / arguments 拼接)。
@@ -222,10 +284,13 @@ async function chatOnce(messages, handlers, signal, toolsOverride) {
     for await (const chunk of stream) {
         // usage:末尾 chunk(choices 可能为空)在 include_usage 时携带;先读再 continue。
         if (chunk.usage) {
+            const extras = extractUsageExtras(chunk.usage);
             usage = {
                 promptTokens: chunk.usage.prompt_tokens,
                 completionTokens: chunk.usage.completion_tokens,
                 totalTokens: chunk.usage.total_tokens,
+                cachedTokens: extras.cachedTokens,
+                reasoningTokens: extras.reasoningTokens,
             };
         }
         const delta = chunk.choices?.[0]?.delta;

package/dist/memory/store.js

@@ -316,6 +316,14 @@ export function gcMemories() {
  * active 条目按 updatedAt 降序,封顶 MAX_INDEX_ENTRIES,只注 id/name/summary/type。
  * 无 active 返空串(零行为变化)。body 不注入——按需 memory_search 取。
  *
+ * 索引策略(省 token):不全量塞进每轮 systemPrompt。
+ *  - pinned 永远包含(pinned = 用户明确想长期保留)
+ *  - recallCount ≥ 1 包含(被引用过,价值已验证)
+ *  - 否则仅当 (lastRecalledAt|createdAt) 近 RECENT_MS(=DECAY_DAYS×2) 内
+ * 排序:pinned 先 → recallCount 降 → updatedAt 降。
+ * 封顶 MAX_INDEX_ENTRIES;尾部标 hidden 数量,引导用 memory_list/memory_search 兜底。
+ * 真正「陈旧」被滤掉时也明示(让 LLM 知道有内容存在但被策略隐藏,而不是误以为空)。
+ *
  * memoryEnabled=false 时(记忆子系统总开关关闭)直接返空串:Memory Index 段
  * 不进系统提示,LLM 看不到工具使用提示;配合 tools/builtins 屏蔽 memory_* 工具,
  * 实现「关闭时零侵入」(默认行为)。传参由 repl 的 buildSystemMessage 在拼装前调
@@ -324,22 +332,49 @@ export function gcMemories() {
 export function buildMemoryIndexSection(memoryEnabled = true) {
     if (!memoryEnabled)
         return '';
-    const active = loadAll()
-        .filter((e) => e.status === 'active')
-        .sort((a, b) => (b.updatedAt || '').localeCompare(a.updatedAt || ''));
+    const all = loadAll();
+    const active = all.filter((e) => e.status === 'active');
     if (active.length === 0)
         return '';
-    const shown = active.slice(0, MAX_INDEX_ENTRIES);
+    const now = Date.now();
+    // DECAY_DAYS×2 = 60 天(常量在下方定义,同模块作用域内可见)
+    const recentCutoff = now - DECAY_DAYS * 2 * DAY_MS;
+    const refTs = (e) => {
+        const r = e.lastRecalledAt ? Date.parse(e.lastRecalledAt) : Date.parse(e.createdAt);
+        return Number.isFinite(r) ? r : now;
+    };
+    // 过滤:只保留"近 60 天有动静 / 有 recall / pinned"的三类。其它 active 视为陈旧。
+    const eligible = active.filter((e) => {
+        if (e.pinned)
+            return true;
+        if (e.recallCount >= 1)
+            return true;
+        return refTs(e) >= recentCutoff;
+    });
+    eligible.sort((a, b) => {
+        if (a.pinned !== b.pinned)
+            return a.pinned ? -1 : 1;
+        if (a.recallCount !== b.recallCount)
+            return b.recallCount - a.recallCount;
+        return (b.updatedAt || '').localeCompare(a.updatedAt || '');
+    });
+    const staleCount = active.length - eligible.length;
+    const shown = eligible.slice(0, MAX_INDEX_ENTRIES);
     const lines = shown.map((e) => `- ${e.id}: ${e.name} — ${e.summary} (${e.type})`);
-    const tail = active.length > MAX_INDEX_ENTRIES
-        ? `\n\n…(${active.length} total, showing first ${MAX_INDEX_ENTRIES}; use memory_search <id or keyword> for more)`
-        : '';
+    const capOmitted = Math.max(0, eligible.length - shown.length);
+    const tailParts = [];
+    if (capOmitted > 0)
+        tailParts.push(`${capOmitted} additional active entries omitted by cap (${shown.length}/${eligible.length} shown)`);
+    if (staleCount > 0)
+        tailParts.push(`${staleCount} stale active entries hidden by index policy (no recall + older than ${DECAY_DAYS * 2}d; use memory_list to see all)`);
+    const tail = tailParts.length > 0 ? `\n\n…(${tailParts.join('; ')})` : '';
     return [
         '',
         '',
         '## Memory Index (retrieve full body via memory_search)',
         'The following are saved memory entries (title/summary only). Retrieve full body via memory_search (pass id or keyword); use memory_list to see all,'
-            + ' memory_update to modify, memory_forget to archive. This list is a startup snapshot; entries added during the session are not listed here — use memory_list/memory_search to find them.',
+            + ' memory_update to modify, memory_forget to archive. This list is a startup snapshot; entries added during the session are not listed here — use memory_list/memory_search to find them.'
+            + ' Index policy: pinned + recently-recalled always shown; long-untouched active entries are hidden to keep this section lean.',
         ...lines,
         tail,
     ].join('\n');

package/dist/repl/index.js

@@ -33,7 +33,8 @@ const SLASH_COMMANDS = [
     { name: '/context', desc: '显示上下文用量条' },
     { name: '/skills', desc: '列出已发现的 skill' },
     { name: '/compact', desc: '压缩历史(可带焦点 /compact …)' },
-    { name: '/resume', desc: '续接已保存的会话' },
+    { name: '/resume', desc: '续接最近 10 个已保存会话(快速)' },
+    { name: '/sessions', desc: '浏览全部已保存会话(慢,翻历史用)' },
     { name: '/rollback', desc: '菜单选轮次回滚(↑↓·Enter)' },
     { name: '/memory', desc: '记忆库:条目计数与近期索引(关闭时提示先开 /memory_switch)' },
     { name: '/memory_switch', desc: '切换记忆子系统开关(无参=切换;/on 或 /off 显式;持久化 MEMORY_ENABLED)' },
@@ -195,6 +196,13 @@ let runningInput = ''; // 运行中已打字缓冲(单行;agent 结束后预填
 let runningPlaceholder = '';
 let currentAbort = null;
 let pendingPrefill = null; // /rollback 选中后预填的 user 输入(下轮 INPUT 态消费)
+// ── pending send 撤回窗口(用户按 Enter 后、agent 真发请求前)──
+// 500ms 内 Ctrl+C / Esc → 整条用户气泡从内容区擦掉 + 原行 prefilled 回输入框(可改可再发);
+// 期间再按 Enter 立即推进 / 时间到自然推进 → 走原流程 enterRunningMode + runTurn。
+// attachmentsCount 记 pendingAttachments 当时长度——撤回时 attachments 保留(用户意图未变,只是改字)。
+const PENDING_RECALL_MS = 500;
+let pendingRecall = null;
+let pendingTimer = null;
 // agent 模式状态已提到 src/agent/mode.ts(共享叶子:switch_mode 工具可写、agent 每步读、repl 注册 onModeChange 监听器)。
 /** 多模态 user 输入的附件状态。pending = 本轮尚未提交的待发图片;messageAttachments = 已 push 进 history 的图片元数据
  *  (供 renderHistory 复显文件名——base64 不可逆地塞进 history 后,只能从侧 channel 拿原文件名)。 */
@@ -325,6 +333,76 @@ function echoInput(lines) {
         layout.contentWrite(`  ${ui.dim}${renderChip(a)}${ui.reset}\n`);
     }
 }
+/**
+ * 等待 pending 撤回窗口(用户 Enter 后、agent 真发请求前的 500ms 兜底)。
+ * 返 true=应 commit(走原 enterRunningMode + runTurn);false=应 recall(主循环 rewindContent 擦气泡 + prefill 回输入框)。
+ *
+ * 监听:
+ *   - Esc / Ctrl+C → recall(shouldCommit=false)
+ *   - Enter / Return → 立即 commit(shouldCommit=true)
+ *   - 其它键忽略(不进 paste 路径、不挂 timer)
+ *   - 500ms 定时器到 → 自动 commit(shouldCommit=true)
+ *
+ * 视觉:状态行 spinner 位临时改 '发送中…  (Esc / Ctrl+C 撤回)';commit 后
+ * runAgent.onStepStart 会 setStatus('思考中') 接管,无需手动还原。
+ *
+ * 降级:非 TTY(setRawMode 抛错)直接 commit,window=0 —— CI / 管道回放路径不退化。
+ */
+function awaitPendingRecall(input, attachmentsCount, placeholder) {
+    pendingRecall = { lines: input, attachmentsCount, placeholder };
+    layout.setStatus('发送中…  (Esc / Ctrl+C 撤回)', '●');
+    // 非 TTY:setRawMode 抛错 → window=0 直返 true(向后退化,不走 raw + 不挂监听)。
+    let ttyReady = false;
+    try {
+        stdin.setRawMode(true);
+        ttyReady = true;
+    }
+    catch {
+        ttyReady = false;
+    }
+    if (!ttyReady) {
+        pendingRecall = null;
+        return Promise.resolve(true);
+    }
+    stdin.resume();
+    emitKeypressEvents(stdin);
+    return new Promise((resolve) => {
+        let done = false;
+        const finalize = (shouldCommit) => {
+            if (done)
+                return;
+            done = true;
+            if (pendingTimer) {
+                clearTimeout(pendingTimer);
+                pendingTimer = null;
+            }
+            emitter.off('keypress', onPendingKey);
+            pendingRecall = null;
+            resolve(shouldCommit);
+        };
+        const onPendingKey = (_str, key) => {
+            if (!key || done)
+                return;
+            // 鼠标报表:吞(与 prompt.ts / onRunningKey 风格一致)
+            if (mouse.swallow(key.sequence ?? ''))
+                return;
+            // 撤回
+            if (key.name === 'escape' || (key.ctrl && key.name === 'c')) {
+                finalize(false);
+                return;
+            }
+            // 立即 commit
+            if (key.name === 'enter' || key.name === 'return') {
+                finalize(true);
+                return;
+            }
+            // 其他键忽略
+        };
+        emitter.on('keypress', onPendingKey);
+        pendingTimer = setTimeout(() => finalize(true), PENDING_RECALL_MS);
+        pendingTimer.unref?.();
+    });
+}
 /** 把任意消息 content 拍平成字符串(OpenAI 可能 string / null / 多模态数组)。 */
 function textOf(c) {
     if (typeof c === 'string')
@@ -661,6 +739,31 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
         layout.contentWrite('\n'); // 轮次之间空行
         return ok;
     };
+    /** 把 picker 选中的会话加载进 REPL(刷 history + 重建 snapshots + 重画)。/resume / /sessions 共用。 */
+    async function resumeFromPick(pick) {
+        if (!pick)
+            return; // Esc / Ctrl+D 取消
+        const loaded = loadSession(pick.id);
+        if (!loaded || !loaded.history.length) {
+            layout.contentWrite(`${ui.yellow}(加载失败)${ui.reset}\n`);
+            return;
+        }
+        if (loaded.history[0]?.role === 'system') {
+            loaded.history[0] = { role: 'system', content: buildSystemMessage(false) };
+        }
+        history.length = 0;
+        history.push(...loaded.history);
+        setAgentMode('auto'); // 续接重置为 auto(mode 不落盘;listener 重写 history[0] 回 auto,与 loaded 幂等)
+        currentSessionId = loaded.id;
+        // 读回该会话的轮次/快照;无文件则从 history 重建 turns(无快照→旧轮次文件改动不可撤销)
+        if (!loadSnapshots(loaded.id))
+            rebuildFromHistory(history);
+        contextState.lastUsage = undefined;
+        lastTurnUsage = undefined; // 续接:旧会话的 token 累计已无意义,清空等下轮覆写
+        layout.clearContent();
+        renderHistory(history);
+        layout.contentWrite(`${ui.dim}(已续接会话 ${loaded.id})${ui.reset}\n`);
+    }
     while (true) {
         // INPUT 态:画底栏输入框 + 状态行,光标入输入框
         refreshStatusBase(history);
@@ -952,10 +1055,11 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             }
             continue;
         }
-        if (line === '/resume') {
-            // /resume:打开会话菜单(↑/↓ 选,Enter 续接,Esc 取消)。默认仅最近 10 条,按 a 展开全部。
-            // 仿 /rollback 菜单化(promptSessionPicker);选中项 cyan+bold + ▸ 高亮。
-            const sessions = listSessions();
+        if (line === '/sessions') {
+            // /sessions:浏览全部已保存会话(慢路径,readdir+全量 JSON.parse,目录 N 大时会有可感知卡顿)。
+            // 默认走 /resume(仅最近 10 条,瞬开);要翻历史续接更早的会话才用这条。
+            // picker 走全显(cap=items.length,无 a 展开提示),靠 picker 自身开窗(以选中为中心分屏)。
+            const sessions = listSessions(); // 不传 limit = 全量
             if (sessions.length === 0) {
                 layout.contentWrite(`${ui.dim}(没有已保存的会话)${ui.reset}\n`);
                 continue;
@@ -967,33 +1071,37 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             }));
             let pick;
             try {
-                pick = await promptSessionPicker(items);
+                pick = await promptSessionPicker(items, items.length);
             }
             catch {
                 continue; // Ctrl+C(SIGINT)→ 取消
             }
-            if (!pick)
-                continue; // Esc / Ctrl+D 取消
-            const loaded = loadSession(pick.id);
-            if (!loaded || !loaded.history.length) {
-                layout.contentWrite(`${ui.yellow}(加载失败)${ui.reset}\n`);
+            await resumeFromPick(pick);
+            continue;
+        }
+        if (line === '/resume') {
+            // /resume:打开会话菜单(↑/↓ 选,Enter 续接,Esc 取消)。只加载最近 10 条,
+            // 避免 sessions 目录堆了几百个会话时 readdir+全量 JSON.parse 卡顿。
+            // 仿 /rollback 菜单化(promptSessionPicker);选中项 cyan+bold + ▸ 高亮。
+            // 要续接更早的会话请用 /sessions 翻全表,或 CLI `mocode --resume <id>`。
+            const sessions = listSessions(10);
+            if (sessions.length === 0) {
+                layout.contentWrite(`${ui.dim}(没有已保存的会话)${ui.reset}\n`);
                 continue;
             }
-            if (loaded.history[0]?.role === 'system') {
-                loaded.history[0] = { role: 'system', content: buildSystemMessage(false) };
+            const items = sessions.map((s) => ({
+                id: s.id,
+                title: s.firstUser || '(无)',
+                subtitle: `${s.id}  ${s.model}`,
+            }));
+            let pick;
+            try {
+                pick = await promptSessionPicker(items);
             }
-            history.length = 0;
-            history.push(...loaded.history);
-            setAgentMode('auto'); // /resume 重置为 auto(mode 不落盘;listener 重写 history[0] 回 auto,与 loaded 幂等)
-            currentSessionId = loaded.id;
-            // 读回该会话的轮次/快照;无文件则从 history 重建 turns(无快照→旧轮次文件改动不可撤销)
-            if (!loadSnapshots(loaded.id))
-                rebuildFromHistory(history);
-            contextState.lastUsage = undefined;
-            lastTurnUsage = undefined; // /resume:旧会话的 token 累计已无意义,清空等下轮覆写
-            layout.clearContent();
-            renderHistory(history);
-            layout.contentWrite(`${ui.dim}(已续接会话 ${loaded.id})${ui.reset}\n`);
+            catch {
+                continue; // Ctrl+C(SIGINT)→ 取消
+            }
+            await resumeFromPick(pick);
             continue;
         }
         if (line === '/theme' || line.startsWith('/theme ')) {
@@ -1298,6 +1406,17 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             }
             continue;
         }
+        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) {
+            // 撤回:气泡从内容区擦掉 + 行放回输入框(下轮 promptWithSlashMenu 经 initialLines 消费)+ 切回 INPUT 视觉。
+            // pendingAttachments **保留** —— 撤回的是输入文本不是意图,再发时随消息一起带走
+            // (runTurn 入口的 pendingAttachments.flush 仍按现有逻辑把附件塞进 userInput)。
+            layout.rewindContent(bubbleRows);
+            pendingPrefill = input;
+            layout.enterInputMode('空闲');
+            continue;
+        }
         const initialPlan = getAgentMode() === 'plan'; // 轮首模式(在 runTurn 之前读)
         const ok = await runTurn(joined, initialPlan, placeholder);
         // plan 轮正常结束(未中断 / 未抛错)→ 看轮末模式决定:

package/dist/session/persist.js

@@ -81,14 +81,24 @@ export function loadSession(id) {
         return null;
     }
 }
-/** 列出所有会话,按 createdAt 降序。损坏文件跳过。 */
-export function listSessions() {
+/** 列出最近会话,按 createdAt 降序。损坏文件跳过。
+ *  - limit?: 仅返回前 N 条。会话文件名是 YYYYMMDD-HHmmss.json,字典序=时间序;
+ *    先按文件名降序取前 N,再只解析这 N 个文件(history 大字段全部跳过不读),避免
+ *    /resume 在 sessions 目录堆了几百个文件时 readdirSync + 全量 JSON.parse 慢。
+ *  - 不传 limit 时读全部(向后兼容,供裸 --resume 列全表用)。
+ */
+export function listSessions(limit) {
     if (!existsSync(config.sessionDir))
         return [];
+    // 过滤掉 .snapshots.json:ASCII 排序里 's'(115) > 'j'(106),后者排在前面,会让
+    // slice(0, limit) 取到一堆快照文件(JSON.parse 后 rec.id=undefined 被吞),真会话被挤掉。
+    const all = readdirSync(config.sessionDir)
+        .filter((f) => f.endsWith('.json') && !f.endsWith('.snapshots.json'))
+        .sort() // YYYYMMDD-HHmmss.json 字典序 ≡ 时间序(同 createdAt 升序)
+        .reverse(); // 降序:最新在前
+    const toRead = typeof limit === 'number' ? all.slice(0, Math.max(0, limit)) : all;
     const out = [];
-    for (const f of readdirSync(config.sessionDir)) {
-        if (!f.endsWith('.json'))
-            continue;
+    for (const f of toRead) {
         try {
             const rec = JSON.parse(readFileSync(path.join(config.sessionDir, f), 'utf8'));
             if (rec && typeof rec.id === 'string') {
@@ -104,6 +114,5 @@ export function listSessions() {
             // 跳过损坏文件
         }
     }
-    out.sort((a, b) => (a.createdAt < b.createdAt ? 1 : -1));
     return out;
 }

package/dist/ui/content.js

@@ -55,6 +55,33 @@ export function breakRow() {
     rowStartSgr = curSgr; // 下行继承本行末状态
     hasCurrent = true; // 新空行即当前行
 }
+/**
+ * 弹出 buffer 末尾 n 物理行(供 layout.rewindContent 撤回刚写入段用)。
+ * 当前行先 commit 再裁剪(消除 hasCurrent 边界);n ≥ totalRows 则全清,
+ * 但**不动 segMark** —— recall 走普通 contentWrite、不撞 md 段;
+ * segMark 由 reset() / commitSegment() 清,recall 不掺和。
+ */
+export function rewind(n) {
+    if (n <= 0)
+        return;
+    const cur = totalRows();
+    if (n >= cur) {
+        rows = [];
+        curSgr = '';
+        rowStartSgr = '';
+        curRaw = '';
+        hasCurrent = false;
+        return;
+    }
+    // 当前行先 commit 再裁剪(否则 hasCurrent 边界会被打穿)
+    if (hasCurrent) {
+        rows.push(rowStartSgr + curRaw + '\x1B[0m');
+        curRaw = '';
+        rowStartSgr = curSgr;
+        hasCurrent = false;
+    }
+    rows.splice(rows.length - n);
+}
 /** 标记段起点:快照当前缓冲状态,供 setLines 截断定位段头(md 流式渲染每 chunk 截断重渲)。 */
 export function beginSegment() {
     segMark = { rowIdx: rows.length, rowStartSgr, curSgr, curRaw, hasCurrent };

package/dist/ui/layout.js

@@ -396,6 +396,30 @@ export function clearContent() {
     content.reset();
     stdout.write(esc.home);
 }
+/**
+ * 撤销(rewind)内容区末尾 n 物理行 —— 供 "刚 echoInput 写下用户气泡、用户撤回"
+ * 把气泡从可视区与 buffer 一起拿掉。content.rewind 弹出 buffer 末 n 行;layout 这边
+ * 同步上溯 contentRow(contentTop 钳位,防下溢)、scrollOffset 钳到新 totalRows、
+ * 最后 repaintViewport 重画可视区(running 态回 runningCaretPos,input 态回续写位)。
+ *
+ * 与 clearContent 不同:只擦最近一段、保留更早内容与 buffer;光标归内容区底,
+ * 不是 (1,1)。常发生在 RUNNING 态的 pending 窗口内 recall —— recall 后调用方
+ * 通常再 enterInputMode 切回 INPUT 视觉,光标由后续 paintInput 重画。
+ */
+export function rewindContent(rowsToRewind) {
+    if (!active || rowsToRewind <= 0)
+        return;
+    content.rewind(rowsToRewind);
+    const g = getGeo();
+    contentRow = Math.max(g.contentTop, contentRow - rowsToRewind);
+    contentCol = 1;
+    // 钳 scrollOffset:不能让 viewport 视点超出新 totalRows
+    const maxOff = Math.max(0, content.totalRows() - g.contentBottom);
+    scrollOffset = Math.min(scrollOffset, maxOff);
+    // 末段 frameRow/frameCol 是 spinner 的画位,撤回若跨过 frame 行也不必清——
+    // repaintViewport 会按新 buffer 重画整片,旧 frame 自然被覆盖。
+    repaintViewport();
+}
 // ── viewport 滚动回看(Phase 2)──
 /** 是否处于滚动回看态(offset>0,内容区显历史)。prompt 据此在非滚动键时回尾。 */
 export function isScrolled() {
@@ -423,7 +447,16 @@ function normalizeSelection() {
         ? { startLine: a.line, startCol: a.col, endLine: b.line, endCol: b.col }
         : { startLine: b.line, startCol: b.col, endLine: a.line, endCol: a.col };
 }
-/** 给自洽带色行的显示列区间 [colStart,colEnd) 套反白(\x1B[7m...\x1B[27m),SGR 码原样穿过不受影响。 */
+/** 给自洽带色行的显示列区间 [colStart,colEnd) 套「统一亮黄底 + 黑字」。
+ *  强制重设前/背景,无视原 SGR:md 字符常带 ui.dim / ui.cyan / ui.gray 等,
+ *  仅靠 SGR 7 反转对比度极弱;改用显式「亮黄底 SGR 103 + 黑前景 SGR 30」,
+ *  跨终端一致。退反白用 0 清 SGR,行末 active SGR 自然续接。
+ *  关键:反白 active 期间**吃掉所有行内 SGR**(不让前景色干扰)——否则
+ *  行内首个 \x1B[2m(dim)/\x1B[36m(cyan)/\x1B[1m(bold) 进选区后仍生效,
+ *  前景被压回原色,整片亮黄底被切割、看着「花」;直穿则带 dim 等,对比不足。
+ *  反白外 SGR 直穿,保留原色。 */
+const SEL_OPEN = '\x1B[30;103m'; // 30:黑前景 | 103:亮黄背景
+const SEL_OFF = '\x1B[0m'; // 全清 SGR,行末 active 状态续接
 function highlightRange(line, colStart, colEnd) {
     if (colEnd <= colStart)
         return line;
@@ -433,17 +466,20 @@ function highlightRange(line, colStart, colEnd) {
     let opened = false;
     for (let i = 0; i < parts.length; i++) {
         if (i % 2 === 1) {
-            out += parts[i]; // SGR 码原样穿过
+            // SGR 段:反白内直接吃,不让行内前景色进选区;反白外直穿,保留原色。
+            if (opened)
+                continue;
+            out += parts[i];
             continue;
         }
         for (const ch of parts[i]) {
             const cw = charWidth(ch.codePointAt(0) ?? 0);
             if (!opened && w >= colStart && w < colEnd) {
-                out += '\x1B[7m';
+                out += SEL_OPEN;
                 opened = true;
             }
             if (opened && w >= colEnd) {
-                out += '\x1B[27m';
+                out += SEL_OFF;
                 opened = false;
             }
             out += ch;
@@ -451,7 +487,7 @@ function highlightRange(line, colStart, colEnd) {
         }
     }
     if (opened)
-        out += '\x1B[27m';
+        out += SEL_OFF;
     return out;
 }
 /**
@@ -531,7 +567,7 @@ export function clearSelection() {
 export function setPasteHandler(fn) {
     pasteHandler = fn;
 }
-/** picker / 介入面板期间禁用鼠标选区与滚轮(避免 viewport 重画覆盖菜单);面板退出后恢复。 */
+/** picker / 介入面板期间禁用鼠标选区与拖拽(避免 viewport 重画覆盖菜单);滚轮仍可用。面板退出后恢复。 */
 export function setMouseEnabled(v) {
     mouseEnabled = v;
     if (!v) {
@@ -591,8 +627,9 @@ function handleMouseEvent(e) {
     if (!active)
         return;
     if (e.type === 'wheel') {
-        if (mouseEnabled)
-            scrollBy(e.dir * WHEEL_LINES);
+        // 滚轮始终可用:面板/picker 期间也允许上下查看 agent 输出,
+        // 与 onRunningKey 的 PgUp/PgDn 行为一致;mouseEnabled 仅管选区/拖拽。
+        scrollBy(e.dir * WHEEL_LINES);
         return;
     }
     if (!mouseEnabled)
@@ -773,14 +810,20 @@ function composeModelLine(status, cols) {
     }
     return twoColumn(leftStr, leftW, rightStr, rightW, cols);
 }
-/** 把本轮 token 总量格式化成 chip 文本(纯字符串,带 ANSI 色)。无 usage 返空串。 */
+/** 把本轮 token 总量格式化成 chip 文本(纯字符串,带 ANSI 色)。无 usage 返空串。
+ *  显示策略:chip 信息密度有限,只显示总量 + 一个 ↻ 标记表示有 cache 命中。
+ *  详细分项(↑↓ 计费/↻ 缓存/reasoning)在 turn 末 summary 行展示,不在此处展开。 */
 function formatTurnTokenChip(usage) {
     if (!usage || !usage.totalTokens)
         return '';
     const n = usage.totalTokens;
     const text = n < 1000 ? `${n}` : `${(n / 1000).toFixed(n >= 10000 ? 0 : 1)}k`;
-    // 单段:量足够稳定时不显分项,避免无谓视觉负担。chip 用 mid 灰(降优先级)— 模式仍是主色。
-    return `${ui.dim}${text} tokens${ui.reset}`;
+    const cached = usage.cachedTokens ?? 0;
+    const cacheTag = cached > 0
+        ? ` ↻${cached < 1000 ? cached : `${(cached / 1000).toFixed(cached >= 10000 ? 0 : 1)}k`}`
+        : '';
+    // chip 用 mid 灰(降优先级)— 模式仍是主色
+    return `${ui.dim}${text} tokens${cacheTag}${ui.reset}`;
 }
 /** spinner 行上方的「虚拟空行」(contentBottom+1)。
  *  - 有活跃 plan:显「plan: <summary> ▸ N. step」整行左对齐(yellow + dim)

package/dist/ui/prompt.js

@@ -128,9 +128,15 @@ export async function promptWithSlashMenu(opts) {
     function cursorCol() {
         return displayWidth(lines[cl].slice(0, cc));
     }
-    /** chip 预览前缀:整段扁平化(行界→空格,避免框内折行)取前 ~20 列,超长 truncateDisplay 自带 …;末尾空格与 suffix 分隔。 */
+    /** chip 预览前缀:行数 + 字符数(字符 <1K 直出,≥1K 缩为 X.XK)。比"前 20 字符截断"对 CJK 更友好
+     * ——后者在中文里 20 列只够 10 个汉字就截没,几乎看不到内容;元信息密度更高、长度可预测。 */
     function chipPrefix() {
-        return chip ? `[${truncateDisplay(chip.split('\n').join(' '), 20)}] ` : '';
+        if (!chip)
+            return '';
+        const lines = chip.split('\n').length;
+        const chars = chip.length;
+        const charStr = chars < 1000 ? `${chars} 字符` : `${(chars / 1000).toFixed(1)}K 字符`;
+        return `[📋 ${lines} 行 · ${charStr}] `;
     }
     /** chipPre 按行拆分(粘贴发生前光标之前已有的文本,可能多行,原样保留在 chip 之前)。 */
     function chipPreLines() {
@@ -178,7 +184,7 @@ export async function promptWithSlashMenu(opts) {
     function applyPastedText(buf) {
         if (!buf)
             return;
-        const isLong = buf.split('\n').length > 8 || buf.length > 400;
+        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);
@@ -202,7 +208,7 @@ export async function promptWithSlashMenu(opts) {
         computeFiltered();
         redraw();
     }
-    /** 粘贴结束:长粘贴(>8 行或 >400 字符)落/并进 chip(原子,整段封预览),短粘贴落为可编辑文本。 */
+    /** 粘贴结束:长粘贴(>8 行或 >200 字符)落/并进 chip(原子,整段封预览),短粘贴落为可编辑文本。 */
     function finalizePaste() {
         if (resolved) {
             pasteParts = [];
@@ -411,9 +417,13 @@ export async function promptWithSlashMenu(opts) {
             return;
         }
         const isReturn = key.name === 'return' || key.name === 'enter';
-        // 换行:Ctrl+J / Alt+Enter(meta)/ Shift+Enter(终端区分时)/ lone LF
+        // 换行:Ctrl+J / Ctrl+Enter / Alt+Enter(meta)/ Shift+Enter(终端区分时)/ lone LF
         // (粘贴的 CR/LF 已在上方 pasting 分支累积进 pasteParts,不会到此)
+        // Ctrl+Enter:readline 解析得到 key.ctrl=true && isReturn 走这条路;少数老 xterm 把
+        // Ctrl+Enter 当裸 \r 发(没 ctrl flag)→ 落到下方「提交」分支做 Enter 处理,
+        // 此时用 Ctrl+J 兜底。
         const wantNewline = (key.ctrl && key.name === 'j') ||
+            (key.ctrl && isReturn) ||
             (key.meta && isReturn) ||
             (key.shift && isReturn) ||
             (key.sequence === '\n' && !key.ctrl);

package/package.json

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