mocode-ai 1.7.10 → 1.8.0

package/dist/tools/builtins/edit-file.js

@@ -16,10 +16,12 @@ function conflict(path, details) {
 }
 export const editFileTool = {
     name: 'edit_file',
-    description: `Replace content in a file transactionally. Two modes:
+    description: `The DEFAULT tool for changing an EXISTING file: transactional, surgical edits — use this instead of re-writing the whole file with write_file. Pick ONE of three modes per call:
 
 **String replacement (default):** old_string must occur EXACTLY once; copy it verbatim from a fresh read_file output (see Tool policy — never reconstruct it from memory, summaries, or grep output). expected_hash is OPTIONAL in this mode: omit it and the tool checks the file itself (old_string must still match exactly once, and the commit is conflict-checked). If you do pass it, it must match the current file or the edit is rejected.
 
+**Multiple replacements:** pass replacements: [{ old_string, new_string }, …] to apply MANY edits across the file in ONE atomic call. Each old_string must occur exactly once in the original file and the matches must not overlap; if ANY of them is missing, ambiguous, or overlapping, the whole call is rejected and nothing is written. Prefer this over write_file whenever you change several spots — it keeps each payload small and never touches unrelated content. Mutually exclusive with the single old_string and line-range modes.
+
 **Line-range:** line_start/line_end (1-based, inclusive) instead of old_string — for large blocks, repeated patterns, or hard-to-reproduce text. Line numbers drift when a file changes, so expected_hash (sha256 from the read_file artifact header) is REQUIRED here; if it is stale, re-read and retry with the new hash.`,
     risk: 'confirm',
     parameters: {
@@ -28,9 +30,25 @@ export const editFileTool = {
             path: { type: 'string', description: 'Absolute file path.' },
             old_string: {
                 type: 'string',
-                description: 'String replacement mode: the exact text to replace (must occur once). Mutually exclusive with line_start/line_end.',
+                description: 'Single-replacement mode: the exact text to replace (must occur once). Mutually exclusive with replacements[] and line_start/line_end.',
+            },
+            new_string: {
+                type: 'string',
+                description: 'Single-replacement / line-range mode: the replacement text.',
+            },
+            replacements: {
+                type: 'array',
+                minItems: 1,
+                description: 'Multi-replacement mode: many edits applied ATOMICALLY in one call. Each old_string must occur exactly once in the current file and matches must not overlap; if any item is missing/ambiguous/overlapping the whole call is rejected and nothing is written. Mutually exclusive with old_string and line_start/line_end.',
+                items: {
+                    type: 'object',
+                    properties: {
+                        old_string: { type: 'string', description: 'Exact text to replace (must occur once).' },
+                        new_string: { type: 'string', description: 'Its replacement.' },
+                    },
+                    required: ['old_string', 'new_string'],
+                },
             },
-            new_string: { type: 'string', description: 'The replacement text.' },
             line_start: {
                 type: 'integer',
                 description: 'Line-range mode: start line (1-based, inclusive). Mutually exclusive with old_string.',
@@ -41,28 +59,64 @@ export const editFileTool = {
             },
             expected_hash: {
                 type: 'string',
-                description: 'sha256 hash from the latest read_file artifact header (sha256:<64 hex>). Optional for old_string mode; required for line-range mode.',
+                description: 'sha256 hash from the latest read_file artifact header (sha256:<64 hex>). Optional for old_string / replacements modes; required for line-range mode.',
             },
         },
-        // 注意:expected_hash 故意不放进 schema 的 required。
-        // 原因:old_string 模式下它是可选的(old_string 唯一命中本身就是基于内容的前置条件,
-        // 提交时 ChangeSet 仍会比对读到的内容 hash 防并发改动);行号模式下必填,但缺失时若被
-        // AJV 在 schema 层拦下,只会得到泛化的「缺少必填字段 expected_hash」,模型据此只补该字段、
-        // 反而丢掉 path,形成乒乓失败。故只在 execute 内校验,缺失时返回富指导信息。
-        required: ['path', 'new_string'],
+        // 注意:expected_hash 与模式专属字段(new_string / replacements / line_*)都不放进 schema required。
+        // 原因:三模式互斥,必填字段取决于所选模式;AJV 只能表达「静态必填」,在 schema 层拦下只会得到
+        // 泛化的「缺少必填字段 X」,模型据此只补该字段、反而丢掉 path,形成乒乓失败。故只在 execute 内
+        // 按模式校验,缺失/互斥时返回富指导信息。
+        required: ['path'],
     },
     async execute(args, ctx) {
         const file = String(args.path);
-        const newString = String(args.new_string);
         const hasOldString = args.old_string !== undefined;
         const hasLineStart = args.line_start !== undefined;
         const hasLineEnd = args.line_end !== undefined;
-        // 参数互斥检查
-        if (hasOldString && (hasLineStart || hasLineEnd)) {
-            return conflict(file, 'old_string 和 line_start/line_end 互斥，请选择一种模式。');
+        const hasReplacements = args.replacements !== undefined;
+        const hasLineRange = hasLineStart || hasLineEnd;
+        // 三模式互斥:old_string(single)/ replacements[](multi)/ line_start+line_end(line),一次恰好一种。
+        const modeCount = (hasOldString ? 1 : 0) + (hasReplacements ? 1 : 0) + (hasLineRange ? 1 : 0);
+        if (modeCount > 1) {
+            return conflict(file, 'old_string、replacements[]、line_start/line_end 三种模式互斥,一次只能用一种。');
+        }
+        if (hasLineStart !== hasLineEnd) {
+            return conflict(file, '行号模式必须同时提供 line_start 和 line_end。');
+        }
+        let mode;
+        if (hasOldString)
+            mode = 'single';
+        else if (hasReplacements)
+            mode = 'multi';
+        else if (hasLineStart && hasLineEnd)
+            mode = 'line';
+        else {
+            return conflict(file, '必须提供 old_string、replacements[] 或同时提供 line_start 和 line_end 三者之一。');
         }
-        if (!hasOldString && (!hasLineStart || !hasLineEnd)) {
-            return conflict(file, '必须提供 old_string 或同时提供 line_start 和 line_end。');
+        if ((mode === 'single' || mode === 'line') && typeof args.new_string !== 'string') {
+            return conflict(file, '必须提供字符串 new_string(要删除该段时传空串 "")。');
+        }
+        const toLf = (s) => s.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        // multi:数组形状校验(schema 已守,这里给富指导并归一化 CRLF)。
+        let multiEdits = [];
+        if (mode === 'multi') {
+            const arr = args.replacements;
+            if (!Array.isArray(arr) || arr.length === 0) {
+                return conflict(file, 'replacements 必须是至少含 1 个 {old_string,new_string} 的数组。');
+            }
+            for (let i = 0; i < arr.length; i++) {
+                const item = arr[i];
+                if (!item ||
+                    typeof item !== 'object' ||
+                    typeof item.old_string !== 'string' ||
+                    typeof item.new_string !== 'string') {
+                    return conflict(file, `replacements[${i}] 必须是含字符串字段 old_string/new_string 的对象。`);
+                }
+                const rec = item;
+                if (!rec.old_string)
+                    return conflict(file, `replacements[${i}].old_string 不能为空。`);
+                multiEdits.push({ old: toLf(rec.old_string), next: toLf(rec.new_string) });
+            }
         }
         // expected_hash:缺省/null/空串都视为「未提供」。提供了就必须格式正确并严格校验。
         const rawHash = args.expected_hash;
@@ -70,7 +124,7 @@ export const editFileTool = {
         let expectedHash = hashProvided ? normalizeContentHash(String(rawHash)) : null;
         if (hashProvided && !expectedHash)
             return conflict(file, 'expected_hash 必须是 sha256:<64 hex>。');
-        if (!hasOldString && !expectedHash) {
+        if (mode === 'line' && !expectedHash) {
             return conflict(file, '行号模式必须提供 expected_hash(行号会随文件变化漂移,需要内容版本锚点)。');
         }
         // 以 Buffer 读取并按 Buffer 算 hash,与 ChangeSet 内部口径一致(非法 UTF-8 时字符串 hash 会对不上)。
@@ -83,13 +137,12 @@ export const editFileTool = {
         if (!expectedHash)
             expectedHash = contentHash(buffer);
         const data = buffer.toString('utf8');
-        const normalized = data.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
-        const newNormalized = newString.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        const normalized = toLf(data);
         let updated;
-        if (hasOldString) {
+        if (mode === 'single') {
             // String replacement mode
-            const oldString = String(args.old_string);
-            const oldNormalized = oldString.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+            const newNormalized = toLf(String(args.new_string));
+            const oldNormalized = toLf(String(args.old_string));
             const count = normalized.split(oldNormalized).length - 1;
             if (count === 0) {
                 return conflict(file, 'old_string 未找到；请重新 read_file 并复制最新内容。');
@@ -99,8 +152,43 @@ export const editFileTool = {
             }
             updated = normalized.replace(oldNormalized, () => newNormalized);
         }
+        else if (mode === 'multi') {
+            // Multiple replacements mode:所有 old_string 先在「原始文件」上一次性定位,
+            // 各自必须唯一命中、区间互不重叠;任何一项不满足整体拒绝、一条都不改(原子)。
+            const located = [];
+            for (let i = 0; i < multiEdits.length; i++) {
+                const edit = multiEdits[i];
+                const hits = [];
+                let from = 0;
+                let hit;
+                // 空串已在上面拒绝;indexOf 步进至少 1 不会死循环。
+                while ((hit = normalized.indexOf(edit.old, from)) !== -1) {
+                    hits.push(hit);
+                    from = hit + edit.old.length;
+                }
+                if (hits.length === 0) {
+                    return conflict(file, `replacements[${i}].old_string 未找到;请重新 read_file 并复制最新内容。`);
+                }
+                if (hits.length > 1) {
+                    return conflict(file, `replacements[${i}].old_string 出现 ${hits.length} 次;请增加上下文使其唯一。`);
+                }
+                located.push({ start: hits[0], end: hits[0] + edit.old.length, next: edit.next });
+            }
+            located.sort((a, b) => a.start - b.start || a.end - b.end);
+            for (let i = 1; i < located.length; i++) {
+                if (located[i].start < located[i - 1].end) {
+                    return conflict(file, 'replacements[] 的命中区间互相重叠;请拆分或合并这些编辑后重试(本次未写入)。');
+                }
+            }
+            // 定位全部通过后才应用:从后向前按区间替换,偏移不会因前序改动而失效。
+            updated = normalized;
+            for (let i = located.length - 1; i >= 0; i--) {
+                updated = updated.slice(0, located[i].start) + located[i].next + updated.slice(located[i].end);
+            }
+        }
         else {
             // Line-range mode
+            const newNormalized = toLf(String(args.new_string));
             const lineStart = Number(args.line_start);
             const lineEnd = Number(args.line_end);
             if (!Number.isInteger(lineStart) || !Number.isInteger(lineEnd)) {

package/dist/tools/builtins/grep.js

@@ -160,7 +160,8 @@ export const grepTool = {
     name: 'grep',
     description: 'Search file contents by regex (recursive; powered by ripgrep: respects .gitignore, skips binaries).\n' +
         'Output: per-file header "<path>: N matches, lines [l1, l2, ...]" plus rendered lines with ORIGINAL INDENTATION kept.\n' +
-        'Pass context=2..5 to include neighbouring lines inline (like ripgrep -C) instead of following each hit with a read_file round-trip. Hard wall 120s; narrow the glob if a tree contains network mounts. Use read_file when you need a whole region or exact edit text.',
+        'Pass context=2..5 to include neighbouring lines inline (like ripgrep -C) instead of following each hit with a read_file round-trip. Hard wall 120s; narrow the glob if a tree contains network mounts. Use read_file when you need a whole region or exact edit text.\n' +
+        'Note: .mocode/ is gitignored; to search session data (e.g. .mocode/sessions/<id>/compacted archived history) you MUST narrow glob to that path, e.g. glob=".mocode/sessions/**".',
     parameters: {
         type: 'object',
         properties: {
@@ -200,7 +201,9 @@ export const grepTool = {
             controller.abort();
         }, GREP_TIMEOUT_MS);
         try {
-            const result = await runRipgrep({ pattern, glob, context }, controller.signal);
+            // glob 显式限定到 .mocode(gitignore 内)时放开 VCS ignore,否则 rg 零文件退出。
+            const noIgnoreVcs = glob === '.mocode/**' || glob.startsWith('.mocode/');
+            const result = await runRipgrep({ pattern, glob, context, noIgnoreVcs }, controller.signal);
             switch (result.status) {
                 case 'regex_error':
                     return `错误:非法正则 ${pattern}: ${result.message}`;

package/dist/tools/builtins/memory-graph.js

@@ -1,4 +1,5 @@
 import { addTriple, graphStats, neighborsOf, pathBetween } from '../../memory/graph.js';
+import { formatRecallStats } from '../../memory/recall-stats.js';
 // ---------- memory_graph ----------
 // 知识图谱维护工具:邻居遍历(1-3 跳,可 relation 过滤)、两点最短路径、手工加三元组、看图统计。
 // 关键词搜索已并入 memory_search(条目 + 图谱事实一次返回),本工具不再提供 search。
@@ -55,6 +56,7 @@ export const memoryGraphTool = {
                 `实体 ${s.entities} 条边(active ${s.edgesActive} / 已失效 ${s.edgesInvalid})`,
                 `project: ${s.byScope.project.entities} 实体, ${s.byScope.project.edges} 边`,
                 `global:  ${s.byScope.global.entities} 实体, ${s.byScope.global.edges} 边`,
+                formatRecallStats(),
             ].join('\n');
         }
         if (action === 'neighbors') {

package/dist/tools/builtins/memory-search.js

@@ -1,13 +1,14 @@
 import { searchEntries } from '../../memory/store.js';
-import { searchGraph } from '../../memory/graph.js';
+import { searchGraphFacts } from '../../memory/graph.js';
+import { recordRecallSearch } from '../../memory/recall-stats.js';
 // ---------- memory_search ----------
 // 唯一记忆搜索入口:关键词搜记忆正文(多词子串匹配,name 权重最高)+ 知识图谱事实段
-// (命中实体的 active 边)。命中条目即 bump recallCount(遗忘衰减依据)。
-// 结果走 capToolResultForHistory 的放宽上限(同 use_skill,保正文完整)。
+// (CJK 分词加权、边级相关度 + 一跳邻接,跨 global/project 两 scope)。命中条目即 bump
+// recallCount(遗忘衰减依据)。结果走 capToolResultForHistory 的放宽上限(同 use_skill)。
 const GRAPH_FACTS_LIMIT = 10;
 export const memorySearchTool = {
     name: 'memory_search',
-    description: 'Search memory entries by keyword (substring match), returning full body. Also surfaces knowledge-graph facts (active edges) for entities matching the query.',
+    description: 'Search memory entries by keyword (substring match), returning full body. Also surfaces knowledge-graph facts (active edges across project + global), ranked by CJK-aware term overlap on entity names/aliases/relation/fact, plus one-hop neighbor edges for context.',
     parameters: {
         type: 'object',
         properties: {
@@ -37,23 +38,28 @@ export const memorySearchTool = {
         const entryText = r
             .map((e) => `# [${e.id}] ${e.name} (${e.type}, recalled ${e.recallCount})\nsummary: ${e.summary}\n\n${e.body}`)
             .join('\n\n---\n\n');
-        // 知识图谱事实段:命中实体的 active 边(容错:图坏了不连累条目搜索)。
+        // 知识图谱事实段:边级相关度检索(容错:图坏了不连累条目搜索)。
         let graphText = '';
+        let graphHit = false;
         try {
-            const g = searchGraph(query, 8);
-            if (g.edges.length > 0) {
-                const lines = g.edges
-                    .slice(0, GRAPH_FACTS_LIMIT)
-                    .map((e) => `${e.src} --[${e.relation}]--> ${e.dst}${e.fact ? ` (${e.fact})` : ''}`);
-                const more = g.edges.length > GRAPH_FACTS_LIMIT
-                    ? `\n…(共 ${g.edges.length} 条,其余用 memory_graph action=neighbors 展开)`
-                    : '';
-                graphText = `\n\n## 知识图谱事实\n${lines.join('\n')}${more}`;
+            const hits = searchGraphFacts(query, { scope: 'all', limit: GRAPH_FACTS_LIMIT, neighbors: 4 });
+            graphHit = hits.length > 0;
+            if (graphHit) {
+                const lines = hits.map((h) => {
+                    const src = h.srcEntity?.name ?? h.edge.src;
+                    const dst = h.dstEntity?.name ?? h.edge.dst;
+                    const fact = h.edge.fact ? ` (${h.edge.fact})` : '';
+                    const tag = h.viaNeighbor ? ' [neighbor]' : '';
+                    const scopeTag = h.edge.scope === 'global' ? '[global]' : '[project]';
+                    return `${scopeTag} ${src} --[${h.edge.relation}]--> ${dst}${fact}${tag}`;
+                });
+                graphText = `\n\n## 知识图谱事实\n${lines.join('\n')}`;
             }
         }
         catch {
             // 静默:图谱段是增强,失败只降级为纯条目结果
         }
+        recordRecallSearch(graphHit); // 埋点:pull 召回使用情况(写盘失败静默)
         if (!entryText && !graphText)
             return `(无匹配记忆:query="${query}")`;
         if (!entryText)

package/dist/tools/builtins/write-file.js

@@ -28,8 +28,10 @@ function invalid(path, message) {
 }
 export const writeFileTool = {
     name: 'write_file',
-    description: 'Create or replace one file transactionally. expected_hash may be omitted (or null) only for create-only writes to a path that must not exist; overwriting requires the hash from a fresh read_file.\n' +
-        'To ADD to an existing file, pass append=true — only the new text goes in `content`; NO expected_hash and NO prior read_file needed (lock-protected; creates the file when missing). Appends VERBATIM: if the file does not end with a newline, start your content with "\\n" or the last line will merge with yours.',
+    description: 'Create a NEW file, APPEND to one, or rewrite essentially the WHOLE file — transactionally.\n' +
+        'Do NOT use this for localized changes to an existing file, even when there are several separate changes: use edit_file (a single edit, one replacements[] batch covering many spots, or a line range). Re-sending an entire file just to tweak a few lines wastes tokens and the long JSON is prone to truncation. Reach for write_file on an existing path only when most of the file is actually being replaced.\n' +
+        'expected_hash may be omitted (or null) only for create-only writes to a path that must not exist; overwriting requires the hash from a fresh read_file.\n' +
+        'To ADD to an existing file, pass append=true — only the new text goes in `content`; NO expected_hash and NO prior read_file needed (lock-protected; creates the file when missing). For long generated output, write the first chunk normally then extend it with repeated append=true calls, keeping each call small. Appends VERBATIM: if the file does not end with a newline, start your content with "\\n" or the last line will merge with yours.',
     risk: 'confirm',
     parameters: {
         type: 'object',

package/dist/tools/constants.js

@@ -29,6 +29,10 @@ export const MAX_OLD_TOOL_STUB = 600;
 export const MAX_TRACE_BYTES = 512 * 1024;
 /** 保留的历史 trace 轮转份数(trace.1 .. trace.N),更老的硬删。 */
 export const MAX_TRACE_ROTATIONS = 3;
+/** compacted/ 压缩归档目录总量上限(字节):旧区原文逐段累积,超了从最老 seg 淘汰。
+ *  段大小与窗口正相关(200k 窗口单段约几百 KB),10MiB 约覆盖十几~几十次压缩。
+ *  可用 MOCODE_MAX_COMPACTED_BYTES 覆盖(测试/小盘用)。 */
+export const MAX_COMPACTED_ARCHIVE_BYTES = 10 * 1024 * 1024;
 /** rollback snapshots 压缩前滚动窗口:无论是否 compact,仅保留最近 N 个 user turn 的快照。 */
 export const MAX_SNAPSHOT_TURNS = 50;
 // ── 上下文压缩摘要(见 session/compact.ts defaultSummarize)────────────────

package/dist/tools/ripgrep-client.js

@@ -69,6 +69,9 @@ export function runRipgrep(params, signal) {
     // --no-require-git:rg 默认只在 git 仓库内才读 .gitignore;加上后非 git 项目的 .gitignore
     // 同样生效(实测不加时 ignored/ 会被扫到)。
     const args = ['--json', '--hidden', '--no-require-git', '--path-separator', '/'];
+    // glob 显式指向 gitignore 内的 .mocode(回捞压缩归档等)时放开 VCS ignore。
+    if (params.noIgnoreVcs)
+        args.push('--no-ignore-vcs');
     if (params.context > 0)
         args.push('-C', String(params.context));
     if (params.glob && params.glob !== '**/*')
@@ -169,7 +172,14 @@ export function runRipgrep(params, signal) {
                 handleLine(buffer.trim());
             // exit 2 + stderr = 正则/参数错误;无命中事件时按 regex_error 上报。
             if (code === 2 && byPath.size === 0 && stderr.trim()) {
-                finish({ status: 'regex_error', message: stderr.trim() });
+                const message = stderr.trim();
+                // 过滤器把所有文件排除(典型:glob 指向 .gitignore 内的 .mocode 却没放开 ignore)
+                // 不是正则错误——按无匹配处理,避免误导模型去改 pattern。
+                if (/No files were searched/i.test(message)) {
+                    finish({ status: 'no-match', scanned, truncated });
+                    return;
+                }
+                finish({ status: 'regex_error', message });
                 return;
             }
             if (byPath.size === 0) {

package/dist/tools/tool-runtime.js

@@ -8,6 +8,67 @@ const DEFAULT_CAPABILITIES = Object.freeze({
     effect: 'unknown',
     concurrency: 'serial',
 });
+/** 长非法 JSON 回显时首尾各保留的字符数(尾部对判断截断最关键)。 */
+const INVALID_JSON_SNIPPET = 150;
+/** 按工具给出参数损坏后的可执行恢复路径。truncated=已确认输出被 token 上限截断。 */
+function invalidJsonRecovery(name, truncated) {
+    if (truncated) {
+        if (name === 'write_file') {
+            return ('恢复方法(不要用相同参数重试):\n' +
+                '1) write_file 只写入首块内容,再用 write_file(append=true, content=…) 分多次续写,每段保持短小;\n' +
+                '2) 若只是修改已有文件的局部,改用 edit_file(只发 old_string/new_string,不要整篇重发);\n' +
+                '3) 确需一次生成,调大 MAX_TOKENS 后再试。');
+        }
+        if (name === 'edit_file') {
+            return '恢复方法:参数在 token 上限处被截断。缩短 old_string(只保留唯一命中所需的最小上下文),或调大 MAX_TOKENS 后再试。';
+        }
+        return '恢复方法:参数在 token 上限处被截断。把本次调用拆成更小的多个调用,或调大 MAX_TOKENS 后再试。';
+    }
+    if (name === 'write_file' || name === 'edit_file') {
+        return ('恢复方法:JSON 字符串值里的换行必须转义为 \\n、双引号转义为 \\"、反斜杠转义为 \\\\,不要在字符串中放裸换行。\n' +
+            '长内容优先 write_file 首块 + append=true 分段,或改用 edit_file 做局部替换。');
+    }
+    return '恢复方法:检查参数 JSON 的引号、反斜杠与换行转义后重试。';
+}
+/** 把 JSON.parse 的 SyntaxError 映射成可操作的中文死因。 */
+function classifyJsonSyntaxError(message, knownTruncated) {
+    if (knownTruncated) {
+        return '死因:模型输出在 max_tokens 处被硬截断,tool_call 参数是不完整的 JSON(没有正常结尾)。';
+    }
+    if (/unterminated string/i.test(message)) {
+        return '死因:字符串未正常结束(Unterminated string)——参数可能在末尾被截断,或内容里的引号未转义。';
+    }
+    if (/bad control character|bad escaped/i.test(message)) {
+        return '死因:字符串值里出现了裸控制字符(最常见是裸换行)——JSON 字符串内换行必须写成 \\n。';
+    }
+    if (/unexpected token/i.test(message)) {
+        return '死因:出现非法字符(Unexpected token)——多为内容中的双引号/反斜杠没有转义,或参数被截断。';
+    }
+    if (/expected|end of (data|json)|unexpected end/i.test(message)) {
+        return '死因:JSON 提前结束或结构残缺——参数可能被截断。';
+    }
+    return `死因:${message}`;
+}
+/** argsRaw 的安全摘要:短则全量,长则只给长度+首尾片段,避免几万字符刷屏且被 TUI 二次截断。 */
+function summarizeRawArgs(argsRaw) {
+    const len = argsRaw.length;
+    if (len <= INVALID_JSON_SNIPPET * 2 + 40)
+        return argsRaw;
+    const head = argsRaw.slice(0, INVALID_JSON_SNIPPET);
+    const tail = argsRaw.slice(len - INVALID_JSON_SNIPPET);
+    return `${head}\n…[中间省略 ${len - INVALID_JSON_SNIPPET * 2} 字符]…\n${tail}`;
+}
+function invalidJsonOutcome(name, argsRaw, parseError, opts, startedAt) {
+    const syntaxMessage = parseError instanceof Error ? parseError.message : String(parseError);
+    const knownTruncated = opts?.finishReason === 'length';
+    const looksTruncated = /end of (data|json)|unexpected end/i.test(syntaxMessage);
+    const output = `错误:工具 ${name} 的 arguments 不是合法 JSON(收到 ${argsRaw.length} 字符)。\n` +
+        `${classifyJsonSyntaxError(syntaxMessage, knownTruncated)}\n` +
+        `${invalidJsonRecovery(name, knownTruncated || looksTruncated)}\n` +
+        `解析器报错:${syntaxMessage}\n` +
+        `参数片段(首/尾):\n${summarizeRawArgs(argsRaw)}`;
+    return terminalOutcome('error', 'INVALID_JSON', output, startedAt);
+}
 const DEFAULT_DEPENDENCIES = {
     enforceSandbox: defaultEnforceSandbox,
     resolveResourceLockRequests: defaultResolveResourceLockRequests,
@@ -194,8 +255,10 @@ export class ToolRuntime {
         try {
             parsed = argsRaw.trim() ? JSON.parse(argsRaw) : {};
         }
-        catch {
-            return terminalOutcome('error', 'INVALID_JSON', t('toolError.invalidJson', { name, arguments: argsRaw }), startedAt);
+        catch (parseError) {
+            // 不再裸 catch:保留 SyntaxError 的具体死因(截断 vs 裸换行 vs 漏转义),
+            // 并结合 finish_reason=length 给出可执行恢复路径,替代旧的整段 argsRaw 刷屏。
+            return invalidJsonOutcome(name, argsRaw, parseError, opts, startedAt);
         }
         const validation = validateToolArguments(tool, parsed);
         if (!validation.valid) {

package/dist/ui/diff.js

@@ -295,9 +295,16 @@ export function renderFileChange(opts) {
     const padW = Math.max(3, String(startLine + Math.max(oldLen, newLen) - 1).length);
     return renderBody(head, counts, compactCtx(ops), padW, startLine, lang);
 }
-/** 头行 + 计数行 + 正文(折叠 + 截断 + 行号),每行尾 \n。 */
-function renderBody(head, counts, items, padW, startLine, lang) {
-    const lines = [head, counts];
+/** Update(path) 头行(edit / 多 hunk 共用)。 */
+function updateHead(pathDisp) {
+    return `${HEAD_INDENT}${ui.bold}${ui.accent}Update${ui.reset}${ui.gray}(${ui.reset}${ui.accent}${pathDisp}${ui.reset}${ui.gray})${ui.reset}`;
+}
+/**
+ * 单个 hunk 的正文行(折叠 + 截断 + 行号),不含头/计数行。
+ * 多替换模式对每个 {old_string,new_string} 各调一次,行号从该 hunk 的 startLine 独立起算。
+ */
+function renderHunkBody(items, padW, startLine, lang) {
+    const lines = [];
     const metaPrefix = `${BODY_INDENT}`; // 与正文行左对齐(batch 展开时还会再加外层 indent,避免双重缩进导致提示行突兀)
     let oldLine = startLine;
     let newLine = startLine;
@@ -365,5 +372,62 @@ function renderBody(head, counts, items, padW, startLine, lang) {
     if (overflow > 0) {
         lines.push(`${metaPrefix}${ui.dim}…(还有 ${overflow} 行未显示)${ui.reset}`);
     }
-    return lines.join('\n') + '\n';
+    return lines;
+}
+/** 单 hunk:头行 + 计数行 + 正文。 */
+function renderBody(head, counts, items, padW, startLine, lang) {
+    return [head, counts, ...renderHunkBody(items, padW, startLine, lang)].join('\n') + '\n';
+}
+/** 单个 hunk 的增删行计数。 */
+function countOps(ops) {
+    let add = 0;
+    let del = 0;
+    for (const o of ops) {
+        if (o.op === 'add')
+            add++;
+        else if (o.op === 'del')
+            del++;
+    }
+    return { add, del };
+}
+function countsLine(add, del) {
+    const parts = [];
+    if (add > 0)
+        parts.push(`${ui.dim}Added ${ui.reset}${ui.green}${add}${ui.reset}${ui.dim} ${lineWord(add)}`);
+    if (del > 0)
+        parts.push(`${ui.dim}removed ${ui.reset}${ui.red}${del}${ui.reset}${ui.dim} ${lineWord(del)}`);
+    return parts.length > 0
+        ? `${HEAD_INDENT}  ${parts.join(`${ui.dim}, ${ui.reset}`)}${ui.reset}`
+        : `${HEAD_INDENT}  ${ui.dim}No changes${ui.reset}`;
+}
+/**
+ * 多替换模式:一个文件里多个互不相邻的 hunk,共用一个 Update(path) 头,
+ * 每个 hunk 独立行号(由 readDiffContext 在原文定位其起始行)。
+ * 任一 hunk 过大无法做 LCS 时返回 null,调用方退回摘要展示(与 renderFileChange 同策略)。
+ */
+export function renderMultiFileChange(opts) {
+    const lang = langForPath(opts.path);
+    const head = updateHead(opts.path);
+    const prepared = [];
+    let totalAdd = 0;
+    let totalDel = 0;
+    let maxLineNo = 1;
+    for (const h of opts.hunks) {
+        const ops = lineDiff(h.oldStr, h.newStr);
+        if (ops === null)
+            return null;
+        const { add, del } = countOps(ops);
+        totalAdd += add;
+        totalDel += del;
+        maxLineNo = Math.max(maxLineNo, h.startLine + Math.max(splitLines(h.oldStr).length, splitLines(h.newStr).length) - 1);
+        prepared.push({ ops, startLine: h.startLine, padW: 0 });
+    }
+    const padW = Math.max(3, String(maxLineNo).length);
+    const out = [head, countsLine(totalAdd, totalDel)];
+    prepared.forEach((p, idx) => {
+        if (idx > 0)
+            out.push(`${BODY_INDENT}${ui.dim}@@${ui.reset}`);
+        out.push(...renderHunkBody(compactCtx(p.ops), padW, p.startLine, lang));
+    });
+    return out.join('\n') + '\n';
 }

package/package.json

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