mocode-ai 0.5.4 → 0.5.5

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 {
@@ -167,45 +166,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 结果。
@@ -242,6 +207,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 前 + 模式还原。
@@ -293,12 +262,24 @@ export async function runAgentCore(opts) {
             }
             contextState.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;
+                    contextState.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 +290,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,22 @@ 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);
+    // 摘要本身已有行尾；再补一行，保持工具与后续正文/状态摘要之间的原有间距。
+    layout.contentWrite('\n');
 }
 /**
  * agent 核心循环(主 agent,TUI 渲染版):
@@ -72,6 +89,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 +99,44 @@ 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;
     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) {
+                if (textBoundaryNewlines < 1) {
+                    layout.contentWrite('\n');
+                }
+                lastChar = '\n';
+                textBoundaryNewlines = 1;
+                hasPendingTextBoundary = false;
+            }
             if (name)
                 spinner.start(`生成 ${name}`);
         },
@@ -113,42 +146,40 @@ 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: () => { },
+        onToolHeader: (tc) => writeToolHeader(tc),
         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/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';

package/dist/context/lifecycle.js

@@ -26,6 +26,7 @@
 //   - mutation 分支额外调 pushMutation 通知(也走 observeMutation 同语义)。
 //
 // 开关:`config.contextLifecycle`(默认 true;MOCODE_LIFECYCLE=false 回退)。
+import { extractPath, lastUserIndex, toText, toolNameOf } from './utils.js';
 /** 观察类工具(永远只到 REFERENCED,不参与自动 STUB)。 */
 const OBSERVER_TOOLS = new Set([
     'grep',
@@ -45,61 +46,6 @@ const STUB_PREFIX_NO_CONSUMER = '⌦[无消费者:观察结果已无引用价值
  *  ≥ 这个值且仍为 LIVE 且非观察类 → 视为 OBSOLETE → STUB。
  *  默认 2:等价于「跨过两个消费者 push 仍无人引用」= 跨过整轮最末尾的工具调用。 */
 const DEFAULT_AGE_THRESHOLD = 2;
-/** 复用 drop.ts 的取 path 思路,但本层要支持更多字段名(read_file/edit_file/write_file 都有 path;
- *  edit_file 还可能有 file_path,但这里只看 path,保持单一)。 */
-function extractPath(argsRaw) {
-    if (!argsRaw)
-        return null;
-    let parsed;
-    try {
-        parsed = JSON.parse(argsRaw);
-    }
-    catch {
-        return null;
-    }
-    if (!parsed || typeof parsed !== 'object')
-        return null;
-    const p = parsed.path;
-    return typeof p === 'string' && p ? p : null;
-}
-/** 从 tool 消息往前找匹配的 assistant.tool_calls 拿 tool 名。找不到返 null(保守跳过)。 */
-function toolNameOf(history, idx) {
-    const tcId = history[idx].tool_call_id;
-    if (!tcId)
-        return null;
-    for (let j = idx - 1; j >= 1; j--) {
-        const m = history[j];
-        if (m.role !== 'assistant')
-            continue;
-        const tcs = m.tool_calls;
-        if (!tcs)
-            continue;
-        const hit = tcs.find((tc) => tc?.id === tcId);
-        if (hit)
-            return hit.function?.name ?? null;
-    }
-    return null;
-}
-/** 找最后一个 user 消息索引;无 user 返 -1。 */
-function lastUserIndex(history) {
-    for (let i = history.length - 1; i >= 1; i--) {
-        if (history[i].role === 'user')
-            return i;
-    }
-    return -1;
-}
-function toText(content) {
-    if (content == null)
-        return '';
-    if (typeof content === 'string')
-        return content;
-    try {
-        return JSON.stringify(content);
-    }
-    catch {
-        return String(content);
-    }
-}
 /** 从 tool 结果的 content 中提取「生产者命中过的 path 列表」。
  *  - read_file:没有 path 列表(本身就是单 path 消费者,无需再追生产者)。
  *  - grep:content 是 `file:line: ...` 行,提取每行的 file 段(只保留绝对路径形态或与 pattern 匹配的)。

package/dist/context/relevance.js

@@ -22,71 +22,10 @@
 //   - TUI 渲染(hooks.onToolResult)用原始 output,与本层解耦——屏上看全量,LLM 看裁剪后版。
 //
 // 零行为变化兜底:开关 `config.contextRelprune` 关闭时,pipeline 路径完全不调本模块。
+import { extractPath, lastUserIndex, toText, toolNameOf } from './utils.js';
 /** stub 标记前缀(供幂等判定)。drop_context 用的是「⌦[已剔除:与当前任务无关]」,
  *  本层用「⌦[已过时:同 path 已有新 read / 已被 mutation 覆写]」,区分两类剔除来源。 */
 const STUB_PREFIX = '⌦[已过时:同 path 已有新 read / 已被 mutation 覆写]';
-/** 解析工具 arguments(只关心 path);非法返 null。 */
-function extractPath(argsRaw) {
-    if (!argsRaw)
-        return null;
-    let parsed;
-    try {
-        parsed = JSON.parse(argsRaw);
-    }
-    catch {
-        return null;
-    }
-    if (!parsed || typeof parsed !== 'object')
-        return null;
-    const p = parsed.path;
-    if (typeof p !== 'string' || !p)
-        return null;
-    return p;
-}
-/** 从 history 末尾向前找最后一个 user 消息的索引;无 user 返 -1。
- *  复用 drop.ts 的思路:user 及其之后的 tool 结果视为当前轮保护区。
- *  在本层里,read_file tool 消息若落在 user 之后,本轮还在用,不能 stub。
- *  注:history[0] 是 system,user 不会落在 0;若 user 就在末尾(即 0 user 之后),
- *  protectedFrom=0 时整段历史都不可 stub(实际不会发生:pushToolResult 必在 user 之后)。 */
-function lastUserIndex(history) {
-    for (let i = history.length - 1; i >= 1; i--) {
-        if (history[i].role === 'user')
-            return i;
-    }
-    return -1;
-}
-/** 取 tool 消息对应的工具名(从紧邻的前导 assistant.tool_calls 按 tool_call_id 配对找)。
- *  返回 null 表示找不到(孤儿 tool,极少见),本层保守不动。 */
-function toolNameOf(history, idx) {
-    const tcId = history[idx].tool_call_id;
-    if (!tcId)
-        return null;
-    for (let j = idx - 1; j >= 1; j--) {
-        const m = history[j];
-        if (m.role !== 'assistant')
-            continue;
-        const tcs = m.tool_calls;
-        if (!tcs)
-            continue;
-        const hit = tcs.find((tc) => tc?.id === tcId);
-        if (hit)
-            return hit.function?.name ?? null;
-    }
-    return null;
-}
-/** 把 content 拍平成字符串(对齐 drop.ts)。 */
-function toText(content) {
-    if (content == null)
-        return '';
-    if (typeof content === 'string')
-        return content;
-    try {
-        return JSON.stringify(content);
-    }
-    catch {
-        return String(content);
-    }
-}
 /**
  * 维护「path → 该 path 所有 read_file tool 消息的 history index」映射。
  *  - observePush:把刚 push 的 read_file tool 消息登记,并把同 path 的"更早" read 全部 stub。