mocode-ai 1.7.11 → 1.8.0

package/dist/agent/index.js

@@ -5,7 +5,7 @@
 import { ui } from '../ui/theme.js';
 import { Spinner } from '../ui/spinner.js';
 import { summarizeToolCall, summarizeToolResult, truncateDisplay, fmtElapsed } from '../ui/render.js';
-import { renderFileChange } from '../ui/diff.js';
+import { renderFileChange, renderMultiFileChange } from '../ui/diff.js';
 import * as layout from '../ui/layout.js';
 import * as batch from '../ui/batch.js';
 import { config } from '../config/index.js';
@@ -150,7 +150,7 @@ function writeToolHeader(tc, toolRuntime) {
 }
 /** 渲染工具结果:mutation 成功走 diff 块(行号 + 语法高亮);其余走一行 preview。
  *  同 writeToolHeader,改为累积到 BatchRenderer(只缓存字符串,不写屏)。 */
-function writeToolResult(tc, output, parsed, preWriteOld, editStartLine, toolRuntime) {
+function writeToolResult(tc, output, parsed, preWriteOld, editStartLine, toolRuntime, multiHunks) {
     // 优先按 tool_call id 反查所属批（并行 / sub-agent 组时 currentBatchId 已不是它）。
     const batchId = batch.batchIdForCall(tc.id) ?? currentBatchId;
     if (!batchId)
@@ -173,19 +173,55 @@ function writeToolResult(tc, output, parsed, preWriteOld, editStartLine, toolRun
     }
     let diff = null;
     if ((tc.name === 'edit_file' || tc.name === 'write_file') && parsed && !isToolErrorOutput(output)) {
-        const oldText = tc.name === 'edit_file' ? String(parsed.old_string ?? '') : preWriteOld;
-        const newText = String((tc.name === 'edit_file' ? parsed.new_string : parsed.content) ?? '');
-        diff = renderFileChange({
-            path: String(parsed.path ?? ''),
-            kind: tc.name === 'edit_file' ? 'edit' : 'write',
-            oldStr: tc.name === 'edit_file' ? String(parsed.old_string ?? '') : preWriteOld,
-            newStr: String((tc.name === 'edit_file' ? parsed.new_string : parsed.content) ?? ''),
-            startLine: tc.name === 'edit_file' ? editStartLine : 1,
-        });
+        const filePath = String(parsed.path ?? '');
+        const isEdit = tc.name === 'edit_file';
+        // 多替换模式:每个 old/new 段一个 hunk,渲染成一个 Update 块内的多个 hunk。
+        const multi = isEdit && multiHunks && multiHunks.length > 0 ? multiHunks : null;
+        const oldText = isEdit
+            ? multi
+                ? multi.map((h) => h.oldStr).join('\n')
+                : String(parsed.old_string ?? '')
+            : preWriteOld;
+        const newText = isEdit
+            ? multi
+                ? multi.map((h) => h.newStr).join('\n')
+                : String(parsed.new_string ?? '')
+            : String(parsed.content ?? '');
+        if (multi) {
+            diff = renderMultiFileChange({
+                path: filePath,
+                hunks: multi.map((h) => ({ oldStr: h.oldStr, newStr: h.newStr, startLine: h.startLine })),
+            });
+            // 渲染器对超大 diff 返回 null(无法做 LCS)时退回工具结果摘要。
+            if (!diff)
+                diff = renderFileChange({
+                    path: filePath,
+                    kind: 'edit',
+                    oldStr: oldText,
+                    newStr: newText,
+                    startLine: editStartLine,
+                });
+        }
+        else {
+            diff = renderFileChange({
+                path: filePath,
+                kind: isEdit ? 'edit' : 'write',
+                oldStr: isEdit ? String(parsed.old_string ?? '') : preWriteOld,
+                newStr: String((isEdit ? parsed.new_string : parsed.content) ?? ''),
+                startLine: isEdit ? editStartLine : 1,
+            });
+        }
+        // 回合改动统计:多替换按各 hunk 独立计算后累加(拼接不相邻段再 diff 会把跨段行误算成增删)。
+        const delta = multi
+            ? multi.reduce((acc, h) => {
+                const d = lineDelta(h.oldStr, h.newStr);
+                return { added: acc.added + d.added, removed: acc.removed + d.removed };
+            }, { added: 0, removed: 0 })
+            : lineDelta(oldText, newText);
         turnFileChanges.push({
-            path: String(parsed.path ?? ''),
+            path: filePath,
             kind: tc.name === 'write_file' && preWriteOld == null ? 'A' : 'M',
-            ...lineDelta(oldText, newText),
+            ...delta,
         });
     }
     const preview = diff ? '' : summarizeToolResult(tc.name, output);
@@ -406,7 +442,7 @@ runtimeOrContext = defaultRuntime) {
         onToolStart: (name) => spinner.start(t('agent.executing', { tool: name })),
         onToolOutput: (tc, chunk) => batch.recordOutput(tc.id, chunk, layout),
         onToolDone: () => spinner.stop(),
-        onToolResult: (tc, output, parsed, preWriteOld, editStartLine) => writeToolResult(tc, output, parsed, preWriteOld, editStartLine, runtime.context.toolRuntime),
+        onToolResult: (tc, output, parsed, preWriteOld, editStartLine, multiHunks) => writeToolResult(tc, output, parsed, preWriteOld, editStartLine, runtime.context.toolRuntime, multiHunks),
         onToolBatchEnd: () => {
             // 一次工具轮次结束不再切 UI batch；下一轮若仍无正文，继续复用 currentBatchId。
         },

package/dist/agent/run-coordinator.js

@@ -290,7 +290,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                             break;
                                         }
                                         case 'result':
-                                            hooks.onToolResult?.(event.call, event.outcome.output, event.parsed, event.diff.preWriteOld, event.diff.editStartLine);
+                                            hooks.onToolResult?.(event.call, event.outcome.output, event.parsed, event.diff.preWriteOld, event.diff.editStartLine, event.diff.multiHunks);
                                             if (event.call.name === 'ask_human' && event.outcome.status === 'success') {
                                                 askHumanCountThisTurn += 1;
                                                 emitTrace('ask_human_call', {
@@ -326,6 +326,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                     delegation: delegationForOrchestrator,
                                     readDedup,
                                     argumentErrorHint: (name) => argumentErrorHint(name, runtimeContextState),
+                                    ...(result.finishReason ? { finishReason: result.finishReason } : {}),
                                     onToolOutput: (call, chunk) => hooks.onToolOutput?.(call, chunk),
                                     ...(opts.toolPolicy
                                         ? {
@@ -401,6 +402,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                                 allowedToolNames: currentAllowedToolNames(),
                                                 delegation: delegationForOrchestrator(),
                                                 readDedup,
+                                                ...(result.finishReason ? { finishReason: result.finishReason } : {}),
                                             });
                                         }
                                     }
@@ -572,6 +574,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                             allowedToolNames: currentAllowedToolNames(),
                                             delegation: delegationForOrchestrator(),
                                             readDedup,
+                                            ...(result.finishReason ? { finishReason: result.finishReason } : {}),
                                         }));
                                         // 完成即发:usage/onToolOutcome/trace 在各 outcome 落地瞬间发出(1s 的
                                         // grep 不再被 60s 的 web_fetch 卡住可见性);history 回灌严格按原序。
