mocode-ai 0.5.4 → 0.5.6

package/dist/agent/core.js

@@ -5,7 +5,7 @@
 // 与 index.ts 的关系:index.ts 的 runAgent = runAgentCore + TUI hooks 薄封装(行为不变)。
 // spawn.ts 的 spawnAgent = runAgentCore + 静默 hooks(子 agent)。
 import { readFileSync } from 'node:fs';
-import { chat, planChatTools, } from '../llm/index.js';
+import { chat, estimateMessagesTokens, estimateToolSchemaTokens, planChatTools, } from '../llm/index.js';
 import { executeTool, tools } from '../tools/registry.js';
 import { checkPermission } from '../permissions/index.js';
 import { getPlanDisabledTools } from '../tools/constants.js';
@@ -17,7 +17,6 @@ import { createRelevancePruner } from '../context/relevance.js';
 import { config } from '../config/index.js';
 import { jailResolve } from '../sandbox/index.js';
 import { createLifecycleEngine } from '../context/lifecycle.js';
-import { hasActivePlan, getActivePlan } from '../plan/active.js';
 /** 解析工具 arguments JSON;非法或空返 null(调用方据此降级到普通 preview)。 */
 function parseArgs(raw) {
     try {
@@ -139,6 +138,7 @@ function pushToolResult(history, tc, output, pruner, lifecycle, scheduler) {
  */
 export async function runAgentCore(opts) {
     const { history, userInput, signal, onContextUpdate, hooks, skipRollback } = opts;
+    const runtimeContextState = opts.contextState ?? contextState;
     const maxSteps = opts.maxSteps ?? config.maxSteps;
     // 中断回滚快照:入口(本 turn push 任何消息前)整段浅拷贝。abort 时 length=0;push(...saved) 还原。
     // 用 slice() 而非 length:maybeCompact 会原地重建(length=0;push(...rebuilt)),savedLen 会失效。
@@ -167,45 +167,11 @@ export async function runAgentCore(opts) {
     // Thrashing 检测:本轮内同 (name, args) 累计次数。≥3 在工具结果尾部追加 hint(见 thrashHint)。
     // 只在 runAgentCore 内,turn 结束自然 GC;不跨 turn 持久(下一轮重新计数,避免误把历史判为 thrashing)。
     const recentToolCalls = new Map();
-    // Plan progress nudge:LLM 连续 ≥ PLAN_NUDGE_THRESHOLD 次工具调用没调 todolist → 注入提醒到结果末尾。
-    // 让进度 chip 反映真实进展,而不是做完一大段后才一次性批量更新。
-    // 计数器在任何 todolist 调用后重置;nudge 发出后也重置(避免后续每次工具调用都重复提醒)。
-    let stepsSincePlanUpdate = 0;
-    const PLAN_NUDGE_THRESHOLD = 2;
-    // Plan nudge 节流:同一步骤只发一次,避免模型未响应时重复刷屏。
-    // nudge 发出后置 -1;调 todolist 后重置为 0(可重新触发);中间步骤保持负值(不重复)。
-    const planNudge = (name) => {
-        if (name === 'todolist') {
-            stepsSincePlanUpdate = 0;
-            return null;
-        }
-        stepsSincePlanUpdate++;
-        if (stepsSincePlanUpdate < PLAN_NUDGE_THRESHOLD)
-            return null;
-        if (stepsSincePlanUpdate > PLAN_NUDGE_THRESHOLD)
-            return null; // 已发过,不再重复
-        if (!hasActivePlan())
-            return null;
-        const p = getActivePlan();
-        if (!p || p.status !== 'in_progress')
-            return null;
-        const hasPending = p.steps.some((s) => s.status === 'pending' || s.status === 'in_progress');
-        if (!hasPending)
-            return null;
-        return ('\n\n[plan-nudge] ⚠ You\'ve run ' + PLAN_NUDGE_THRESHOLD +
-            '+ tool calls since the last plan update. ' +
-            'Call `todolist` (action=update) NOW to mark the current step done and set the next step in_progress. ' +
-            'Do this BEFORE making more tool calls.');
-    };
     const recordAndHint = (name, args) => {
         const fp = `${name}\x00${args}`;
         const c = (recentToolCalls.get(fp) ?? 0) + 1;
         recentToolCalls.set(fp, c);
-        const thrash = thrashHint(name, args, c);
-        const nudge = planNudge(name);
-        if (!thrash && !nudge)
-            return null;
-        return [thrash, nudge].filter(Boolean).join('');
+        return thrashHint(name, args, c);
     };
     history.push({ role: 'user', content: userInput });
     // drop_context 工具的上下文剔除回调:闭包捕获 history,原地剔除无关旧 tool 结果。
@@ -222,7 +188,7 @@ export async function runAgentCore(opts) {
     // 预算调度器:每个 runAgentCore 实例一个,步前 evaluateBudget + scheduleActions。
     // 决策按 ROI 分发(cold tools 优先 / history 摘要最后);contextBudget 开关关闭时为 null。
     const scheduler = config.contextBudget !== false
-        ? createBudgetScheduler() // 在 step 循环之外实例化一次,跨步持有 lastRunLog
+        ? createBudgetScheduler(runtimeContextState) // 在 step 循环之外实例化一次,跨步持有 lastRunLog
         : null;
     // 本轮流式状态:首个正文 token 到达即停 spinner(思考期间 spinner 持续转「思考中…」,不写思考内容)。
     let mode = 'idle';
@@ -242,6 +208,10 @@ export async function runAgentCore(opts) {
     const onToolCall = (name) => {
         // 文本/思考已流完,模型转而生成 tool_call 参数(可能很长,如 write_file 整篇内容):
         // 补换行(让随后的 ● 行与 diff 不黏在正文末尾)+ 启「生成中」内联 spinner,内容区不再干等。
+        if (lastChar && lastChar !== '\n') {
+            hooks.onTextEnd?.(); // 主 agent:layout.contentWrite('\n')
+            lastChar = '\n';
+        }
         hooks.onToolCall?.(name); // 主 agent:spinner.start(`生成 ${name}…`)
     };
     // 中断还原:停 spinner + 补换行 + (已中断)提示 + history 还原到本 turn 前 + 模式还原。
@@ -266,7 +236,7 @@ export async function runAgentCore(opts) {
                 await scheduler.runStep(history, step);
             }
             else {
-                await maybeCompact(history);
+                await maybeCompact(history, undefined, undefined, runtimeContextState);
             }
             hooks.onStepStart?.(); // 主 agent:spinner.start('思考中')
             mode = 'idle';
@@ -291,14 +261,26 @@ export async function runAgentCore(opts) {
                 }
                 throw e;
             }
-            contextState.lastUsage = result.usage; // 供 /context 与状态行显示实测 token
+            runtimeContextState.lastUsage = result.usage; // 供 /context 与状态行显示实测 token
             addUsage(result.usage); // 本轮累计:onDone 摘要行 + AgentRunResult.usage 透传
+            // 校正系数:API 实测 prompt_tokens / 估算 token。
+            // 每次 chat 响应后刷新,让下次 evaluateBudget 用更接近真实的 actual。
+            // 钳位 [0.5, 2.0]:防单次异常值(极短回复 / 空 history)导致系数跳变。
+            if (result.usage?.promptTokens && result.usage.promptTokens > 100) {
+                const estimated = estimateMessagesTokens(history) + estimateToolSchemaTokens();
+                if (estimated > 100) {
+                    const raw = result.usage.promptTokens / estimated;
+                    runtimeContextState.correction = Math.max(0.5, Math.min(2.0, raw));
+                }
+            }
             hooks.onChatDone?.(); // 主 agent:spinner.stop()
             // lastUsage 已更新:触发状态行 context 用量条重算+重画,运行中不再冻结在轮首。
             onContextUpdate?.();
             if (result.toolCalls.length > 0) {
                 hadToolsThisTurn = true;
-                // 正文与工具批次的分隔由 onToolBatchStart 连同摘要一次性提交，避免两次写屏错位。
+                // 流式正文末尾补换行(若 onToolCall 已补则 lastChar='\n',此处 no-op);防 ● 行黏在正文行尾
+                if (mode !== 'idle' && lastChar !== '\n')
+                    hooks.onTextEnd?.();
                 // 带工具调用的 assistant 消息原样回灌(OpenAI 格式要求)
                 history.push({
                     role: 'assistant',
@@ -309,36 +291,39 @@ export async function runAgentCore(opts) {
                         function: { name: tc.name, arguments: tc.arguments },
                     })),
                 });
-                // 工具分组执行(保 tool_calls 原顺序):连续的只读工具(READ_TOOL_NAMES)成组并发——一次性启动全部
-                // executeTool(调用即开始 I/O),再按原顺序逐个 await + 渲染(● 头与 ↳ 结果紧邻,修并行时"全 ● 后全 ↳"分离)。
+                // 工具分组执行(保 tool_calls 原顺序):连续的只读工具(READ_TOOL_NAMES)成组并发——先一次性
+                // 渲染全部 header，让摘要在任何同步工具真正执行前立即可见；随后启动全部 executeTool，
+                // 再按原顺序逐个 await + 回灌结果。
                 // mutation(write_file/edit_file)及 run_command/use_skill 各为单步串行屏障——mutation 串行保
                 // recordMutation 调用序 = 回滚快照序(executeTool 内写前记 before 快照,同文件多次写需按序)。
                 // 渲染与 history 回灌一律按原顺序;并发只影响执行时序,tool_call_id 仍按序配对。
                 // executeTool 永不抛错(调度器 try/catch 返字符串),故 await 单个 promise 不会抛(永远 resolve 为字符串)。
                 const calls = result.toolCalls;
-                hooks.onToolBatchStart?.(calls);
                 let i = 0;
                 while (i < calls.length) {
                     if (READ_TOOL_NAMES.has(calls[i].name)) {
-                        // 收集连续只读组(≥1),并发执行:先一次性启动所有(executeTool 调用即开始 I/O),
-                        // 再按原顺序逐个 await + 渲染——● 头与 ↳ 结果紧邻、顺序 = tool_calls 序(修"全 ● 后全 ↳"分离 bug)。
+                        // 收集连续只读组(≥1),并发执行:先渲染所有 header，再一次性启动所有
+                        // (executeTool 调用即开始 I/O)，最后按原顺序逐个 await + 回灌。
+                        // 必须先 header 后 execute：todolist/grep 等同步快速工具会在 executeTool 返回 Promise 前
+                        // 已经完成；若先 started.map，用户只能在工具完成后才看到摘要与其前面的换行。
                         // 异步工具(web_fetch 等)并发跑、总耗时 ≈ 最慢一个;同步工具(glob/grep)map 时已顺序跑完,await 即返。
                         let j = i;
                         while (j < calls.length && READ_TOOL_NAMES.has(calls[j].name))
                             j++;
                         const batch = calls.slice(i, j);
+                        for (const tc of batch)
+                            hooks.onToolHeader?.(tc);
+                        hooks.onToolStart?.(batch[0].name);
                         const started = batch.map((tc) => executeTool(tc.name, tc.arguments, signal, { skipRollback, dropContext }));
                         for (let k = 0; k < batch.length; k++) {
                             const tc = batch[k];
-                            hooks.onToolHeader?.(tc);
-                            hooks.onToolStart?.(tc.name);
                             const output = await started[k];
-                            hooks.onToolDone?.();
                             hooks.onToolResult?.(tc, output, null, null, 1); // 只读工具无 diff
                             // Thrashing:history 里附 hint(UI 已用干净 output 渲染,避免屏幕噪声)
                             const hint = recordAndHint(tc.name, tc.arguments);
                             pushToolResult(history, tc, hint ? `${output}${hint}` : output, relprune, lifecycle, scheduler);
                         }
+                        hooks.onToolDone?.();
                         i = j;
                     }
                     else if (calls[i].name === 'task') {

package/dist/agent/index.js

@@ -12,6 +12,8 @@ import { beginTurn } from '../rollback/index.js';
 import { config } from '../config/index.js';
 import { runAgentCore, isMutationTool, } from './core.js';
 import { createPetHooks } from '../pet/state.js';
+/** 当前 turn 的 batch id(runAgent 内闭包变量;一条 turn 一轮 tool batch 结束即清空)。 */
+let currentBatchId = null;
 /** 取 userInput 的首行:字符串直接 split;多模态 parts 找首个 text part 再 split。 */
 function firstLineOf(ui) {
     if (typeof ui === 'string')
@@ -19,24 +21,24 @@ function firstLineOf(ui) {
     const first = ui.find((p) => p.type === 'text');
     return first?.text.split('\n')[0] ?? '';
 }
-/** 完整工具批次一拿到就聚合成一行写屏，结果随后回填到同一可展开项。 */
-function writeToolBatch(calls, leadingBlank) {
-    const id = batch.beginBatch();
-    for (const tc of calls) {
-        batch.recordCall(id, tc.name, summarizeToolCall(tc.name, tc.arguments));
-    }
-    batch.showPendingBatch(id, layout, leadingBlank);
-    return id;
-}
-function appendToolBatch(id, calls) {
-    batch.appendPendingCalls(id, calls.map((tc) => ({
-        name: tc.name,
-        callSummary: summarizeToolCall(tc.name, tc.arguments),
-    })), layout);
+/** 工具调用 ● 头:工具名 + 参数摘要(按 tool_calls 原顺序打印,让用户看到本轮跑哪些工具)。
+ *  重构后改为累积到 BatchRenderer,onToolBatchEnd 时统一打摘要行;
+ *  展开/折叠由 BatchRenderer + 鼠标 release 决定,本函数不再直接写屏。 */
+function writeToolHeader(tc) {
+    // 改文件工具是 batch 屏障：先收尾之前的普通工具，确保 mutation 永远独占一批。
+    if (isMutationTool(tc.name))
+        flushToolBatch();
+    if (!currentBatchId)
+        currentBatchId = batch.beginBatch();
+    batch.recordCall(currentBatchId, tc.name, summarizeToolCall(tc.name, tc.arguments));
+    // 第一条工具开始时立即落摘要；后续调用加入同一 batch，并原地刷新计数。
+    batch.showLiveBatch(currentBatchId, layout);
 }
 /** 渲染工具结果:mutation 成功走 diff 块(行号 + 语法高亮,仿 Claude Code);其余走一行 preview。
  *  同 writeToolHeader,改为累积到 BatchRenderer(只缓存字符串,不写屏)。 */
-function writeToolResult(batchId, tc, output, parsed, preWriteOld, editStartLine) {
+function writeToolResult(tc, output, parsed, preWriteOld, editStartLine) {
+    if (!currentBatchId)
+        return;
     let diff = null;
     if (isMutationTool(tc.name) && parsed && !output.startsWith('错误')) {
         diff = renderFileChange({
@@ -50,7 +52,25 @@ function writeToolResult(batchId, tc, output, parsed, preWriteOld, editStartLine
         });
     }
     const preview = diff ? '' : summarizeToolResult(tc.name, output);
-    batch.completePendingBatch(batchId, tc.name, preview, diff, output, layout);
+    batch.recordResult(currentBatchId, tc.name, preview, diff, output);
+    // mutation 结果（成功 diff 或错误输出）立即可见，并阻止后续普通工具并入这一批。
+    if (isMutationTool(tc.name))
+        flushToolBatch(true);
+}
+/** 将跨 LLM 工具轮次累计的调用写入内容区；正文开始或整个 turn 收尾时才切批。 */
+function flushToolBatch(expandSingleEntry = false) {
+    if (!currentBatchId)
+        return;
+    const id = currentBatchId;
+    currentBatchId = null;
+    batch.endBatch(id, layout);
+    if (expandSingleEntry)
+        batch.expandSingleEntryFully(id, layout);
+    // 普通摘要只有一个“当前空行”，再 break 一次把它提交为分隔空行。
+    // mutation 自动展开时 content.insertAfter 已先把该当前空行提交到 rows；若这里仍补 \n，
+    // diff 后就会固定出现两条空白行。
+    if (!expandSingleEntry)
+        layout.contentWrite('\n');
 }
 /**
  * agent 核心循环(主 agent,TUI 渲染版):
@@ -72,6 +92,7 @@ onContextUpdate) {
     // 开新轮次(回滚用):首行截断 40,供 /rollback 轮次菜单展示。
     beginTurn(truncateDisplay(firstLineOf(userInput), 40));
     layout.contentMode(); // 防御性:运行态光标归输入框光标位供 IME 锚定(enterRunningMode 已置,这里兜底)
+    currentBatchId = null; // 新 turn 清旧 batch id(防上 turn 残留)
     // spinner:状态行最前面转圈(思考中 / 生成 / 执行 工具时,状态栏 lead 位显帧 + 文字)。
     // 经 setStatus 注入状态行(spinnerFrame + statusText),composeStatus 把帧 + 文字放 lead 位;
     // 不画内容区续写位——内容区在等待期间保持干净,首 token 到达即从续写位开始写正文。
@@ -81,29 +102,46 @@ onContextUpdate) {
     // lastChar 镜像:core 跟踪流式末字符决定补换行,但 TUI hooks 需读它决定 layout.contentWrite('\n')。
     // core 的 onTextEnd hook 只在 lastChar !== '\n' 时才调,调后置 '\n';镜像与此同步。
     let lastChar = '';
-    let visibleBlock = 'none';
-    let currentBatchId = null;
+    // 正文 -> 工具的边界由 core.onTextEnd 与本层 onToolCall 分两段完成。
+    // markdown 段末已经是完整物理行，因此再写 1 个 \n 就代表 1 条空白行；
+    // 不能按普通字符串的“两个换行才有一个空行”来计算。
+    let textBoundaryNewlines = 0;
+    let hasPendingTextBoundary = false;
+    let toolBatchFollowsText = false;
     const hooks = {
         onText: (s) => {
+            // 纯空白 chunk 在视觉上不是正文：既不切 batch，也不写入 markdown 缓冲。
+            // 部分兼容后端会在连续工具轮次间流出 " " / "\n"，若据此切批会漏掉首个工具。
+            if (currentBatchId && s.trim().length === 0)
+                return;
+            const followsToolBatch = currentBatchId !== null;
+            // batch 收尾已经统一留了一条空白行。部分后端会把下一段正文以 \n / \n\n
+            // 开头发来；去掉这些“边界换行”，避免与 UI 分隔叠成两条空白行。
+            const visible = followsToolBatch ? s.replace(/^(?:[ \t]*\r?\n)+/, '') : s;
+            if (s)
+                flushToolBatch();
             spinner.stop(); // 任何正文 token 都停 spinner(首 token 停「思考中」;onToolCall 重启后若又来文本则停「生成中」)。未旋转时 stop 为 no-op。
-            const hasVisibleText = s.trim().length > 0;
-            let expandedBatchHasBlankTail = false;
-            if (hasVisibleText && currentBatchId) {
-                batch.finalizePendingBatch(currentBatchId, layout);
-                // 展开详情通过中段插入，原摘要后的空行会保留在详情尾部；无需再补一次。
-                expandedBatchHasBlankTail = batch.isExpanded(currentBatchId);
-                currentBatchId = null;
+            layout.contentWriteMd(visible); // 正文走 markdown 渲染(代码块高亮 / 标题 / 列表 / 行内 …),见 ui/markdown.ts
+            if (visible) {
+                lastChar = visible[visible.length - 1];
+                if (visible.trim().length > 0) {
+                    hasPendingTextBoundary = true;
+                    textBoundaryNewlines = 0;
+                }
             }
-            const leadingBlank = hasVisibleText && visibleBlock === 'tool' && !expandedBatchHasBlankTail;
-            layout.contentWriteMd(s, leadingBlank); // 分隔与正文同次重绘，避免续写位二次定位多出空行
-            if (hasVisibleText)
-                visibleBlock = 'text';
-            if (s)
-                lastChar = s[s.length - 1];
         },
         onToolCall: (name) => {
             // 文本/思考已流完,模型转而生成 tool_call 参数(可能很长,如 write_file 整篇内容):
             // 补换行(让随后的 ● 行与 diff 不黏在正文末尾)+ 启「生成中」内联 spinner,内容区不再干等。
+            if (hasPendingTextBoundary) {
+                toolBatchFollowsText = true;
+                if (textBoundaryNewlines < 1) {
+                    layout.contentWrite('\n');
+                }
+                lastChar = '\n';
+                textBoundaryNewlines = 1;
+                hasPendingTextBoundary = false;
+            }
             if (name)
                 spinner.start(`生成 ${name}`);
         },
@@ -113,42 +151,48 @@ onContextUpdate) {
             if (lastChar && lastChar !== '\n') {
                 layout.contentWrite('\n');
                 lastChar = '\n';
+                if (hasPendingTextBoundary)
+                    textBoundaryNewlines = 1;
             }
         },
-        onToolBatchStart: (calls) => {
-            if (currentBatchId)
-                appendToolBatch(currentBatchId, calls);
-            else
-                currentBatchId = writeToolBatch(calls, visibleBlock !== 'none');
-            visibleBlock = 'tool';
+        onToolHeader: (tc) => {
+            // mutation 的自动展开会把 current/committed 空行状态互相转换；在首摘要真正
+            // 落屏前按视觉行归一，避免同样的文本→edit 边界偶发 1 行或 2 行。
+            if (toolBatchFollowsText && isMutationTool(tc.name)) {
+                layout.normalizeMutationBoundary();
+            }
+            toolBatchFollowsText = false;
+            writeToolHeader(tc);
         },
-        onToolHeader: () => { },
         onToolStart: (name) => spinner.start(`执行 ${name}`),
         onToolDone: () => spinner.stop(),
-        onToolResult: (tc, output, parsed, preWriteOld, editStartLine) => {
-            if (currentBatchId) {
-                writeToolResult(currentBatchId, tc, output, parsed, preWriteOld, editStartLine);
-            }
+        onToolResult: (tc, output, parsed, preWriteOld, editStartLine) => writeToolResult(tc, output, parsed, preWriteOld, editStartLine),
+        onToolBatchEnd: () => {
+            // 一次工具轮次结束不再切 UI batch；下一轮若仍无正文，继续复用 currentBatchId。
+        },
+        onNoReply: () => {
+            flushToolBatch();
+            layout.contentWrite(`${ui.dim}(无回复)${ui.reset}\n`);
+        },
+        onMaxSteps: () => {
+            flushToolBatch();
+            layout.contentWrite(`  ${ui.yellow}●${ui.reset} ${ui.yellow}达到最大步数(${config.maxSteps}),本轮停止。${ui.reset}\n`);
         },
-        // 连续无正文的工具步骤保持同一 batch；遇到正文或本轮结束时才收尾。
-        onToolBatchEnd: () => { },
-        onNoReply: () => layout.contentWrite(`${ui.dim}(无回复)${ui.reset}\n`),
-        onMaxSteps: () => layout.contentWrite(`  ${ui.yellow}●${ui.reset} ${ui.yellow}达到最大步数(${config.maxSteps}),本轮停止。${ui.reset}\n`),
         onAbort: () => {
             spinner.stop();
-            if (currentBatchId)
-                batch.finalizePendingBatch(currentBatchId, layout);
-            currentBatchId = null;
             if (lastChar && lastChar !== '\n')
                 layout.contentWrite('\n');
+            flushToolBatch();
             layout.contentWrite(`${ui.dim}(已中断)${ui.reset}\n`);
         },
         onDone: (elapsedMs, usage) => {
-            if (currentBatchId)
-                batch.finalizePendingBatch(currentBatchId, layout);
-            currentBatchId = null;
+            flushToolBatch();
             const tok = formatTurnTokens(usage);
             layout.contentWrite(`  ${ui.dim}✻ Worked for ${fmtElapsed(elapsedMs)}${tok}${ui.reset}\n`);
+            // 内容区触底时，DECSTBM 增量滚屏可能只推进物理终端，未把 Worked 前已在
+            // buffer 中的空行完整画出来；用户滚动/点击触发 repaint 后才“突然”出现。
+            // 轮次收尾立即按 buffer 原子重画，使未满屏与触底滚屏的布局一致。
+            layout.repaintViewport();
         },
     };
     // 桌宠状态广播:与 TUI hooks 并列注入,互不干扰(petHooks 只调 bridge.sendState,不写屏;

package/dist/agent/spawn.js

@@ -7,8 +7,8 @@
 //  - 独立 history:不共享主对话,避免子任务的工具噪声污染主上下文。
 //  - 系统提示复用主 agent 组装链(config.systemPrompt + memory 段 + skills 段)+ 子 agent 角色后缀。
 //  - 工具子集:按白名单从 chatTools 过滤;无白名单 = 全量(但 task 工具调用方通常会限定只读)。
-//  - 不调 beginTurn(不进主回滚链);但文件 mutation 仍经 executeTool→recordMutation,
-//    归入当前主轮次(语义:子 agent 的改动属于当前主轮,可随 /rollback 一起撤销)。
+//  - 不调 beginTurn(不进主回滚链);skipRollback=true 使文件 mutation 跳过 recordMutation,
+//    子 agent 的改动不进主回滚快照链(靠 git 兜底,见下方 skipRollback 注释)。
 //  - 步数上限默认更低(config.subAgentMaxSteps ?? 50),防子任务失控耗尽配额。
 //  - 中断透传:opts.signal(主 agent 的 abort signal)透传给 runAgentCore → chat/executeTool,
 //    主 Ctrl+C 树杀子 agent(chat 流式 abort + run_command/web_fetch 即时取消)。
@@ -21,6 +21,7 @@ import { buildMemorySection, buildMemoryIndexSection } from '../memory/index.js'
 import { ui } from '../ui/theme.js';
 import { runAgentCore } from './core.js';
 import { summarizeToolCall, summarizeToolResult, truncateDisplay } from '../ui/render.js';
+import { createContextState } from '../session/compact.js';
 /** 子 agent 系统提示后缀:角色与约束。 */
 const SUBAGENT_SUFFIX = `
 
@@ -115,6 +116,9 @@ export async function spawnAgent(opts) {
         // onStepStart / onChatDone / onToolStart / onToolDone / onAbort:子 agent 静默,无需 spinner / 中断渲染。
         // abort 还原(history 还原 + 模式还原)由 core 的 abortRestore 处理,hooks 只管展示。
     };
+    // 每个子 agent 独享统计/预算状态。不能保存再恢复模块级单例：多个 task 并发时
+    // save/restore 会竞态，且 lastEstimate / schedulerLog 仍会污染主 agent。
+    const localContextState = createContextState();
     const result = await runAgentCore({
         history,
         userInput: opts.prompt,
@@ -123,6 +127,7 @@ export async function spawnAgent(opts) {
         maxSteps,
         toolsOverride,
         skipRollback: true, // 逻辑隔离:子 agent 文件改动不进主回滚快照链,主 /rollback 不撤销(靠 git 兜底)
+        contextState: localContextState,
     });
     return {
         summary: result.finalText,

package/dist/config/index.js

@@ -223,7 +223,6 @@ ${buildSnapshotSection()}${config.projectSkillEnabled ? buildProjectSkillSection
 
 ## Working notepad (todolist)
 - For genuinely complex tasks only: explore codebase → clarify with user → create plan → execute step by step. See tool description for details.
-- **Update the plan after each step** — do NOT batch all status updates at the end. The progress chip must reflect real-time state.
 
 ## Termination & Reporting
 - Stop immediately when no more tools are needed; give conclusions directly.

package/dist/context/budget.js

@@ -25,6 +25,7 @@
 // 开关(MOCODE_BUDGET_SCHEDULER):默认 true。false 时 agent/core.ts 走老路径
 //      (直接 maybeCompact),完全跳过本模块,零行为变化。
 import { estimateMessagesTokens, estimateTokens } from '../llm/index.js';
+import { toText } from './utils.js';
 /** 五区分账(占比对齐 CONTEXT_WINDOW)。顺序固定,便于遍历。 */
 export const BUDGET_LAYERS = [
     'system',
@@ -52,19 +53,6 @@ export const HOT_TURN_WINDOW = 4;
  * Cold 区内:age ≥ TOOL_OLD_AGE 的非观察类工具结果可被调度器就地 stub。
  * 默认 2 = 跨过 2 个消费者 push 仍未被消费,等同 lifecycle 的 DEFAULT_AGE_THRESHOLD。 */
 export const TOOL_OLD_AGE = 2;
-/** 把每条 token 拍平成字符串(只估 token,不深解析工具调用)。 */
-function toText(content) {
-    if (content == null)
-        return '';
-    if (typeof content === 'string')
-        return content;
-    try {
-        return JSON.stringify(content);
-    }
-    catch {
-        return String(content);
-    }
-}
 function msgTokens(m) {
     const c = m.content;
     const tcs = m.tool_calls;
@@ -75,14 +63,6 @@ function msgTokens(m) {
     // 与 llm.estimateTokens 同公式(CJK 1/字,ASCII 1/4字);保证调度器评估与系统估算口径一致。
     return 4 + estimateTokens(extra);
 }
-/** 从 history 末尾向前找最后一个 user 消息的索引;无 user 返 -1。 */
-export function lastUserIndex(history) {
-    for (let i = history.length - 1; i >= 1; i--) {
-        if (history[i].role === 'user')
-            return i;
-    }
-    return -1;
-}
 /** 从 idx 处向前数第 N 个 user turn 的边界 index(含该 user 之后的内容)。
  * 用于把 history 切成 Hot 区(tail 一段,endExclusive=history.length)与 Cold 区(0..endExclusive)。
  * 若 N 个 user 不足,Hot 区 = history.length(全保护);Cold 区空,无压缩目标。 */
@@ -98,16 +78,19 @@ export function userTurnBoundary(history, window) {
     return 1; // 没攒够 N 个 user 之前的全归 Cold(history[0] system 不动)
 }
 /** 评估当前 history 的五区预算(纯函数,改不动 history)。
- * 传入 step 是当前所在 step 编号(agent 循环 step 变量),用于日志/调试。 */
-export function evaluateBudget(history, window, step = 0) {
+ * 传入 step 是当前所在 step 编号(agent 循环 step 变量),用于日志/调试。
+ * correction:API 实测 / 估算的校正系数(默认 1);>1 表示粗估偏低,乘以系数后 actual 更接近真实值。 */
+export function evaluateBudget(history, window, step = 0, correction = 1) {
     const layers = {};
     for (const k of BUDGET_LAYERS) {
         const budget = Math.floor(BUDGET_RATIO[k] * window);
         layers[k] = { actual: 0, budget, overBudget: false, overRatio: 0 };
     }
+    // 校正后的 token 数:raw * correction,最小 1(raw > 0 时)。
+    const adj = (raw) => (raw > 0 ? Math.max(1, Math.round(raw * correction)) : 0);
     const sysMsg = history[0];
     if (sysMsg)
-        layers.system.actual = msgTokens(sysMsg);
+        layers.system.actual = adj(msgTokens(sysMsg));
     // Summary 检测:role:'system' 且不是 history[0] 的,视为摘要(compact.ts 摘要插 index 1)。
     // 简单启发:若 history[1]?.role === 'system' 且 content 含「# 会话摘要」特征串,计入 summary。
     // 命中时循环跳过 i=1;不命中时当作普通 message(罕见,落到下方 user/assistant 分支)。
@@ -115,7 +98,7 @@ export function evaluateBudget(history, window, step = 0) {
     if (history.length > 1 && history[1].role === 'system') {
         const c1 = toText(history[1].content);
         if (c1.startsWith('# 会话摘要') || c1.includes('会话摘要')) {
-            layers.summary.actual = msgTokens(history[1]);
+            layers.summary.actual = adj(msgTokens(history[1]));
             summaryHit = true;
         }
     }
@@ -127,7 +110,7 @@ export function evaluateBudget(history, window, step = 0) {
         if (i === 1 && summaryHit)
             continue; // summary 已单独算过
         if (m.role === 'tool') {
-            const t = msgTokens(m);
+            const t = adj(msgTokens(m));
             if (i >= hotStart)
                 layers.toolRecent.actual += t;
             else
@@ -135,7 +118,7 @@ export function evaluateBudget(history, window, step = 0) {
         }
         else if (m.role !== 'system') {
             // user / assistant 全部计入 history(对话轨迹)
-            layers.history.actual += msgTokens(m);
+            layers.history.actual += adj(msgTokens(m));
         }
         // 其它 system(几乎不存在)跳过
     }
@@ -152,7 +135,8 @@ export function evaluateBudget(history, window, step = 0) {
     // 按 overRatio 降序
     triggers.sort((a, b) => layers[b].overRatio - layers[a].overRatio);
     const total = BUDGET_LAYERS.reduce((s, k) => s + (k === 'reserve' ? 0 : layers[k].actual), 0);
-    const totalOver = total >= 0.85 * window;
+    // 安全裕量:用 0.82 而非 0.85,预留 3% 给 correction 波动与新消息增量。
+    const totalOver = total >= 0.82 * window;
     return {
         step,
         total,
@@ -161,19 +145,24 @@ export function evaluateBudget(history, window, step = 0) {
         triggers,
         totalOver,
         hotBoundary: hotStart,
+        correction,
     };
 }
-/** 根据 BudgetReport 生成调度动作(从轻到重,直至总占用回落到 0.85 以下)。
+/** 根据 BudgetReport 生成调度动作(从轻到重,直至总占用回落到阈值以下)。
  * 规则:
  *   - system 超 → warn(不压,配置问题不是内容问题)
  *   - toolOld 超 → 先 L1(中截超大)→ L2(same-path 已有 relevance)→ L3(age stub,新增)
  *   - toolRecent 超 → cap(只降低单条上限,不 stub)
  *   - history 超 或 totalOver → compact_history(调 maybeCompact / compactHistory)
- *   - summary 超 → 不动(摘要本身就压缩产物,删它等于丢历史,只能放任或扩 Recent 预算) */
+ *   - summary 超 → 不动(摘要本身就压缩产物,删它等于丢历史,只能放任或扩 Recent 预算)
+ *
+ * 安全裕量:headroom 按 0.80 * window - total * 1.05 计算(预留 5% 应对 correction 误差
+ * 与新消息增量),避免估算偏差导致被 API 硬截断。 */
 export function scheduleActions(report) {
     const actions = [];
     const { layers, totalOver, total } = report;
-    const headroom = 0.85 * report.window - total;
+    // 收紧:0.80 阈值(原 0.85)+ total * 1.05 放大(估算不确定性缓冲)
+    const headroom = 0.80 * report.window - total * 1.05;
     // system 超 → warn,不是 schedule 目标
     if (layers.system.overBudget) {
         actions.push({
@@ -196,8 +185,8 @@ export function scheduleActions(report) {
     if (layers.toolRecent.overBudget && layers.toolRecent.overRatio > 0.15) {
         actions.push({ kind: 'cap_hot_tools', aggressive: layers.toolRecent.overRatio > 0.5 });
     }
-    // History / total 超 → 摘要(最贵);headroom < -2K 真正触发,让 cold tools 先动
-    if ((layers.history.overBudget || totalOver) && headroom < -2000) {
+    // History / total 超 → 摘要(最贵);headroom < -1500 真正触发(原 -2000,裕量收紧后同步调低),让 cold tools 先动
+    if ((layers.history.overBudget || totalOver) && headroom < -1500) {
         actions.push({ kind: 'compact_history' });
     }
     // 排序(同 kind 已在上面排好):warn → cold L1→L2→L3 → cap_hot → compact_history

package/dist/context/index.js

@@ -10,4 +10,4 @@ export { optimizeToolResult } from './pipeline.js';
 export { classify, knownToolKinds } from './classifier.js';
 export { registerEncoder, registerAll, getEncoder, registeredKinds, } from './registry.js';
 // ── Context Budget Scheduler ───────────────────────────────────────────────
-export { evaluateBudget, scheduleActions, formatReport, quickEstimate, userTurnBoundary, lastUserIndex, BUDGET_LAYERS, BUDGET_RATIO, HOT_TURN_WINDOW, TOOL_OLD_AGE, } from './budget.js';
+export { evaluateBudget, scheduleActions, formatReport, quickEstimate, userTurnBoundary, BUDGET_LAYERS, BUDGET_RATIO, HOT_TURN_WINDOW, TOOL_OLD_AGE, } from './budget.js';