mocode-ai 1.6.9 → 1.7.0

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

@@ -82,119 +82,48 @@ class LegacyCompatibleToolDispatcher {
         calls.forEach((call, index) => (call.name === ADD_TOOL_GROUPS_TOOL_NAME ? controlIndexes : otherIndexes).push(index));
         const hasRouteBarrier = controlIndexes.length > 0;
         if (hasRouteBarrier) {
-            // 同批的非控制调用全部是「未被禁用的并行安全(只读)工具」时(纯 solo 时空集也满足),
-            // 允许它们与扩容同批:先并发执行只读调用,再应用扩容。只读结果本 step 即得,新增 schema
-            // 下一 step 生效——不必为扩容空耗一轮。只要混有写/执行等非并行工具(或某只读调用已被
-            // 当前 snapshot 拒绝),即退回整批保守拒绝。
-            const safeReadonlyBatch = otherIndexes.every((index) => isParallelTool(calls[index].name, toolRuntime) && !request.isDenied(calls[index].name));
-            if (safeReadonlyBatch) {
-                // 所有 header 按调用原序先发(渲染侧据此建组容器),只读批的 header 必须先于 execute。
-                for (let index = 0; index < calls.length; index++) {
-                    request.onEvent({ type: 'header', call: calls[index] });
-                }
-                if (otherIndexes.length > 0) {
-                    request.onEvent({ type: 'start', tool: calls[otherIndexes[0]].name });
-                    const startedReadonly = otherIndexes.map((index) => execute(calls[index]));
-                    for (let offset = 0; offset < otherIndexes.length; offset++) {
-                        const index = otherIndexes[offset];
-                        const outcome = await startedReadonly[offset];
-                        record(index, outcome);
-                        executionEvents(index, parseArgs(calls[index].arguments), outcome);
-                        resultEvent(index, outcome, null);
-                    }
-                    request.onEvent({ type: 'done' });
-                }
-                // 控制调用(header 已发):逐个校验并应用扩容;solo 与同批语义一致。
-                for (const index of controlIndexes) {
-                    const call = calls[index];
-                    const parsed = parseArgs(call.arguments);
-                    let outcome;
-                    if (request.isDenied(call.name)) {
-                        outcome = {
-                            status: 'denied',
-                            code: 'TOOL_DISABLED',
-                            retryable: false,
-                            output: `错误:当前 tool policy snapshot 不允许调用 ${call.name}。`,
-                            changedFiles: [],
-                            durationMs: 0,
-                        };
-                    }
-                    else if (!request.expandToolGroups) {
-                        outcome = {
-                            status: 'denied',
-                            code: 'TOOL_DISABLED',
-                            retryable: false,
-                            output: '错误:当前 Agent 未启用动态工具策略，无法调用 add_tool_groups。',
-                            changedFiles: [],
-                            durationMs: 0,
-                        };
-                    }
-                    else if (!parsed ||
-                        !Array.isArray(parsed.groups) ||
-                        parsed.groups.length === 0 ||
-                        typeof parsed.reason !== 'string' ||
-                        !parsed.reason.trim()) {
-                        outcome = {
-                            status: 'error',
-                            code: 'INVALID_ARGUMENTS',
-                            retryable: false,
-                            output: '错误:add_tool_groups 需要非空 groups 数组和非空 reason。',
-                            changedFiles: [],
-                            durationMs: 0,
-                        };
-                    }
-                    else {
-                        const expansion = request.expandToolGroups(parsed.groups, parsed.reason);
-                        const succeeded = expansion.added.length > 0;
-                        const details = [
-                            succeeded
-                                ? `Tool policy expanded to v${expansion.snapshot.version}; added groups: ${expansion.added.join(', ')}.`
-                                : `Tool policy was not expanded (still v${expansion.snapshot.version}).`,
-                            expansion.implied.length > 0 ? `Implied groups also activated: ${expansion.implied.join(', ')}.` : '',
-                            expansion.rejected.length > 0 ? `Rejected: ${expansion.rejected.join('; ')}.` : '',
-                            succeeded ? 'The added tool schemas become available on the next model step.' : '',
-                        ]
-                            .filter(Boolean)
-                            .join('\n');
-                        outcome = {
-                            status: succeeded ? 'success' : 'error',
-                            code: succeeded ? 'OK' : 'INVALID_ARGUMENTS',
-                            retryable: false,
-                            output: details,
-                            changedFiles: [],
-                            durationMs: 0,
-                        };
-                        request.onEvent({
-                            type: 'route_expand',
-                            fromVersion: request.policy.toolPolicy?.version,
-                            expansion,
-                            requestedGroups: parsed.groups,
-                            reason: parsed.reason,
-                            status: outcome.status,
-                        });
-                    }
+            // add_tool_groups 混批语义 = 部分执行:同批所有「未被禁用的并行安全(只读)」调用
+            // 本 step 照常并发执行,控制调用照常应用扩容(只改下一 step 的 schema);仅写/执行
+            // 等非并行调用被配对拒绝并提示下一 step 重试——单个违规调用不再让整批陪葬。
+            // 所有 header 按调用原序先发(渲染侧据此建组容器),只读批的 header 必须先于 execute。
+            for (let index = 0; index < calls.length; index++) {
+                request.onEvent({ type: 'header', call: calls[index] });
+            }
+            // 只读调用先并发启动(执行序不变);但发布(history 回灌/事件)一律按 provider 声明序
+            // 交错进行:history 批校验按 assistant tool_calls 逐位配对 id,若按执行序发布(只读先、
+            // 扩容后),add_tool_groups 排在只读之前时必然 id 错位,整批 rollback 中断本轮。
+            // 非并行(写/执行/串行)调用不启动:它们与扩容同批时被拒绝,下一 step 重试。
+            const startedReadonly = new Array(calls.length);
+            const eligibleReadonly = otherIndexes.filter((index) => isParallelTool(calls[index].name, toolRuntime) && !request.isDenied(calls[index].name));
+            if (eligibleReadonly.length > 0) {
+                request.onEvent({ type: 'start', tool: calls[eligibleReadonly[0]].name });
+                for (const index of eligibleReadonly)
+                    startedReadonly[index] = execute(calls[index]);
+            }
+            const lastReadonlyIndex = eligibleReadonly.length > 0 ? eligibleReadonly[eligibleReadonly.length - 1] : -1;
+            for (let index = 0; index < calls.length; index++) {
+                const readonlyPromise = startedReadonly[index];
+                if (readonlyPromise) {
+                    const outcome = await readonlyPromise;
                     record(index, outcome);
-                    request.onEvent({ type: 'host_outcome', call, parsed: parsed ?? {}, outcome });
+                    executionEvents(index, parseArgs(calls[index].arguments), outcome);
                     resultEvent(index, outcome, null);
-                    traceEnd(index, outcome);
+                    // done 紧跟最后一个只读结果(控制调用在尾部时与旧事件序完全一致)。
+                    if (index === lastReadonlyIndex)
+                        request.onEvent({ type: 'done' });
+                    continue;
                 }
-            }
-            else {
-                // 不安全批(混有写/执行等非并行工具):不扩容、不执行任何普通工具,逐 call 按原序配对拒绝结果。
-                for (let index = 0; index < calls.length; index++) {
+                if (calls[index].name !== ADD_TOOL_GROUPS_TOOL_NAME) {
+                    // 非并行(写/执行/串行)或被禁用的普通调用:与扩容同批时不执行,配对拒绝并提示
+                    // 下一 step 重试;控制调用与只读不受其影响照常处理。
                     const call = calls[index];
-                    request.onEvent({ type: 'header', call });
-                    const isControl = call.name === ADD_TOOL_GROUPS_TOOL_NAME;
-                    const isReadonly = isParallelTool(call.name, toolRuntime);
                     const outcome = {
                         status: 'denied',
-                        code: isControl ? 'INVALID_ARGUMENTS' : 'TOOL_DISABLED',
+                        code: 'TOOL_DISABLED',
                         retryable: false,
-                        output: isControl
-                            ? '错误:add_tool_groups 只能单独调用，或与只读工具(read_file/glob/grep/web 等)同批；本次没有扩容。'
-                            : isReadonly
-                                ? `错误:同一响应包含 add_tool_groups，工具 ${call.name} 未执行。请在下一 step 重试。`
-                                : `错误:add_tool_groups 不能与写/执行工具 ${call.name} 同批；请先完成扩容，再在下一 step 调用 ${call.name}。`,
+                        output: request.isDenied(call.name)
+                            ? `错误:当前 tool policy snapshot 不允许调用 ${call.name}。`
+                            : `错误:add_tool_groups 不能与写/执行工具 ${call.name} 同批执行，本 step 已跳过该调用（其余只读调用与扩容已正常处理）；请在下一 step 重试 ${call.name}。`,
                         changedFiles: [],
                         durationMs: 0,
                     };
@@ -202,7 +131,81 @@ class LegacyCompatibleToolDispatcher {
                     request.onEvent({ type: 'host_outcome', call, parsed: parseArgs(call.arguments) ?? {}, outcome });
                     resultEvent(index, outcome, null);
                     traceEnd(index, outcome);
+                    continue;
                 }
+                // 控制调用(header 已发):逐个校验并应用扩容;solo 与同批语义一致。
+                // 扩容只改下一 step 的 schema;本批只读执行都走 step 快照,先后无行为差。
+                const call = calls[index];
+                const parsed = parseArgs(call.arguments);
+                let outcome;
+                if (request.isDenied(call.name)) {
+                    outcome = {
+                        status: 'denied',
+                        code: 'TOOL_DISABLED',
+                        retryable: false,
+                        output: `错误:当前 tool policy snapshot 不允许调用 ${call.name}。`,
+                        changedFiles: [],
+                        durationMs: 0,
+                    };
+                }
+                else if (!request.expandToolGroups) {
+                    outcome = {
+                        status: 'denied',
+                        code: 'TOOL_DISABLED',
+                        retryable: false,
+                        output: '错误:当前 Agent 未启用动态工具策略，无法调用 add_tool_groups。',
+                        changedFiles: [],
+                        durationMs: 0,
+                    };
+                }
+                else if (!parsed ||
+                    !Array.isArray(parsed.groups) ||
+                    parsed.groups.length === 0 ||
+                    typeof parsed.reason !== 'string' ||
+                    !parsed.reason.trim()) {
+                    outcome = {
+                        status: 'error',
+                        code: 'INVALID_ARGUMENTS',
+                        retryable: false,
+                        output: '错误:add_tool_groups 需要非空 groups 数组和非空 reason。',
+                        changedFiles: [],
+                        durationMs: 0,
+                    };
+                }
+                else {
+                    const expansion = request.expandToolGroups(parsed.groups, parsed.reason);
+                    const succeeded = expansion.added.length > 0;
+                    const details = [
+                        succeeded
+                            ? `Tool policy expanded to v${expansion.snapshot.version}; added groups: ${expansion.added.join(', ')}.`
+                            : `Tool policy was not expanded (still v${expansion.snapshot.version}).`,
+                        expansion.implied.length > 0 ? `Implied groups also activated: ${expansion.implied.join(', ')}.` : '',
+                        expansion.rejected.length > 0 ? `Rejected: ${expansion.rejected.join('; ')}.` : '',
+                        succeeded ? 'The added tool schemas become available on the next model step.' : '',
+                    ]
+                        .filter(Boolean)
+                        .join('\n');
+                    outcome = {
+                        status: succeeded ? 'success' : 'error',
+                        code: succeeded ? 'OK' : 'INVALID_ARGUMENTS',
+                        retryable: false,
+                        output: details,
+                        changedFiles: [],
+                        durationMs: 0,
+                    };
+                    request.onEvent({
+                        type: 'route_expand',
+                        fromVersion: request.policy.toolPolicy?.version,
+                        expansion,
+                        requestedGroups: parsed.groups,
+                        reason: parsed.reason,
+                        status: outcome.status,
+                    });
+                }
+                record(index, outcome);
+                request.onEvent({ type: 'host_outcome', call, parsed: parsed ?? {}, outcome });
+                resultEvent(index, outcome, null);
+                traceEnd(index, outcome);
             }
         }
         let index = hasRouteBarrier ? calls.length : 0;
@@ -234,11 +237,16 @@ class LegacyCompatibleToolDispatcher {
                     request.onEvent({ type: 'header', call });
                 request.onEvent({ type: 'start', tool: batch[0].name });
                 const started = batch.map((call) => execute(call));
+                // 完成即发:usage/host_outcome/trace_end 在各 outcome 落地瞬间发出(1s 的 grep 不再
+                // 被 60s 的 run_command 卡住可见性);result(history 回灌)严格保持原序。
+                await Promise.all(started.map(async (pending, offset) => {
+                    const outcome = await pending;
+                    executionEvents(index + offset, parseArgs(batch[offset].arguments), outcome);
+                }));
                 for (let offset = 0; offset < batch.length; offset++) {
                     const callIndex = index + offset;
                     const outcome = await started[offset];
                     record(callIndex, outcome);
-                    executionEvents(callIndex, parseArgs(batch[offset].arguments), outcome);
                     resultEvent(callIndex, outcome, null);
                 }
                 request.onEvent({ type: 'done' });
@@ -284,25 +292,36 @@ class LegacyCompatibleToolDispatcher {
                 const firstAllowed = entries.find((entry) => !entry.denied);
                 if (firstAllowed)
                     request.onEvent({ type: 'start', tool: firstAllowed.call.name });
-                for (let chunkStart = 0; chunkStart < entries.length; chunkStart += concurrency) {
-                    const chunk = entries.slice(chunkStart, chunkStart + concurrency);
-                    // 块内同时启动,再按原序 await + 回灌：完成顺序任意,history/trace 始终是原调用序。
-                    const started = chunk.map((entry) => {
-                        if (entry.denied)
-                            return Promise.resolve(entry.denied);
-                        return execute(entry.call, request.argumentErrorHint(entry.call.name), (lockedArgs) => {
-                            entry.diff = readDiffContext(entry.call, lockedArgs, jailResolve);
-                        });
-                    });
-                    for (let k = 0; k < chunk.length; k++) {
-                        const callIndex = index + chunkStart + k;
-                        const entry = chunk[k];
-                        const outcome = await started[k];
-                        record(callIndex, outcome);
-                        executionEvents(callIndex, entry.parsed, outcome);
-                        resultEvent(callIndex, outcome, entry.denied ? null : entry.parsed, entry.diff);
-                        invalidate(outcome);
+                // 动态补位池:启动上限 concurrency,任意一个完成立即补位下一个——静态分块时
+                // 「7 个任务、1 个跑 10 分钟」会让第 5 分钟起 4 个槽位空转而 6/7 号干等,总耗时
+                // ≈最慢链;补位后 ≈最满调度。
+                // 完成即发:usage/host_outcome/trace_end 在各 outcome 落地瞬间发出(快完成的
+                // 子 agent 不再被批内前面的慢调用卡住可见性)。history 回灌(result 事件)严格
+                // 保持 provider 原调用序——批校验按 assistant tool_calls 逐位配对 id。
+                // 实现用 worker 循环而非「补位回调 + outcomes.map」:outcomes 是稀疏数组,
+                // Array.prototype.map 会跳过未启动槽位的洞,补位链条会在第 N+1 个断掉。
+                const outcomes = new Array(entries.length);
+                let cursor = 0;
+                const runWorker = async () => {
+                    while (cursor < entries.length) {
+                        const position = cursor++;
+                        const entry = entries[position];
+                        const outcome = entry.denied
+                            ? entry.denied
+                            : await execute(entry.call, request.argumentErrorHint(entry.call.name), (lockedArgs) => {
+                                entry.diff = readDiffContext(entry.call, lockedArgs, jailResolve);
+                            });
+                        outcomes[position] = Promise.resolve(outcome);
+                        executionEvents(index + position, entry.parsed, outcome);
                     }
+                };
+                await Promise.all(Array.from({ length: Math.min(concurrency, entries.length) }, () => runWorker()));
+                for (let offset = 0; offset < entries.length; offset++) {
+                    const outcome = await outcomes[offset];
+                    const callIndex = index + offset;
+                    record(callIndex, outcome);
+                    resultEvent(callIndex, outcome, entries[offset].denied ? null : entries[offset].parsed, entries[offset].diff);
+                    invalidate(outcome);
                 }
                 if (firstAllowed)
                     request.onEvent({ type: 'done' });
@@ -352,12 +371,17 @@ class LegacyCompatibleToolDispatcher {
                         entry.diff = readDiffContext(entry.call, lockedArgs, jailResolve);
                     });
                 });
+                // 完成即发:usage/host_outcome/trace_end 落地瞬间发出;result(history 回灌)严格原序
+                // ——批校验按 assistant tool_calls 逐位配对 id,同文件排队由 canonical file 锁保证。
+                await Promise.all(started.map(async (pending, offset) => {
+                    const outcome = await pending;
+                    executionEvents(index + offset, entries[offset].parsed, outcome);
+                }));
                 for (let offset = 0; offset < entries.length; offset++) {
                     const callIndex = index + offset;
                     const entry = entries[offset];
                     const outcome = await started[offset];
                     record(callIndex, outcome);
-                    executionEvents(callIndex, entry.parsed, outcome);
                     resultEvent(callIndex, outcome, entry.denied ? null : entry.parsed, entry.diff);
                     invalidate(outcome);
                 }

package/dist/headless.js

@@ -14,6 +14,7 @@
 // 权限：非交互默认 fail-closed（permissions/index.ts 的 !isTTY 分支）。
 // --dangerously-skip-permissions 显式关闭权限闸。
 import path from 'node:path';
+import { mkdirSync, writeFileSync } from 'node:fs';
 import { setSandboxRoot } from './sandbox/root.js';
 import { registerToolsExtension } from './tools/registry.js';
 // 装配官方默认工具包：registry 不顶层 import builtins（破模块循环），入口须显式装配。
@@ -26,7 +27,8 @@ import { defaultRuntime, Runtime } from './runtime/index.js';
 import { runAgentCore } from './agent/core.js';
 import { summarizeToolCall, summarizeToolResult } from './ui/render.js';
 import { getToolChatSchema } from './tools/policy.js';
-import { createWorktree, removeWorktree } from './jobs/worktree.js';
+import { jobsRoot, updateJob } from './jobs/store.js';
+import { createWorktree, exportWorktreePatch, removeWorktree } from './jobs/worktree.js';
 import { runAsIdentity } from './bots/bus.js';
 import { createAsyncApprovalChecker } from './jobs/approval.js';
 import { writeCheckpoint, readCheckpoint } from './jobs/checkpoint.js';
@@ -257,6 +259,24 @@ export async function runHeadless(opts) {
         await runtime.close();
         if (wt) {
             try {
+                // worktree 成果挽留:销毁前把相对 HEAD 的改动导成 patch 落到主工作区
+                // .mocode/jobs/,后台任务/一次性 worktree 跑完不再"自毁成果"。job 模式顺带
+                // 回写 patchPath 供 /jobs 与通知引用;非 git 改动(导出失败)不阻塞清理。
+                const patch = exportWorktreePatch(wt);
+                if (patch !== null) {
+                    const patchFile = path.join(jobsRoot(), opts.jobId ? `${opts.jobId}.patch` : `wt-${Date.now()}.patch`);
+                    try {
+                        mkdirSync(path.dirname(patchFile), { recursive: true });
+                        writeFileSync(patchFile, patch, 'utf8');
+                        process.stderr.write(`mocode: worktree 改动已导出 patch:${patchFile}\n`);
+                        if (opts.jobId) {
+                            updateJob(opts.jobId, { patchPath: patchFile });
+                        }
+                    }
+                    catch (e) {
+                        process.stderr.write(`mocode: patch 导出失败(${e instanceof Error ? e.message : String(e)}),worktree 改动将丢失\n`);
+                    }
+                }
                 removeWorktree(wt);
             }
             catch {
@@ -279,6 +299,12 @@ export async function runHeadless(opts) {
         };
         process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
     }
+    else if (result.terminationReason === 'max_steps' && result.finalText) {
+        // 撞限 salvage 摘要:非 json 模式也必须落 stdout。它从未被 onText 流式输出,
+        // 走旧的「!textBuffer 才补打」分支会在本轮早前已有叙述文本时把它整个吞掉。
+        // 尾部换行沿用下方 isTTY 统一补行逻辑,与 completed 路径行为一致。
+        process.stdout.write(result.finalText);
+    }
     else if (finalText && !textBuffer) {
         process.stdout.write(finalText);
     }

package/dist/jobs/launch.js

@@ -5,7 +5,7 @@
 // tsx loader 单进程跑 src/index.ts（不用 tsx CLI：它会 respawn 一个不 hide 的弹窗 node）。
 //
 // 通用件 buildEntryArgs / spawnDetached 也供 schedule 守护进程复用（src/schedule/daemon.ts）。
-import { spawn, spawnSync } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import { openSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
@@ -68,13 +68,19 @@ export function launchBackgroundJob(prompt, opts = {}) {
     return { record: { ...record, pid: child.pid }, child };
 }
 /**
- * 树杀进程并置 killed。
+ * 树杀进程。返回「kill 信号已成功发出」(Windows)或「信号已发送」(POSIX),不保证目标已退出。
  * Windows：taskkill /T /F 杀整棵进程树；POSIX：负 pid 杀整个进程组。
+ *
+ * 异步化:spawnSync('taskkill') 会同步阻塞整个事件循环(扫树期间流式渲染/并行工具停摆)。
+ * 调用方「已知 job 已死」的语义靠 exited 轮询(isDaemonRunning / reconcile),不依赖本函数的返回时序。
  */
-export function killTree(pid) {
+export async function killTree(pid) {
     if (process.platform === 'win32') {
-        const r = spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true });
-        return r.status === 0;
+        return new Promise((resolve) => {
+            const killer = spawn('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true });
+            killer.on('close', (code) => resolve(code === 0));
+            killer.on('error', () => resolve(false));
+        });
     }
     try {
         process.kill(-pid, 'SIGTERM');
@@ -85,10 +91,11 @@ export function killTree(pid) {
     }
 }
 /** 树杀 job 并置 killed。 */
-export function killBackgroundJob(record) {
+export async function killBackgroundJob(record) {
     if (typeof record.pid !== 'number')
         return false;
-    if (!killTree(record.pid))
+    const ok = await killTree(record.pid);
+    if (!ok)
         return false;
     updateJob(record.id, { status: 'killed', finishedAt: new Date().toISOString() }, { force: true });
     return true;

package/dist/jobs/worktree.js

@@ -44,6 +44,26 @@ export function createWorktree() {
     }
     return { path: wtPath, repoRoot };
 }
+/**
+ * 把 worktree 相对 HEAD 的全部改动导出为 unified diff（含未跟踪文件，binary 标记为
+ * Binary files differ）。无改动返回 null（调用方不写空 patch 文件）。
+ *
+ * 用 spawnSync 而非异步 spawn：本函数只在 headless/runner 的收尾路径调用（事件循环
+ * 已无流式渲染在跑），且 removeWorktree 本身就是同步链，拆异步收益为零。
+ */
+export function exportWorktreePatch(wt) {
+    const status = git(['status', '--porcelain'], wt.path);
+    if (!status.ok || !status.output)
+        return null; // 无改动 / git 不可用
+    // 未跟踪文件：先 git add -N(intent-to-add) 让 diff 能覆盖新文件,否则 --worktree
+    // 默认跳过 untracked,新建的文件会随 worktree 一起消失。--intent-to-add 不改
+    // index 的实际内容、不产生对象,worktree remove --force 可正常清理。
+    git(['add', '-N', '.'], wt.path);
+    const diff = git(['diff', 'HEAD', '--binary'], wt.path);
+    if (!diff.ok || !diff.output)
+        return null;
+    return `${diff.output}\n`;
+}
 /** 先删 node_modules 链接（防误伤目标），再移除 worktree + prune。 */
 export function removeWorktree(wt) {
     const link = join(wt.path, 'node_modules');

package/dist/llm/index.js

@@ -26,6 +26,8 @@ if (process.env.DEBUG === 'true') {
  *   不重试  →  400 (bad request) / 401 (auth) / 其他 4xx / 用户中断 (AbortError / APIUserAbortError)
  *
  * 退避:指数 + ±20% jitter,首等 1s,翻倍,封顶 30s;若后端返回 Retry-After 头则优先按其值。
+ *   例外:「连接类」错误(连接被掐断 / 建连层网络错)的首次重试不等待(见 computeRetryWaitMs):
+ *   换条新连接几乎必成,白等 1s 只让用户干看「重试中」;第二次起照常退避。
  * 默认 10 次尝试(1 初始 + 9 重试),要调改 RETRY_MAX_ATTEMPTS。
  *
  * SDK 内置 maxRetries 默认 2(对所有 5xx+网络错重试),与本策略叠加会双重重试 5xx —— 显式置 0 让
@@ -351,6 +353,36 @@ export function computeBackoff(attempt, retryAfterMs) {
     const hi = base * (1 + RETRY_JITTER);
     return Math.max(0, Math.round(lo + Math.random() * (hi - lo)));
 }
+/**
+ * 「连接类」错误:连接被掐断 / 建连层网络错(errno 藏在 cause 链)/ SDK 建连失败包装 /
+ * 折叠成文案的网络错。这类错误的共同点:**重发到一条新连接几乎必成** —— 池里的旧连接
+ * 被代理掐死(keepalive 竞速)是最常见成因,第一次失败换条连接就好。
+ * 判据全部复用 isRetryableError / hasStreamBreakSignal 已有的分类原语,不引入新词表。
+ */
+export function isConnectionClassError(err) {
+    if (!err || typeof err !== 'object')
+        return false;
+    const e = err;
+    const ctor = e.constructor?.name ?? '';
+    if (ctor === 'APIConnectionError' || ctor === 'APIConnectionTimeoutError')
+        return true;
+    if (hasStreamBreakSignal(err))
+        return true;
+    if (causeChainFrames(err).some((f) => !!f.code && RETRYABLE_ERRNO.has(f.code)))
+        return true;
+    const msg = typeof e.message === 'string' ? e.message : '';
+    return /^connection error\.?$/i.test(msg.trim()) || /\bfetch failed\b/i.test(msg);
+}
+/**
+ * 第 N 次失败后的实际等待毫秒。连接类错误的**首次**重试不等待(0ms):换条新连接几乎
+ * 必成,白等 1s 只让用户干看「重试中」闪烁;第二次起照常指数退避(预算与封顶都不变)。
+ * Retry-After 存在时优先尊重服务端指令 —— 429 限流与断流可能同源,立即重发只会火上浇油。
+ */
+export function computeRetryWaitMs(attempt, err, retryAfterMs) {
+    if (attempt === 1 && retryAfterMs === undefined && isConnectionClassError(err))
+        return 0;
+    return computeBackoff(attempt, retryAfterMs);
+}
 function logRetry(attempt, err, waitMs) {
     const e = err;
     const tag = e.status ? `HTTP ${e.status}` : e.name || 'Error';
@@ -535,7 +567,7 @@ async function chatWithRuntime(runtime, messages, handlers, signal, toolsOverrid
             }
             if (streamRetryable)
                 streamRetries++;
-            const wait = computeBackoff(attempt, getRetryAfterMs(err));
+            const wait = computeRetryWaitMs(attempt, err, getRetryAfterMs(err));
             const retry = {
                 attempt,
                 nextAttempt: attempt + 1,
@@ -851,8 +883,35 @@ export function contentTokens(content) {
     }
     return estimateTokens(contentToText(content));
 }
-/** 估算单条消息的 token 数:结构开销 + content + tool_calls 参数。 */
+/** 单条消息的 token 估算缓存:命中键 = 该消息的「内容签名」(见 messageSignature)。 */
+const messageTokensCache = new WeakMap();
+/**
+ * 消息内容签名:content 引用 + role + 有无 tool_calls。
+ *
+ * **为什么签名里用 content 的「长度」而不是内容本身**:签名要在每次估算时算,必须是 O(1)。
+ * 用 `typeof content === 'string' ? content.length : -1` 兼顾 O(1) 与可判定性 ——
+ * string 不可变,原地改写(`msg.content = ...`)必然换成另一个字符串对象、长度通常也变;
+ * 长度相同而内容变了的情况(如 microcompact 截到同样长度)极少,且那种路径
+ * (compact / age-aware)本身会先 markContextChanged 走全量重估(见 scheduler)。
+ *
+ * **为什么不直接用对象身份当键**(即 WeakMap<ChatMessage, number>):有 4 处代码会
+ * **原地改写** message.content —— age-aware.ts:66、artifacts.ts:269(标 stale)、
+ * compact.ts:590/597(微压缩)。对象身份不变但内容已变,身份缓存会返回旧值 →
+ * token 低估 → 80% 压力线不触发 → prompt 实际已超窗口(llm/index.ts:1042-1044 注释
+ * 描述过这个失败模式:「模型突然抽风」)。签名方案让这4 处自动安全,无需挂失效钩子。
+ */
+function messageSignature(m) {
+    const c = m.content;
+    const tcs = m.tool_calls;
+    return `${m.role ?? ''}|${typeof c === 'string' ? c.length : -1}|${tcs ? 1 : 0}`;
+}
+/** 估算单条消息的 token 数:结构开销 + content + tool_calls 参数。内容签名命中则复用上次结果。 */
 export function messageTokens(m) {
+    const key = m;
+    const sig = messageSignature(m);
+    const hit = messageTokensCache.get(key);
+    if (hit !== undefined && hit.sig === sig)
+        return hit.tokens;
     const role = m.role;
     let structural = 4; // {role}\n{content}\n 框架基线
     if (role === 'system')
@@ -865,7 +924,9 @@ export function messageTokens(m) {
         for (const tc of tcs)
             body += estimateTokens(tc?.function?.arguments ?? '');
     }
-    return structural + body;
+    const tokens = structural + body;
+    messageTokensCache.set(key, { sig, tokens });
+    return tokens;
 }
 /** 估算整段 messages 的 token 数(不含工具 schema,含 priming 常数)。 */
 export function estimateMessagesTokens(messages) {

package/dist/llm/proxy.js

@@ -72,6 +72,19 @@ function windowsProxyOptions() {
         noProxy,
     };
 }
+/**
+ * 空闲 keepalive 连接的存活时长(毫秒)。
+ *
+ * undici 默认 4s:编码会话里工具执行(npm test/build)几乎总超过 4s,下一次 LLM 请求时
+ * 连接已被池回收,经 Clash 重新做 TCP+TLS 握手(实测 1.4–8s),每个 step 都吃一次;
+ * 「undici 拿到刚被代理掐死的连接」也正是偶发 ECONNRESET 的来源。拉长到 60s 让空闲
+ * 连接活过典型的工具执行间隔,复用率上升。可用 MOCODE_KEEPALIVE_MS 覆盖(非正数回退默认)。
+ */
+const DEFAULT_KEEPALIVE_TIMEOUT_MS = 60_000;
+function keepAliveTimeoutMs() {
+    const raw = Number(process.env.MOCODE_KEEPALIVE_MS);
+    return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_KEEPALIVE_TIMEOUT_MS;
+}
 export function installEnvProxy() {
     if (installed)
         return;
@@ -93,7 +106,17 @@ export function installEnvProxy() {
         return originalEmitWarning(...args);
     });
     try {
-        setGlobalDispatcher(new EnvHttpProxyAgent(options));
+        // keepalive 调参:EnvHttpProxyAgent 把 ...agentOpts 透传给内部 Agent/ProxyAgent
+        // (undici 6.21 env-http-proxy-agent.js 构造器),Client 层消费这三个选项。
+        // threshold 刻意高于默认 2s:undici 会在「服务端 Keep-Alive 头声明的存活期 − threshold」
+        // 时刻掐自己的空闲连接,若代理声明的存活期略长于我们的 keepAliveTimeout,留出余量
+        // 可避免双方同时收线时撞上刚被掐死的连接(那正是 ECONNRESET 的形态)。
+        setGlobalDispatcher(new EnvHttpProxyAgent({
+            ...(options ?? {}),
+            keepAliveTimeout: keepAliveTimeoutMs(),
+            keepAliveMaxTimeout: 600_000,
+            keepAliveTimeoutThreshold: 5_000,
+        }));
     }
     finally {
         process.emitWarning = originalEmitWarning;