@@ -671,6 +674,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                                         delegation: delegationForOrchestrator(),
                                                         readDedup,
                                                         ...(hint ? { argumentErrorHint: hint } : {}),
+                                                        ...(result.finishReason ? { finishReason: result.finishReason } : {}),
                                                         onLockAcquired: (lockedArgs) => {
                                                             entry.diff = readDiffContext(entry.tc, lockedArgs, ctx.jailResolve);
                                                         },
@@ -685,7 +689,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                         for (let offset = 0; offset < entries.length; offset++) {
                                             const entry = entries[offset];
                                             const outcome = await outcomes[offset];
-                                            hooks.onToolResult?.(entry.tc, outcome.output, entry.denied ? null : entry.parsed, entry.diff.preWriteOld, entry.diff.editStartLine);
+                                            hooks.onToolResult?.(entry.tc, outcome.output, entry.denied ? null : entry.parsed, entry.diff.preWriteOld, entry.diff.editStartLine, entry.diff.multiHunks);
                                             pushToolResult(history, entry.tc, outcome.output, relprune, lifecycle, scheduler, runtimeContextState, outcome.status === 'success');
                                             const invalidatedFiles = [
                                                 ...new Set([...(outcome.changedFiles ?? []), ...(outcome.staleFiles ?? [])]),
@@ -760,6 +764,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                                 delegation: delegationForOrchestrator(),
                                                 readDedup,
                                                 ...(hint ? { argumentErrorHint: hint } : {}),
+                                                ...(result.finishReason ? { finishReason: result.finishReason } : {}),
                                                 onLockAcquired: (lockedArgs) => {
                                                     entry.diff = readDiffContext(entry.tc, lockedArgs, ctx.jailResolve);
                                                 },
@@ -776,7 +781,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                         for (let k = 0; k < entries.length; k++) {
                                             const entry = entries[k];
                                             const outcome = await started[k];
-                                            hooks.onToolResult?.(entry.tc, outcome.output, entry.denied ? null : entry.parsed, entry.diff.preWriteOld, entry.diff.editStartLine);
+                                            hooks.onToolResult?.(entry.tc, outcome.output, entry.denied ? null : entry.parsed, entry.diff.preWriteOld, entry.diff.editStartLine, entry.diff.multiHunks);
                                             pushToolResult(history, entry.tc, outcome.output, relprune, lifecycle, scheduler, runtimeContextState, outcome.status === 'success');
                                             const invalidatedFiles = [
                                                 ...new Set([...(outcome.changedFiles ?? []), ...(outcome.staleFiles ?? [])]),
@@ -856,6 +861,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                             delegation: delegationForOrchestrator(),
                                             readDedup,
                                             ...(serialHint ? { argumentErrorHint: serialHint } : {}),
+                                            ...(result.finishReason ? { finishReason: result.finishReason } : {}),
                                             onLockAcquired: (lockedArgs) => {
                                                 if (mutationParsed)
                                                     diff = readDiffContext(tc, lockedArgs, ctx.jailResolve);
@@ -866,7 +872,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                         traceToolEnd(tc, i, outcome);
                                         const output = outcome.output;
                                         hooks.onToolDone?.();
-                                        hooks.onToolResult?.(tc, output, mutationParsed, diff.preWriteOld, diff.editStartLine);
+                                        hooks.onToolResult?.(tc, output, mutationParsed, diff.preWriteOld, diff.editStartLine, diff.multiHunks);
                                         if (tc.name === 'ask_human' && outcome.status === 'success') {
                                             askHumanCountThisTurn += 1;
                                             emitTrace('ask_human_call', {

package/dist/agent/stages/tool-dispatcher.js

@@ -49,6 +49,7 @@ class LegacyCompatibleToolDispatcher {
             delegation: request.delegation(),
             readDedup: request.readDedup,
             ...(hint ? { argumentErrorHint: hint } : {}),
+            ...(request.finishReason ? { finishReason: request.finishReason } : {}),
             ...(onLockAcquired ? { onLockAcquired } : {}),
         });
         const executionEvents = (index, parsed, outcome) => {

package/dist/agent/tool-helpers.js

@@ -128,31 +128,59 @@ export function unregisteredToolOutcome(name, toolRuntime) {
 /** mutation 执行前读旧内容供 diff:write_file 取整文件旧内容(不存在→null=新建),
  * edit_file 取 old_string 起始行号(供 diff 显示真实文件行号)。读不到则 diff 退化为相对行号。
  * 非 mutation 或参数非法返 { preWriteOld: null, editStartLine: 1 }。失败不阻断。 */
+const toLf = (s) => s.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
 export function readDiffContext(tc, parsed, resolvePath = jailResolve) {
+    const empty = { preWriteOld: null, editStartLine: 1 };
     if (!parsed)
-        return { preWriteOld: null, editStartLine: 1 };
+        return empty;
     const p = String(parsed.path ?? '');
     if (!p)
-        return { preWriteOld: null, editStartLine: 1 };
+        return empty;
     if (tc.name === 'write_file') {
         try {
             // jailResolve:沙箱越界(../../、绝对外圈、软链出圈)抛错 → catch 兜底返 null,不泄露牢外内容(TOCTOU)
             return { preWriteOld: readFileSync(resolvePath(p), 'utf8'), editStartLine: 1 };
         }
         catch {
-            return { preWriteOld: null, editStartLine: 1 }; // 文件不存在(新建)、不可读 或 沙箱越界(不泄露)
+            return empty; // 文件不存在(新建)、不可读 或 沙箱越界(不泄露)
         }
     }
     if (tc.name === 'edit_file') {
         // 行尾归一化:LLM 生成的 old_string 用 LF(\n),但 Windows 文件可能是 CRLF(\r\n),
         // 不统一则 indexOf 必败、editStartLine 恒为 1。与 edit-file.ts 保持一致归一化为 LF。
-        const oldStr = String(parsed.old_string ?? '')
-            .replace(/\r\n/g, '\n')
-            .replace(/\r/g, '\n');
+        const replacements = Array.isArray(parsed.replacements) ? parsed.replacements : null;
         try {
             // jailResolve:同上,沙箱越界抛错 → catch 兜底,不泄露牢外内容
             const raw = readFileSync(resolvePath(p), 'utf8');
-            const data = raw.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+            const data = toLf(raw);
+            // 多替换模式:在「编辑前」的原文上为每个 old_string 定位唯一命中的起始行,
+            // 供多 hunk diff 显示真实文件行号。任一项非唯一/找不到就不带 hunk(退回工具结果摘要),
+            // 真正的原子校验仍以 edit-file.ts execute 为准,这里只做展示、失败不阻断。
+            if (replacements) {
+                const hunks = [];
+                for (const item of replacements) {
+                    if (!item || typeof item !== 'object')
+                        return empty;
+                    const rec = item;
+                    if (typeof rec.old_string !== 'string' || typeof rec.new_string !== 'string')
+                        return empty;
+                    const oldStr = toLf(rec.old_string);
+                    if (!oldStr)
+                        return empty;
+                    const first = data.indexOf(oldStr);
+                    if (first < 0 || data.indexOf(oldStr, first + oldStr.length) !== -1)
+                        return empty;
+                    hunks.push({
+                        oldStr: rec.old_string,
+                        newStr: rec.new_string,
+                        startLine: data.slice(0, first).split('\n').length,
+                    });
+                }
+                if (hunks.length === 0)
+                    return empty;
+                return { preWriteOld: null, editStartLine: hunks[0].startLine, multiHunks: hunks };
+            }
+            const oldStr = toLf(String(parsed.old_string ?? ''));
             const idx = oldStr ? data.indexOf(oldStr) : -1;
             return {
                 preWriteOld: null,
@@ -160,10 +188,10 @@ export function readDiffContext(tc, parsed, resolvePath = jailResolve) {
             };
         }
         catch {
-            return { preWriteOld: null, editStartLine: 1 }; // 读不到:diff 退化为相对行号(含沙箱越界)
+            return empty; // 读不到:diff 退化为相对行号(含沙箱越界)
         }
     }
-    return { preWriteOld: null, editStartLine: 1 };
+    return empty;
 }
 /** 回灌 tool 结果到 history。
  *  正常路径只做单条 hard cap;原始 output 同时供 TUI 展示,因此用户与模型

package/dist/config/file.js

@@ -22,11 +22,19 @@ export function readConfigFile() {
 }
 /**
  * 读-合并-写:把 entries 覆盖进 ~/.mocode/config,保留文件里其它键。
- * mkdirSync 兜底(首跑无 ~/.mocode)。不吞 I/O 异常——向导路径让其抛(与历史行为一致);
- * UI 偏好路径用 `updateConfigKey`(自带 try/catch 静默)。
+ * 值为 null 表示从配置文件删除该键(用于切到「不带某可选值」的预设时清除残留,
+ * 否则旧值会一直盖过新预设)。mkdirSync 兜底(首跑无 ~/.mocode)。不吞 I/O 异常——
+ * 向导路径让其抛(与历史行为一致);UI 偏好路径用 `updateConfigKey`(自带 try/catch 静默)。
  */
 export function writeConfigKeys(entries) {
-    const merged = { ...readConfigFile(), ...entries };
+    const existing = readConfigFile();
+    const merged = { ...existing };
+    for (const [k, v] of Object.entries(entries)) {
+        if (v === null)
+            delete merged[k];
+        else
+            merged[k] = v;
+    }
     const body = Object.entries(merged)
         .map(([k, v]) => `${k}=${v}`)
         .join('\n');

package/dist/config/index.js

@@ -57,6 +57,7 @@ const LLM_ENV_KEYS = [
     'LLM_API_KEY',
     'LLM_MODEL',
     'CONTEXT_WINDOW_TOKENS',
+    'MAX_TOKENS',
     'ANTHROPIC_PROMPT_CACHE',
     'REASONING_EFFORT',
 ];
@@ -485,7 +486,7 @@ ${buildWorkDisciplineSection(inferModelFamily(config.model))}
 - Silent Execution: invoke tools directly without preamble. Output visible text ONLY for the final answer and critical mid-task findings. Strictly no step-by-step narration (no "let me…", "让我先…", "now checking…" between calls).
 - Go directly to a known path or symbol; use discovery tools only when the location is unknown.
 - Edit against a FRESH read: before editing, call read_file on the exact path and copy the exact target text. Never reconstruct old_string from a grep/summary/diff — those lose whitespace and indentation and cause edit failures.
-- Pick the right file tool: use edit_file for partial changes to an existing file (expected_hash is OPTIONAL in old_string mode, REQUIRED in line-range mode); use write_file only to create a file, to rewrite most of a file (replacing needs the latest read_file hash), or to append (append=true needs no read_file and no hash). Never write a throwaway script (tmp_patch*.cjs, fix_*.py, ...) to modify source files: scripts run outside ChangeSet tracking, so rollback and diff cannot see them.
+- Pick the right file tool: for an EXISTING file, DEFAULT to edit_file — one old_string for a single change, replacements[] for many separate changes in one atomic call, or a line range for a big block. Do NOT overwrite an existing file with write_file just to tweak parts of it (re-sending the whole file wastes tokens and its long JSON is truncation-prone). Use write_file only to create a new file, to append (append=true needs no read_file and no hash), or to rewrite essentially the WHOLE file (a full rewrite needs the latest read_file hash). expected_hash is OPTIONAL in edit_file old_string/replacements mode, REQUIRED in line-range mode. Never write a throwaway script (tmp_patch*.cjs, fix_*.py, ...) to modify source files: scripts run outside ChangeSet tracking, so rollback and diff cannot see them.
 - A read_file hash from before a compaction, session resume, edit conflict, or external change is STALE and will be rejected if you pass it. In edit_file old_string mode just omit expected_hash; otherwise re-read rather than reuse an old hash.
 - Emit multiple independent tool calls in ONE assistant message so they run concurrently — e.g. several read_file regions, a grep plus a glob, or several web_fetch calls. One lookup per message wastes a full model round-trip each time. Place parallel-safe calls consecutively; keep any call that depends on their results (e.g. an edit) for the next message.
 - Never batch a read with an edit that depends on it; do not repeat overlapping reads or unchanged failed calls.
@@ -581,7 +582,8 @@ export const config = {
     model: llmKeysFromShell.includes('LLM_MODEL')
         ? process.env.LLM_MODEL || 'gpt-4o-mini'
         : (__activePreset?.model ?? process.env.LLM_MODEL ?? 'gpt-4o-mini'),
-    maxTokens: process.env.MAX_TOKENS ? Number(process.env.MAX_TOKENS) : undefined,
+    // 优先级:shell env > 激活预设(目录添加时按 limit.output 预填)> undefined=不下发吃后端默认。
+    maxTokens: process.env.MAX_TOKENS ? Number(process.env.MAX_TOKENS) : (__activePreset?.maxTokens ?? undefined),
     // 用 getter 而非 buildBasePrompt() 立即求值：对象字面量初始化期间 buildBasePrompt 会读取
     // config.model 等字段，直接调用会触发 TDZ。Getter 也让语言、persona 等运行时变化在下一轮生效。
     get systemPrompt() {
@@ -727,6 +729,14 @@ export function updateModelConfig(opts) {
         config.contextWindowTokens = opts.contextWindowTokens;
         process.env.CONTEXT_WINDOW_TOKENS = String(opts.contextWindowTokens);
     }
+    if (opts.maxTokens !== undefined) {
+        // null = 显式清除(切到无该值的预设);数字 = 设置。同步 env 保证本窗口立即按新值/不发该字段。
+        config.maxTokens = opts.maxTokens === null ? undefined : opts.maxTokens;
+        if (opts.maxTokens === null)
+            delete process.env.MAX_TOKENS;
+        else
+            process.env.MAX_TOKENS = String(opts.maxTokens);
+    }
     if (opts.anthropicPromptCache !== undefined) {
         config.anthropicPromptCache = opts.anthropicPromptCache;
         process.env.ANTHROPIC_PROMPT_CACHE = opts.anthropicPromptCache ? 'true' : 'false';

package/dist/config/presets.js

@@ -88,6 +88,14 @@ export function parsePreset(raw) {
     if (typeof contextWindow !== 'number' || !Number.isFinite(contextWindow) || contextWindow <= 0) {
         throw new Error(`预设 ${name}: contextWindow 必须为正数`);
     }
+    // maxTokens 可选:缺省=不下发(吃后端默认);给了就必须是正整数。
+    let maxTokens;
+    if (obj.maxTokens !== undefined && obj.maxTokens !== null) {
+        if (typeof obj.maxTokens !== 'number' || !Number.isFinite(obj.maxTokens) || obj.maxTokens <= 0) {
+            throw new Error(`预设 ${name}: maxTokens 必须为正数`);
+        }
+        maxTokens = Math.floor(obj.maxTokens);
+    }
     const provider = normalizePresetProvider(obj.provider);
     const anthropicPromptCache = provider === 'anthropic' && obj.anthropicPromptCache !== false;
     // reasoningEffort 缺省 = auto;显式写了非法值按现有校验风格报错(坏文件由 listPresets 跳过)。
@@ -132,6 +140,7 @@ export function parsePreset(raw) {
         apiKey,
         model,
         contextWindow: Math.floor(contextWindow),
+        ...(maxTokens ? { maxTokens } : {}),
         anthropicPromptCache,
         ...(reasoningEffort ? { reasoningEffort } : {}),
         ...extra,

package/dist/llm/index.js

@@ -740,6 +740,10 @@ async function chatOnce(messages, handlers, signal, toolsOverride, runtime = def
     let consumedAny = false;
     const thinkFilter = new ThinkTagFilter();
     let usage;
+    // finish_reason 只在最后一个带 choice 的 chunk 出现;取最后一次非空值。
+    // 'length' 意味着输出在 max_tokens 处被硬切断——长 tool_call 参数此时必为残缺 JSON,
+    // 工具层据此把笼统的 INVALID_JSON 升级成截断恢复指引。
+    let finishReason;
     const toolAcc = new Map();
     const emitVisible = (text) => {
         if (!text)
@@ -784,7 +788,11 @@ async function chatOnce(messages, handlers, signal, toolsOverride, runtime = def
                 cachedTokens: usage.cachedTokens,
             });
         }
-        const delta = chunk.choices?.[0]?.delta;
+        const choice0 = chunk.choices?.[0];
+        const delta = choice0?.delta;
+        if (typeof choice0?.finish_reason === 'string' && choice0.finish_reason) {
+            finishReason = choice0.finish_reason;
+        }
         if (!delta)
             continue; // 末尾 usage-only chunk 等无 delta
         if (delta.content) {
@@ -835,6 +843,7 @@ async function chatOnce(messages, handlers, signal, toolsOverride, runtime = def
         content: consumedAny ? visibleContent : null,
         toolCalls,
         usage,
+        finishReason,
     };
 }
 // ── token 估算(自包含,不依赖 ui / 外部 tokenizer)──────────────────────

package/dist/llm/providers/anthropic.js

@@ -315,6 +315,8 @@ export async function anthropicChatOnce(messages, handlers, signal, tools, runti
         await throwResponseError(response);
     let content = '';
     let usage;
+    // message_delta 的 delta.stop_reason 给出停止原因;max_tokens 归一到 OpenAI 的 'length'。
+    let finishReason;
     const toolAcc = new Map();
     const live = { cjk: 0, other: 0 };
     const reportLive = () => {
@@ -391,6 +393,12 @@ export async function anthropicChatOnce(messages, handlers, signal, tools, runti
             continue;
         }
         if (type === 'message_delta') {
+            // stop_reason 位于 message_delta 的 delta 子对象(与 usage 同级事件)。
+            const d = event.delta;
+            if (typeof d?.stop_reason === 'string' && d.stop_reason) {
+                // Anthropic: end_turn / max_tokens / stop_sequence / tool_use / tool_use 等。
+                finishReason = d.stop_reason === 'max_tokens' ? 'length' : d.stop_reason;
+            }
             const raw = event.usage;
             if (raw) {
                 const previous = usage ?? usageFromAnthropic({});
@@ -414,5 +422,5 @@ export async function anthropicChatOnce(messages, handlers, signal, tools, runti
     const toolCalls = [...toolAcc.entries()]
         .sort((a, b) => a[0] - b[0])
         .map(([, call]) => ({ ...call, arguments: call.arguments || '{}' }));
-    return { content: content || null, toolCalls, usage };
+    return { content: content || null, toolCalls, usage, finishReason };
 }

package/dist/llm/providers/vertex.js

@@ -407,5 +407,11 @@ export async function vertexChatOnce(messages, handlers, signal, tools, runtime,
         content += marker;
         handlers.onText?.(marker);
     }
-    return { content: content || null, toolCalls, usage };
+    return {
+        content: content || null,
+        toolCalls,
+        usage,
+        // Gemini MAX_TOKENS 归一到 OpenAI 的 'length',供工具层给出截断恢复指引。
+        ...(finishReason ? { finishReason: finishReason === 'MAX_TOKENS' ? 'length' : finishReason } : {}),
+    };
 }

package/dist/models/map-preset.js

@@ -57,6 +57,9 @@ export function buildPreset(input) {
     const contextWindow = typeof model.limit?.context === 'number' && model.limit.context > 0
         ? Math.floor(model.limit.context)
         : FALLBACK_CONTEXT_WINDOW;
+    // 单次输出上限:目录有 limit.output 就带上(避免吃网关小默认导致长 write_file 被截断);
+    // 目录缺失则留 undefined=不下发,绝不硬编码大值(超过模型真实上限会被后端 400 拒整请求)。
+    const maxOutput = typeof model.limit?.output === 'number' && model.limit.output > 0 ? Math.floor(model.limit.output) : undefined;
     return {
         name: input.name ?? defaultPresetName(provider.id, model.id),
         provider: presetProvider,
@@ -64,6 +67,7 @@ export function buildPreset(input) {
         apiKey: input.apiKey,
         model: input.modelOverride ?? model.id,
         contextWindow,
+        ...(maxOutput ? { maxTokens: maxOutput } : {}),
         anthropicPromptCache: presetProvider === 'anthropic',
     };
 }

package/dist/repl/commands/model-actions.js

@@ -23,6 +23,8 @@ export function applyPresetConfig(ctx, p) {
         baseURL: p.baseURL,
         apiKey: p.apiKey,
         contextWindowTokens: p.contextWindow,
+        // 预设带值用值;不带显式清除(否则旧 MAX_TOKENS 残留会盖过新预设)。
+        maxTokens: p.maxTokens ?? null,
         anthropicPromptCache: p.anthropicPromptCache,
         ...(p.reasoningEffort ? { reasoningEffort: p.reasoningEffort } : {}),
     });
@@ -32,6 +34,7 @@ export function applyPresetConfig(ctx, p) {
         LLM_API_KEY: p.apiKey,
         LLM_MODEL: p.model,
         CONTEXT_WINDOW_TOKENS: String(p.contextWindow),
+        MAX_TOKENS: p.maxTokens ? String(p.maxTokens) : null,
         ANTHROPIC_PROMPT_CACHE: p.anthropicPromptCache ? 'true' : 'false',
     });
     // 关键不变量：应用预设即激活——必须同步 .active 指针。否则重启时旧激活预设的优先级

package/dist/repl/commands/model.js

@@ -25,14 +25,15 @@ import { renderHistory } from '../message-format.js';
 import { MODEL_PRESETS, maskKey } from '../commands.js';
 import { unhandled, next } from './types.js';
 /** 决定自动存的预设名:协议、缓存配置和连接四元组都一致时不重复存。 */
-function uniquePresetName(desired, provider, baseURL, apiKey, model, contextWindow, anthropicPromptCache) {
+function uniquePresetName(desired, provider, baseURL, apiKey, model, contextWindow, anthropicPromptCache, maxTokens) {
     const existing = listPresets();
     const sameEntry = existing.find((p) => p.provider === provider &&
         p.baseURL === baseURL &&
         p.apiKey === apiKey &&
         p.model === model &&
         p.contextWindow === contextWindow &&
-        p.anthropicPromptCache === anthropicPromptCache);
+        p.anthropicPromptCache === anthropicPromptCache &&
+        (p.maxTokens ?? undefined) === maxTokens);
     if (sameEntry)
         return null;
     const sanitized = desired
@@ -73,6 +74,8 @@ export const modelCommands = [
                 baseURL: target.baseURL,
                 apiKey: target.apiKey,
                 contextWindowTokens: target.contextWindow,
+                // 预设带值用值;不带则显式清除(否则本窗口/配置文件里的旧 MAX_TOKENS 会一直盖过新预设)。
+                maxTokens: target.maxTokens ?? null,
                 anthropicPromptCache: target.anthropicPromptCache,
                 ...(target.reasoningEffort ? { reasoningEffort: target.reasoningEffort } : {}),
             });
@@ -82,6 +85,8 @@ export const modelCommands = [
                 LLM_API_KEY: target.apiKey,
                 LLM_MODEL: target.model,
                 CONTEXT_WINDOW_TOKENS: String(target.contextWindow),
+                // null = 从配置文件删除该键(写不下发=吃后端默认)。
+                MAX_TOKENS: target.maxTokens ? String(target.maxTokens) : null,
                 ANTHROPIC_PROMPT_CACHE: target.anthropicPromptCache ? 'true' : 'false',
                 ...(target.reasoningEffort ? { REASONING_EFFORT: target.reasoningEffort } : {}),
             });
@@ -185,6 +190,7 @@ export const modelCommands = [
             layout.contentWrite(`  ${ui.accent}effort  ${ui.reset}  ${config.reasoningEffort}` +
                 (recognized ? '\n' : `${ui.dim}(当前模型未识别,参数不会下发)${ui.reset}\n`));
             layout.contentWrite(`  ${ui.accent}窗口    ${ui.reset}  ${config.contextWindowTokens} tokens\n`);
+            layout.contentWrite(`  ${ui.accent}输出上限${ui.reset} ${config.maxTokens ? `${config.maxTokens} tokens` : `${ui.dim}未设置(不下发,吃后端默认)${ui.reset}`}\n`);
             if (config.provider === 'anthropic') {
                 layout.contentWrite(`  ${ui.accent}缓存    ${ui.reset}  Prompt Cache ${config.anthropicPromptCache ? 'on' : 'off'}\n`);
             }
@@ -284,11 +290,14 @@ export const modelCommands = [
         let apiKey;
         let model;
         let window;
+        // 单次输出上限;undefined = 不下发(吃后端默认)。quickApply 沿用当前值。
+        let maxTokens;
         if (quickApply) {
             baseURL = preset.baseURL;
             apiKey = config.apiKey;
             model = preset.model;
             window = preset.window;
+            maxTokens = config.maxTokens;
         }
         else {
             // baseURL
@@ -364,6 +373,29 @@ export const modelCommands = [
                     window = Math.floor(n);
                 }
             }
+            // maxTokens(可选):单次回复输出上限。回车采纳当前值;填 0/留空 = 不下发吃后端默认。
+            {
+                const res = await promptIntervention({
+                    type: 'input',
+                    title: 'MAX_TOKENS',
+                    detail: '单次回复最大输出 token(思考+正文+工具参数)。留空=不下发吃后端默认;' +
+                        '部分兼容网关默认仅 4k/8k,长文件写入会被截断,建议填该模型官方最大输出(常见 8k-64k)。回车采纳当前值。',
+                    seed: config.maxTokens ? String(config.maxTokens) : '',
+                });
+                if (res.action === 'cancelled') {
+                    return next();
+                }
+                const v = (res.value ?? '').trim();
+                if (v) {
+                    const n = Number(v);
+                    if (Number.isFinite(n) && n > 0)
+                        maxTokens = Math.floor(n);
+                    // 非法值不阻断:保持 undefined(不下发),与留空同义。
+                }
+                else {
+                    maxTokens = undefined;
+                }
+            }
         }
         // 3) 应用协议、连接与缓存配置；Anthropic 原生协议无需重建 OpenAI client，但统一刷新无害。
         const provider = preset.provider;
@@ -374,6 +406,8 @@ export const modelCommands = [
             baseURL,
             apiKey,
             contextWindowTokens: window,
+            // 手填向导里留空 = undefined → 显式清除旧值,不下发 max_tokens。
+            maxTokens: maxTokens ?? null,
             anthropicPromptCache,
         });
         writeConfigKeys({
@@ -382,13 +416,14 @@ export const modelCommands = [
             LLM_API_KEY: apiKey,
             LLM_MODEL: model,
             CONTEXT_WINDOW_TOKENS: String(window),
+            MAX_TOKENS: maxTokens ? String(maxTokens) : null,
             ANTHROPIC_PROMPT_CACHE: anthropicPromptCache ? 'true' : 'false',
         });
         reconfigureClient();
         // 3.5) 自动存为命名预设；协议与缓存策略也是去重键的一部分。
         let savedName = null;
         try {
-            const finalName = uniquePresetName(model, provider, baseURL, apiKey, model, window, anthropicPromptCache);
+            const finalName = uniquePresetName(model, provider, baseURL, apiKey, model, window, anthropicPromptCache, maxTokens);
             if (finalName) {
                 savePreset({
                     name: finalName,
@@ -397,6 +432,7 @@ export const modelCommands = [
                     apiKey,
                     model,
                     contextWindow: window,
+                    ...(maxTokens ? { maxTokens } : {}),
                     anthropicPromptCache,
                 });
                 savedName = finalName;

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/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/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.11",
+  "version": "1.8.0",
   "description": "终端编码 agent:LLM + tool-call 循环 + 流式输出(含思考)+ 27 个工具,接任意 OpenAI 兼容后端。",
   "type": "module",
   "bin": {