mocode-ai 0.4.3 → 0.4.5

package/README.md

@@ -150,6 +150,8 @@ The agent operates in **the working directory it was launched from** — to have
 | `memory_update`     | Edit a memory in place (id unchanged; correct stale facts / update summary / toggle pin) |
 | `memory_forget`     | Forget a memory: archived by default (recoverable), `mode=delete` for a hard delete (pinned memories can't be deleted) |
 
+The five `memory_*` tools are gated on `MEMORY_ENABLED=true` at startup; toggle at runtime with `/memory_switch` (REPL restart required, by design — see Skills section for the difference between Tier-1 `MOCODE.md` and Tier-2 memory).
+
 ## Slash commands
 
 | Command           | Purpose                                                              |
@@ -162,6 +164,7 @@ The agent operates in **the working directory it was launched from** — to have
 | `/resume`           | Resume a saved session                                                |
 | `/rollback`         | Menu to pick a turn to roll back to (↑↓ · Enter)                     |
 | `/memory`           | Show memory library: entry count + recent index                       |
+| `/memory_switch`   | Toggle Tier-2 memory on/off (REPL restart required — by design)       |
 | `/reflect`          | Manually trigger a background memory reflection pass                  |
 | `/model`            | Configure the LLM (baseURL / apiKey / model / context window), applied immediately + persisted |
 | `/init`             | Scan the project and generate `MOCODE.md` project memory (dispatched to the agent) |
@@ -198,6 +201,13 @@ MoCode automatically scans the following directories for skills (each skill is a
 
 A skill's `description` is injected into the system prompt (progressive disclosure, tier 1); the model calls `use_skill` to load the full body (tier 2) only when the task is relevant. Use `/skills` to see discovered skills.
 
+## Project memory (MOCODE.md)
+
+MoCode has a **two-tier memory** model distinct from skills:
+
+- **Tier-1 — `MOCODE.md` (auto-loaded every session):** Markdown project memory that gets concatenated into the system prompt on every turn. Discovery walks `~/.mocode/MOCODE.md` → every `MOCODE.md` from the cwd up to the filesystem root (far→near, near wins). On overflow the body is truncated with a marker pointing back at the files. Generate or refresh one with `/init`, or write it by hand — it's plain Markdown, no schema. `MOCODE.md` is also where the agent itself persists "next-session facts" it deduces (architecture, conventions, pitfalls).
+- **Tier-2 — `memory_*` tool library (agent-driven, opt-in):** Discrete tagged records (`decision` / `fact` / `pitfall` / `reference` / `feedback`) with recall-count-based decay (30-day → archived; 90-day → GC). The agent saves / searches / updates / forgets via tools; titles go in the system-prompt index (≤50), bodies fetched on demand via `memory_search`. Off by default; toggle with `MEMORY_ENABLED=true` at startup or `/memory_switch` (REPL restart required).
+
 ## Type checking
 
 ```bash

package/README.zh-CN.md

@@ -150,6 +150,8 @@ agent 工作在**启动时所在的工作目录**——想让它操作某个项
 | `memory_update` | 原地改一条记忆(id 不变;纠正过时事实 / 改摘要 / 改 pin)                      |
 | `memory_forget` | 遗忘记忆:默认归档(可复活),`mode=delete` 硬删(pinned 拒删)               |
 
+5 个 `memory_*` 工具受启动时 `MEMORY_ENABLED=true` 总开关控制;运行时切换用 `/memory_switch`(需重启 REPL,刻意为之,见下「项目记忆」小节区分 Tier-1 / Tier-2)。
+
 ## 斜杠命令
 
 | 命令              | 作用                                                 |
@@ -162,6 +164,7 @@ agent 工作在**启动时所在的工作目录**——想让它操作某个项
 | `/resume`       | 续接已保存的会话                                           |
 | `/rollback`     | 菜单选轮次回滚(↑↓ · Enter)                                |
 | `/memory`       | 看记忆库:条目数 + 近期索引                                    |
+| `/memory_switch` | 切换 Tier-2 记忆开关(需重启 REPL,刻意为之)                  |
 | `/reflect`      | 手动触发一次后台记忆反思 pass                                   |
 | `/model`        | 配置大模型(baseURL / apiKey / model / 上下文窗口),即时生效 + 持久化 |
 | `/init`         | 扫描项目生成 `MOCODE.md` 项目记忆(发给 agent 执行)               |
@@ -198,6 +201,13 @@ mocode 自动扫描以下目录的 skill(每个 skill 是 `<name>/SKILL.md`,带
 
 skill 的 `description` 注入系统提示(渐进式披露第①层),模型只在任务相关时调 `use_skill` 加载完整正文(第②层)。用 `/skills` 查看已发现的 skill。
 
+## 项目记忆(MOCODE.md)
+
+mocode 的**双层记忆**模型,跟 Skills 是两件事:
+
+- **Tier-1 — `MOCODE.md`(每轮自动加载):** Markdown 项目记忆,每轮拼进 system prompt。发现路径:`~/.mocode/MOCODE.md` → 从 cwd 往上逐级 `MOCODE.md`(远→近拼接,近的覆盖更突出);超长截断并标注原始文件。运行 `/init` 生成或刷新,纯 Markdown,可手写,无 schema。agent 自己推得的「下次要记住的事实」(架构/约定/坑位)也写在这里。
+- **Tier-2 — `memory_*` 工具库(agent 主导,需启用):** 离散带标签条目(`decision` / `fact` / `pitfall` / `reference` / `feedback`),按召回计数衰减(30 天 → archived,90 天 → 硬删 GC)。agent 用工具存 / 搜 / 改 / 删;索引(标题)进系统提示(≤50 条),正文按需 `memory_search` 取。默认关,启动 `MEMORY_ENABLED=true` 或 REPL 内 `/memory_switch`(需重启 REPL,刻意为之)。
+
 ## 类型检查
 
 ```bash

package/dist/agent/index.js

@@ -7,10 +7,13 @@ import { Spinner } from '../ui/spinner.js';
 import { summarizeToolCall, summarizeToolResult, truncateDisplay, fmtElapsed, } from '../ui/render.js';
 import { renderFileChange } from '../ui/diff.js';
 import * as layout from '../ui/layout.js';
+import * as batch from '../ui/batch.js';
 import { beginTurn } from '../rollback/index.js';
 import { config } from '../config/index.js';
 import { runAgentCore, isMutationTool, } from './core.js';
 import { createPetHooks } from '../pet/state.js';
+/** 当前 turn 的 batch id(runAgent 内闭包变量;一条 turn 一轮 tool batch 结束即清空)。 */
+let currentBatchId = null;
 /** 取 userInput 的首行:字符串直接 split;多模态 parts 找首个 text part 再 split。 */
 function firstLineOf(ui) {
     if (typeof ui === 'string')
@@ -18,15 +21,22 @@ function firstLineOf(ui) {
     const first = ui.find((p) => p.type === 'text');
     return first?.text.split('\n')[0] ?? '';
 }
-/** 工具调用 ● 头:工具名 + 参数摘要(按 tool_calls 原顺序打印,让用户看到本轮跑哪些工具)。 */
+/** 工具调用 ● 头:工具名 + 参数摘要(按 tool_calls 原顺序打印,让用户看到本轮跑哪些工具)。
+ *  重构后改为累积到 BatchRenderer,onToolBatchEnd 时统一打摘要行;
+ *  展开/折叠由 BatchRenderer + 鼠标 release 决定,本函数不再直接写屏。 */
 function writeToolHeader(tc) {
-    const summary = summarizeToolCall(tc.name, tc.arguments);
-    layout.contentWrite(`  ${ui.brightMagenta}●${ui.reset} ${ui.cyan}${tc.name}${ui.reset}  ${ui.dim}${summary}${ui.reset}\n`);
+    if (!currentBatchId)
+        currentBatchId = batch.beginBatch();
+    batch.recordCall(currentBatchId, tc.name, summarizeToolCall(tc.name, tc.arguments));
 }
-/** 渲染工具结果:mutation 成功走 diff 块(行号 + 语法高亮,仿 Claude Code);其余走一行 preview。 */
+/** 渲染工具结果:mutation 成功走 diff 块(行号 + 语法高亮,仿 Claude Code);其余走一行 preview。
+ *  同 writeToolHeader,改为累积到 BatchRenderer(只缓存字符串,不写屏)。 */
 function writeToolResult(tc, output, parsed, preWriteOld, editStartLine) {
+    if (!currentBatchId)
+        return;
+    let diff = null;
     if (isMutationTool(tc.name) && parsed && !output.startsWith('错误')) {
-        layout.contentWrite(renderFileChange({
+        diff = renderFileChange({
             path: String(parsed.path ?? ''),
             kind: tc.name === 'edit_file' ? 'edit' : 'write',
             oldStr: tc.name === 'edit_file'
@@ -34,14 +44,10 @@ function writeToolResult(tc, output, parsed, preWriteOld, editStartLine) {
                 : preWriteOld,
             newStr: String((tc.name === 'edit_file' ? parsed.new_string : parsed.content) ?? ''),
             startLine: tc.name === 'edit_file' ? editStartLine : 1,
-        }));
-    }
-    else {
-        const preview = summarizeToolResult(tc.name, output);
-        if (preview) {
-            layout.contentWrite(`  ${ui.gray}↳ ${preview}${ui.reset}\n`);
-        }
+        });
     }
+    const preview = diff ? '' : summarizeToolResult(tc.name, output);
+    batch.recordResult(currentBatchId, tc.name, preview, diff);
 }
 /**
  * agent 核心循环(主 agent,TUI 渲染版):
@@ -63,6 +69,7 @@ onContextUpdate) {
     // 开新轮次(回滚用):首行截断 40,供 /rollback 轮次菜单展示。
     beginTurn(truncateDisplay(firstLineOf(userInput), 40));
     layout.contentMode(); // 防御性:运行态光标归输入框光标位供 IME 锚定(enterRunningMode 已置,这里兜底)
+    currentBatchId = null; // 新 turn 清旧 batch id(防上 turn 残留)
     // spinner:状态行最前面转圈(思考中 / 生成 / 执行 工具时,状态栏 lead 位显帧 + 文字)。
     // 经 setStatus 注入状态行(spinnerFrame + statusText),composeStatus 把帧 + 文字放 lead 位;
     // 不画内容区续写位——内容区在等待期间保持干净,首 token 到达即从续写位开始写正文。
@@ -101,7 +108,16 @@ onContextUpdate) {
         onToolStart: (name) => spinner.start(`执行 ${name}`),
         onToolDone: () => spinner.stop(),
         onToolResult: (tc, output, parsed, preWriteOld, editStartLine) => writeToolResult(tc, output, parsed, preWriteOld, editStartLine),
-        onToolBatchEnd: () => layout.contentWrite('\n'),
+        onToolBatchEnd: () => {
+            // 收尾:把累积的 batch 渲染成单行摘要(批内 N 个 tool 调用共用一行,
+            // 鼠标点击该行可展开完整明细——见 ui/batch.ts)。无 batch(模型未调工具)则补空行保持间距。
+            if (currentBatchId) {
+                const id = currentBatchId;
+                currentBatchId = null;
+                batch.endBatch(id, layout);
+            }
+            layout.contentWrite('\n');
+        },
         onNoReply: () => layout.contentWrite(`${ui.dim}(无回复)${ui.reset}\n`),
         onMaxSteps: () => layout.contentWrite(`  ${ui.yellow}●${ui.reset} ${ui.yellow}达到最大步数(${config.maxSteps}),本轮停止。${ui.reset}\n`),
         onAbort: () => {
@@ -109,6 +125,7 @@ onContextUpdate) {
             if (lastChar && lastChar !== '\n')
                 layout.contentWrite('\n');
             layout.contentWrite(`${ui.dim}(已中断)${ui.reset}\n`);
+            currentBatchId = null; // 丢弃未收尾 batch
         },
         onDone: (elapsedMs, usage) => {
             const tok = formatTurnTokens(usage);

package/dist/config/index.js

@@ -99,7 +99,7 @@ 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. But first check whether this conversation already covers it — don't re-explore something already retrieved earlier in this session.)
 - 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.
 - 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:
@@ -115,7 +115,7 @@ You are in PLAN mode: investigate and design only — do NOT execute or change a
 ## ⛯ 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. But first check whether this conversation already covers it — don't re-explore something already retrieved earlier in this session.)
 - 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.
 - 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:
@@ -137,33 +137,44 @@ 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 次对话,以避免上下文膨胀。"
-- **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.
+- **Context check before any call — do this before the batching rule below**: before planning tool calls for this turn, first check whether the current conversation, an earlier tool result, or a file/symbol already read in this session already answers it. If it does, skip the call and answer directly. Only call a tool when the info is genuinely missing, may be stale (the underlying file/state changed since you last read it), or was never retrieved. This applies to every tool — codegraph, grep, web_search, run_command — not just read_file.
+  - ✅ already have it: user asks "刚才那个函数在哪个文件" after codegraph_explore returned it two turns ago → answer from that result, no new call.
+  - ❌ wasteful: re-running grep/codegraph for a symbol whose location this same conversation already returned, "just to be sure".
+- **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.
+- **Web search when freshness matters**: for tasks involving UI/interaction/copy/visual design, new SDKs or APIs, CVE/version upgrades, or anything likely past your training cutoff, web_search FIRST to ground your work in current material — don't fall back on stale templates (gradient+emoji defaults, "I hope this message finds you well" openers, generic AI-flavored phrasing). Routine coding (bug fixes, refactors, tests, internal docs) doesn't need it.
 
 ## 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.
-- Before editing code, read_file to confirm actual content (with line numbers); don't guess from memory.
+- **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. (Skip if you already read this exact content earlier in this session and nothing has changed it since — see Step Economy above.)
 - 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 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).
+- 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).
+- run_command has side effects on the host — state intent before invoking (delete, install, push, reset, etc.).
 - 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.
+- **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)
@@ -182,18 +193,14 @@ ${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; update as you go. Skip for single-file edits or quick lookups.
+- Plan is file-backed (\`todolist read\` to re-orient). See the tool description for the full action set.
 
 ## 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/capabilities.js

@@ -26,6 +26,9 @@ const KNOWN_TEXT_ONLY_PREFIXES = [
     'babbage-',
     'davinci-',
     'gpt-4o-mini-search', // 搜索专用,无视觉入口
+    // MiniMax M2 系列(M2 / M2.1 / M2.5 / M2.7,含各自 -highspeed 变体):纯文本,无视觉输入。
+    // 官方文档明确仅 MiniMax-M3 支持 image/video content parts;M2.x 传 image_url 会被拒。
+    'minimax-m2',
 ];
 const KNOWN_VISION_FAMILIES = [
     'gpt-4o',
@@ -54,6 +57,7 @@ const KNOWN_VISION_FAMILIES = [
     'minicpm-v',
     'glm-4v',
     'yi-vl',
+    'minimax-m3', // 官方文档:仅 M3 支持 image_url/video_url content parts
 ];
 /** 归一化:小写、去空白;用于前缀比较。 */
 function normalize(model) {

package/dist/repl/index.js

@@ -11,11 +11,13 @@ import { ui, setTheme, getTheme, listThemes, themeExists } from '../ui/theme.js'
 import { bannerString, displayWidth, padEndDisplay, summarizeToolCall, summarizeToolResult } from '../ui/render.js';
 import * as layout from '../ui/layout.js';
 import * as mouse from '../ui/mouse.js';
+import * as batch from '../ui/batch.js';
 import { promptWithSlashMenu, promptTurnPicker, promptSessionPicker, promptThemePicker, promptRevertChoice, } from '../ui/prompt.js';
 import { promptIntervention } from '../ui/intervention.js';
 import { tools } from '../tools/registry.js';
 import { estimateMessagesTokens, reconfigureClient, } from '../llm/index.js';
 import { loadImageAttachment, renderChip, MAX_INLINE_BYTES_DEFAULT, } from '../attachments/image.js';
+import { modelSupportsVision } from '../llm/capabilities.js';
 import { manualCompact, contextState, newSessionId, saveSession, loadSession, listSessions, } from '../session/index.js';
 import { listTurns, planRollback, applyRollback, persistSnapshots, loadSnapshots, rebuildFromHistory, resetState, } from '../rollback/index.js';
 import { listSkills, effectiveSystemPrompt, } from '../skills/index.js';
@@ -33,7 +35,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)' },
@@ -62,6 +65,9 @@ const MODEL_PRESETS = [
     { label: 'GLM(智谱)', baseURL: 'https://open.bigmodel.cn/api/v3', model: 'glm-4.6', window: 128000 },
     { label: 'DeepSeek', baseURL: 'https://api.deepseek.com', model: 'deepseek-chat', window: 64000 },
     { label: 'Qwen(阿里)', baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1', model: 'qwen-plus', window: 128000 },
+    // MiniMax OpenAI 兼容端点(https://platform.minimax.io/docs/api-reference/text-openai-api)。
+    // MiniMax-M3 为唯一支持图片/视频输入的模型;M2 系列纯文本(见 llm/capabilities.ts KNOWN_TEXT_ONLY_PREFIXES)。
+    { label: 'MiniMax', baseURL: 'https://api.minimax.io/v1', model: 'MiniMax-M3', window: 1000000 },
     { label: '本地 Ollama', baseURL: 'http://localhost:11434/v1', model: 'qwen2.5:7b', window: 32768 },
     { label: '本地 vLLM', baseURL: 'http://localhost:8000/v1', model: 'default', window: 32768 },
     { label: '自定义 base_url', baseURL: '', model: '', window: 128000 },
@@ -417,19 +423,33 @@ function textOf(c) {
 }
 /**
  * 把会话历史渲染成静态文本进内容区(回滚 / 续接 / --resume 后复显上下文,仿 Claude Code):
- * user→❯ 回显、assistant→正文(+ tool_calls 作 ● 行)、tool→↳ 结果预览;system 跳过。
+ * user→❯ 回显、assistant→正文(+ tool_calls 折叠成 ● 摘要行)、tool→↳ 结果预览;system 跳过。
  * 思考段不持久(history 只存正文),故无思考折叠。渲染后续写位在末尾,紧接 enterInputMode 画输入框。
  * 内容长于屏时 viewport 显尾(最近轮次),PgUp 可看更早——与流式态一致。
  * user 多模态:用 textOf 取 text parts;若侧 channel messageAttachments 有原文件名则追加 chip 行
  * (避免 base64 解码不可逆,旧 session 没侧 channel 时只显文本,文件名 fallback 到 image/* mime)。
+ *
+ * 折叠策略:遇到 assistant + tool_calls 不立即打 ● 行,而是累积到 batchEntries;
+ * 跟随的连续 tool 消息按 tool_call_id 反查填 resultSummary;遇下一个非 tool 消息(或末尾)时,
+ * 用 batch.writeSummaryOnly 出单行摘要(与实时 runAgent 同一渲染器,UI 一致)。
+ * 回放默认全折叠;用户可鼠标点击摘要行展开(由 BatchRenderer 接管,见 ui/batch.ts)。
  */
 export function renderHistory(history) {
     const idToName = new Map();
+    // 当前累积的 batch(assistant.tool_calls + 后续 tool 消息);一旦遇到非 tool 消息即收尾出摘要
+    let pendingBatch = [];
+    const flushBatch = () => {
+        if (pendingBatch.length === 0)
+            return;
+        batch.writeSummaryOnly(pendingBatch, layout);
+        pendingBatch = [];
+    };
     for (let idx = 0; idx < history.length; idx++) {
         const m = history[idx];
         if (m.role === 'system')
             continue;
         if (m.role === 'user') {
+            flushBatch(); // 上一轮 batch(若有)收尾
             const lines = textOf(m.content).split('\n');
             layout.contentWrite(formatUserMessage(lines));
             const atts = messageAttachments.get(idx);
@@ -454,31 +474,53 @@ export function renderHistory(history) {
         if (m.role === 'assistant') {
             const text = textOf(m.content);
             if (text) {
+                flushBatch(); // 文本前若有累积 batch 先收尾(罕见:连续两个 assistant tool_calls 文本间)
                 layout.contentWriteMdOnce(text);
                 if (!text.endsWith('\n'))
                     layout.contentWrite('\n');
             }
             const tcs = m.tool_calls;
-            if (Array.isArray(tcs)) {
+            if (Array.isArray(tcs) && tcs.length > 0) {
+                // 累积到 pendingBatch,顺序 = tool_calls 序
                 for (const tc of tcs) {
                     const name = tc?.function?.name ?? '';
                     const args = tc?.function?.arguments ?? '';
                     if (tc?.id && name)
                         idToName.set(tc.id, name);
-                    layout.contentWrite(`  ${ui.brightMagenta}●${ui.reset} ${ui.cyan}${name}${ui.reset}  ${ui.dim}${summarizeToolCall(name, args)}${ui.reset}\n`);
+                    pendingBatch.push({
+                        name,
+                        callSummary: summarizeToolCall(name, args),
+                        resultSummary: '',
+                        diffBlock: null,
+                    });
                 }
+                continue; // 跳过后续 tool 消息处理循环(由下一分支填 result)
             }
+            // 无 tool_calls:若有 pending batch(文本+无 tool_calls 的 assistant),不常见,先收尾
+            flushBatch();
             continue;
         }
         if (m.role === 'tool') {
             const id = m.tool_call_id ?? '';
             const name = idToName.get(id) ?? '';
-            const preview = summarizeToolResult(name, textOf(m.content));
-            if (preview)
-                layout.contentWrite(`  ${ui.gray}↳ ${preview}${ui.reset}\n`);
+            const output = textOf(m.content);
+            const preview = summarizeToolResult(name, output);
+            // 匹配 pendingBatch 中尚未填 result 的同名 entry;同名前缀 tool 较罕见(并行工具同 id 不同名)
+            let target;
+            for (let i = pendingBatch.length - 1; i >= 0; i--) {
+                const e = pendingBatch[i];
+                if (e.name === name && !e.resultSummary) {
+                    target = e;
+                    break;
+                }
+            }
+            if (target)
+                target.resultSummary = preview;
+            // 不直接写屏——等 flushBatch 时出单行摘要
             continue;
         }
     }
+    flushBatch(); // 末尾兜底
 }
 /**
  * 交互式 REPL:全屏 TUI(alt screen + 固定底栏)。INPUT 态底栏=状态行+输入框(raw mode 等按键);
@@ -673,9 +715,13 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             ? input
             : [
                 { type: 'text', text: input },
+                // detail 故意不设(留 undefined,JSON.stringify 时被丢弃):OpenAI 认 'auto'/'low'/'high',
+                // 但 MiniMax 只认 'low'/'default'/'high'——'auto' 不是合法枚举值,某些后端会 400。
+                // 不传 detail 让各 provider 用自己的默认值(OpenAI 默认视为 auto,MiniMax 默认 default),
+                // 是唯一在两边都不出错的写法。
                 ...imgs.map((a) => ({
                     type: 'image_url',
-                    image_url: { url: a.dataUrl, detail: 'auto' },
+                    image_url: { url: a.dataUrl },
                 })),
             ];
         const msgIndex = history.length; // runAgent push 后 = 这个 index
@@ -738,6 +784,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);
@@ -913,6 +984,11 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
                 pendingAttachments.push(r.att);
             }
             layout.contentWrite(`  ${ui.dim}${renderChip(r.att)} — will attach to next message${ui.reset}\n`);
+            // 提前警告(不阻断附加):当前模型已知不支持视觉(如 MiniMax M2.x / gpt-3.5 等)时,
+            // 附加时就提示,而不是等发送后才在 catch 块里翻译 API 报错——减少一轮无意义请求。
+            if (!modelSupportsVision(config.model)) {
+                layout.contentWrite(`  ${ui.yellow}⚠ 当前模型 ${config.model} 已知不支持视觉输入,发送图片可能会失败。可用 /model 切换。${ui.reset}\n`);
+            }
             continue;
         }
         if (line === '/context') {
@@ -1029,10 +1105,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;
@@ -1044,33 +1121,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);
+            }
+            catch {
+                continue; // Ctrl+C(SIGINT)→ 取消
             }
-            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`);
+            await resumeFromPick(pick);
             continue;
         }
         if (line === '/theme' || line.startsWith('/theme ')) {

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;
 }