mocode-ai 0.6.4 → 0.6.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, estimateMessagesTokens, estimateToolSchemaTokens, planChatTools, } from '../llm/index.js';
+import { chat, estimatePromptTokens, planChatTools, chatTools, } from '../llm/index.js';
 import { executeTool, tools } from '../tools/registry.js';
 import { checkPermission } from '../permissions/index.js';
 import { getPlanDisabledTools } from '../tools/constants.js';
@@ -18,6 +18,7 @@ import { isToolResultSuccess } from '../context/utils.js';
 import { config } from '../config/index.js';
 import { jailResolve } from '../sandbox/index.js';
 import { createLifecycleEngine } from '../context/lifecycle.js';
+import { getTokenCalibration, updateTokenCalibration, } from '../context/token-calibration.js';
 /** 解析工具 arguments JSON;非法或空返 null(调用方据此降级到普通 preview)。 */
 function parseArgs(raw) {
     try {
@@ -236,15 +237,23 @@ export async function runAgentCore(opts) {
                 abortRestore();
                 return { completed: false, finalText: null };
             }
+            // 本步只计算一次实际工具集合，调度、请求和 usage 校准必须使用完全相同的 schema。
+            const activeTools = opts.toolsOverride
+                ?? (getAgentMode() === 'plan' ? planChatTools : chatTools);
+            const requestBaseURL = config.baseURL;
+            const requestModel = config.model;
+            const storedCalibration = getTokenCalibration(requestBaseURL, requestModel, activeTools);
+            runtimeContextState.correction = storedCalibration.correction;
+            runtimeContextState.calibrationSamples = storedCalibration.samples;
             // 步前:五区 Budget Scheduler 决策——按 ROI 调度(冷工具优先 / history 摘要最后)。
             // 开关关闭(scheduler=null)时退化回原 maybeCompact 路径,零行为变化。
             // 此时 spinner 已停,通知行干净。
             let historyRebuilt = false;
             if (scheduler) {
-                historyRebuilt = await scheduler.runStep(history, step);
+                historyRebuilt = await scheduler.runStep(history, step, activeTools);
             }
             else {
-                const compactResult = await maybeCompact(history, undefined, undefined, runtimeContextState);
+                const compactResult = await maybeCompact(history, undefined, undefined, runtimeContextState, activeTools);
                 historyRebuilt = compactResult?.historyRebuilt === true;
             }
             // compact 用新消息数组原地重建 history 后，旧 lifecycle 的数字 index 已全部失效。
@@ -259,11 +268,7 @@ export async function runAgentCore(opts) {
             lastChar = '';
             let result;
             try {
-                // 每步读实时模式:LLM 可能在上一步调 switch_mode 切了模式,这里立即用对应工具集
-                // (auto=chatTools 全量;plan=planChatTools 只读子集)。模式由 src/agent/mode.ts 单一持有。
-                // 调用方可传 toolsOverride 覆盖(子 agent 受限工具子集)。
-                result = await chat(history, { onText, onToolCall }, signal, opts.toolsOverride ??
-                    (getAgentMode() === 'plan' ? planChatTools : undefined));
+                result = await chat(history, { onText, onToolCall }, signal, activeTools);
             }
             catch (e) {
                 // 中断(用户运行中 Ctrl+C):chat() 抛 AbortError(signal.aborted)→ 还原 history + 模式 + return(不抛)。
@@ -278,15 +283,13 @@ export async function runAgentCore(opts) {
             }
             runtimeContextState.lastUsage = result.usage; // 供 /context 与状态行显示实测 token
             addUsage(result.usage); // 本轮累计:onDone 摘要行 + AgentRunResult.usage 透传
-            // 校正系数:API 实测 prompt_tokens / 估算 token。
-            // 每次 chat 响应后刷新,让下次 evaluateBudget 用更接近真实的 actual。
-            // 钳位 [0.5, 2.0]:防单次异常值(极短回复 / 空 history)导致系数跳变。
+            // 用本次实际发送的 tools 计算分母，再以 EWMA 更新 provider/model/tool-set 校准。
+            // 只持久化比例与样本数；无 usage 或短 prompt 时保持既有值。
             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));
-                }
+                const estimated = estimatePromptTokens(history, activeTools);
+                const updated = updateTokenCalibration(requestBaseURL, requestModel, activeTools, estimated, result.usage.promptTokens);
+                runtimeContextState.correction = updated.correction;
+                runtimeContextState.calibrationSamples = updated.samples;
             }
             hooks.onChatDone?.(); // 主 agent:spinner.stop()
             // lastUsage 已更新:触发状态行 context 用量条重算+重画,运行中不再冻结在轮首。

package/dist/context/budget.js

@@ -24,7 +24,7 @@
 //
 // 开关(MOCODE_BUDGET_SCHEDULER):默认 true。false 时 agent/core.ts 走老路径
 //      (直接 maybeCompact),完全跳过本模块,零行为变化。
-import { estimateMessagesTokens, estimateTokens } from '../llm/index.js';
+import { chatTools, estimateMessagesTokens, estimateToolSchemaTokens, messageTokens, } from '../llm/index.js';
 import { toText } from './utils.js';
 /** 五区分账(占比对齐 CONTEXT_WINDOW)。顺序固定,便于遍历。 */
 export const BUDGET_LAYERS = [
@@ -54,14 +54,8 @@ export const HOT_TURN_WINDOW = 4;
  * 默认 2 = 跨过 2 个消费者 push 仍未被消费,等同 lifecycle 的 DEFAULT_AGE_THRESHOLD。 */
 export const TOOL_OLD_AGE = 2;
 function msgTokens(m) {
-    const c = m.content;
-    const tcs = m.tool_calls;
-    let extra = toText(c);
-    if (tcs)
-        for (const tc of tcs)
-            extra += tc?.function?.arguments ?? '';
-    // 与 llm.estimateTokens 同公式(CJK 1/字,ASCII 1/4字);保证调度器评估与系统估算口径一致。
-    return 4 + estimateTokens(extra);
+    // 与请求预估复用同一实现，避免角色结构开销、多模态和 tool_calls 在两个预算路径中漂移。
+    return messageTokens(m);
 }
 /** 从 idx 处向前数第 N 个 user turn 的边界 index(含该 user 之后的内容)。
  * 用于把 history 切成 Hot 区(tail 一段,endExclusive=history.length)与 Cold 区(0..endExclusive)。
@@ -79,8 +73,9 @@ export function userTurnBoundary(history, window) {
 }
 /** 评估当前 history 的五区预算(纯函数,改不动 history)。
  * 传入 step 是当前所在 step 编号(agent 循环 step 变量),用于日志/调试。
- * correction:API 实测 / 估算的校正系数(默认 1);>1 表示粗估偏低,乘以系数后 actual 更接近真实值。 */
-export function evaluateBudget(history, window, step = 0, correction = 1) {
+ * correction:API 实测 / 估算的校正系数(默认 1);>1 表示粗估偏低,乘以系数后 actual 更接近真实值。
+ * activeTools 必须与下一次 chat() 实际发送的工具集合一致，避免 plan/子 agent 误算 schema。 */
+export function evaluateBudget(history, window, step = 0, correction = 1, activeTools = chatTools) {
     const layers = {};
     for (const k of BUDGET_LAYERS) {
         const budget = Math.floor(BUDGET_RATIO[k] * window);
@@ -89,8 +84,8 @@ export function evaluateBudget(history, window, step = 0, correction = 1) {
     // 校正后的 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 = adj(msgTokens(sysMsg));
+    // 工具 schema 与 system prompt 同属请求固定开销；必须计入总量才能可靠触发压缩。
+    layers.system.actual = adj((sysMsg ? msgTokens(sysMsg) : 0) + estimateToolSchemaTokens(activeTools));
     // Summary 检测:role:'system' 且不是 history[0] 的,视为摘要(compact.ts 摘要插 index 1)。
     // 简单启发:若 history[1]?.role === 'system' 且 content 含「# 会话摘要」特征串,计入 summary。
     // 命中时循环跳过 i=1;不命中时当作普通 message(罕见,落到下方 user/assistant 分支)。

package/dist/context/encoders/command.js

@@ -0,0 +1,201 @@
+import { stripAnsi } from './_util.js';
+const PAREN_DIAGNOSTIC = /^(.*)\((\d+),(\d+)\):\s*(error|warning|warn|fatal|note)\b\s*:?\s*(.*)$/i;
+const COL_DIAGNOSTIC = /^(.*):(\d+):(\d+):\s*(error|warning|warn|fatal|note)\b\s*:?\s*(.*)$/i;
+const LINE_DIAGNOSTIC = /^(.*):(\d+):\s*(error|warning|warn|fatal|note)\b\s*:?\s*(.*)$/i;
+const PASS_LINE = /^\s*(?:PASS\b|PASSED\b|✓|✔|✅|ok\b)/i;
+const FAIL_LINE = /^\s*(?:FAIL\b|FAILED\b|ERROR\b|✗|×|❌|not ok\b|●)/i;
+const TEST_SUMMARY = /^\s*(?:Test Suites?|Tests?|Ran\s+\d+|=+\s|\d+\s+(?:passed|failed|errors?))/i;
+const IMPORTANT_LINE = /\b(?:error|failed|failure|fatal|exception|panic)\b|not ok|[✗×❌]/i;
+const TEST_COMMAND = /\b(?:test|vitest|jest|pytest|mocha|ava|tap|cargo\s+test|go\s+test|dotnet\s+test)\b/i;
+function parseDiagnostic(line) {
+    const m = PAREN_DIAGNOSTIC.exec(line) ?? COL_DIAGNOSTIC.exec(line);
+    if (m) {
+        return { file: m[1], line: m[2], column: m[3], severity: m[4], message: m[5], continuation: [] };
+    }
+    const lineOnly = LINE_DIAGNOSTIC.exec(line);
+    if (!lineOnly)
+        return null;
+    return {
+        file: lineOnly[1],
+        line: lineOnly[2],
+        severity: lineOnly[3],
+        message: lineOnly[4],
+        continuation: [],
+    };
+}
+function splitStatus(text) {
+    const lines = text.split('\n');
+    const status = /^\[(?:退出码 [^\]]+|已中断|超时,已终止)\]$/.test(lines[0] ?? '')
+        ? lines.shift()
+        : null;
+    return { status, lines };
+}
+function formatDiagnostics(lines) {
+    const diagnostics = [];
+    const other = [];
+    let current = null;
+    for (const line of lines) {
+        const diagnostic = parseDiagnostic(line);
+        if (diagnostic) {
+            diagnostics.push(diagnostic);
+            current = diagnostic;
+        }
+        else if (current && (/^\s+/.test(line) || /^[\^~|]/.test(line))) {
+            current.continuation.push(line);
+        }
+        else {
+            current = null;
+            other.push(line);
+        }
+    }
+    if (diagnostics.length === 0)
+        return null;
+    const groups = new Map();
+    for (const diagnostic of diagnostics) {
+        const group = groups.get(diagnostic.file) ?? [];
+        group.push(diagnostic);
+        groups.set(diagnostic.file, group);
+    }
+    const errors = diagnostics.filter((d) => /^(?:error|fatal)$/i.test(d.severity)).length;
+    const warnings = diagnostics.filter((d) => /^(?:warning|warn)$/i.test(d.severity)).length;
+    const out = [`# Build diagnostics · ${diagnostics.length} issues · ${groups.size} files · command-encoded`];
+    if (errors || warnings)
+        out.push(`# ${errors} errors · ${warnings} warnings`);
+    for (const [file, items] of groups) {
+        out.push(`${file}:`);
+        for (const item of items) {
+            const location = item.column ? `${item.line}:${item.column}` : item.line;
+            out.push(`  ${location}: ${item.severity}${item.message ? `: ${item.message}` : ''}`);
+            for (const continuation of item.continuation)
+                out.push(`    ${continuation}`);
+        }
+    }
+    if (other.some((line) => line.length > 0))
+        out.push('# Other output', ...other);
+    return { text: out.join('\n'), count: diagnostics.length };
+}
+function formatTests(lines, command) {
+    const blocks = [];
+    const other = [];
+    let current = null;
+    let markers = 0;
+    for (const line of lines) {
+        const kind = FAIL_LINE.test(line) ? 'fail' : PASS_LINE.test(line) ? 'pass' : null;
+        if (kind) {
+            current = { kind, lines: [line] };
+            blocks.push(current);
+            markers++;
+        }
+        else if (current && line.length > 0 && /^\s+/.test(line) && !TEST_SUMMARY.test(line)) {
+            current.lines.push(line);
+        }
+        else {
+            current = null;
+            other.push(line);
+        }
+    }
+    if (markers === 0 || (markers < 2 && !TEST_COMMAND.test(command)))
+        return null;
+    const failed = blocks.filter((block) => block.kind === 'fail');
+    const passed = blocks.filter((block) => block.kind === 'pass');
+    const out = [`# Test results · ${passed.length} passed · ${failed.length} failed · command-encoded`];
+    if (failed.length) {
+        out.push(`# Failed tests (${failed.length})`);
+        for (const block of failed)
+            out.push(...block.lines);
+    }
+    if (passed.length) {
+        out.push(`# Passed tests (${passed.length})`);
+        for (const block of passed)
+            out.push(...block.lines);
+    }
+    if (other.some((line) => line.length > 0))
+        out.push('# Test summary / other output', ...other);
+    return { text: out.join('\n'), count: markers };
+}
+function collapseDuplicateLines(text) {
+    const lines = text.split('\n');
+    const out = [];
+    let runs = 0;
+    for (let i = 0; i < lines.length;) {
+        let end = i + 1;
+        while (end < lines.length && lines[end] === lines[i])
+            end++;
+        const count = end - i;
+        if (count >= 3) {
+            out.push(`${lines[i]}  [×${count}]`);
+            runs++;
+        }
+        else {
+            for (let j = i; j < end; j++)
+                out.push(lines[j]);
+        }
+        i = end;
+    }
+    return { text: out.join('\n'), runs };
+}
+function errorTail(text, max) {
+    if (max <= 0)
+        return '';
+    const lines = text.split('\n');
+    let important = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (IMPORTANT_LINE.test(lines[i])) {
+            important = i;
+            break;
+        }
+    }
+    if (important < 0)
+        return text.slice(-max);
+    const fromError = lines.slice(Math.max(0, important - 1)).join('\n');
+    if (fromError.length <= max)
+        return fromError;
+    const joiner = '\n…[错误详情中段省略]…\n';
+    const errorHead = Math.max(0, Math.floor((max - joiner.length) * 0.65));
+    const finalTail = Math.max(0, max - joiner.length - errorHead);
+    return fromError.slice(0, errorHead) + joiner + fromError.slice(-finalTail);
+}
+function truncateCommand(text, budget) {
+    if (!budget || text.length <= budget)
+        return { text, truncated: false };
+    const marker = '\n…[command 输出已结构化截断；保留开头与错误尾部]…\n';
+    const available = budget - marker.length;
+    if (available <= 0)
+        return { text: marker.slice(0, budget), truncated: true };
+    const headSize = Math.floor(available * 0.45);
+    const tailSize = available - headSize;
+    return {
+        text: text.slice(0, headSize) + marker + errorTail(text, tailSize),
+        truncated: true,
+    };
+}
+/** run_command 专用 encoder：构建诊断分文件、测试结果分 pass/fail，并按错误尾部优先截断。 */
+export const commandEncoder = {
+    kind: 'log',
+    encode({ output, args, budget }) {
+        const stripped = stripAnsi(output).replace(/\r\n?/g, '\n');
+        const { status, lines } = splitStatus(stripped);
+        const command = typeof args?.command === 'string' ? args.command : '';
+        const diagnostics = formatDiagnostics(lines);
+        const tests = diagnostics ? null : formatTests(lines, command);
+        const structured = diagnostics?.text ?? tests?.text ?? lines.join('\n');
+        const withStatus = status ? `${status}\n${structured}` : structured;
+        const collapsed = collapseDuplicateLines(withStatus);
+        const fitted = truncateCommand(collapsed.text, budget);
+        const mode = diagnostics ? `build:${diagnostics.count}` : tests ? `tests:${tests.count}` : 'generic';
+        const notes = [mode, 'ANSI stripped'];
+        if (collapsed.runs)
+            notes.push(`${collapsed.runs} dup runs collapsed`);
+        if (fitted.truncated)
+            notes.push('head+error-tail truncated');
+        return {
+            text: fitted.text,
+            meta: {
+                kind: 'log',
+                originalLen: output.length,
+                encodedLen: fitted.text.length,
+                note: notes.join(', '),
+            },
+        };
+    },
+};

package/dist/context/encoders/index.js

@@ -11,7 +11,7 @@
 import { passthroughEncoder } from './passthrough.js';
 import { treeEncoder } from './tree.js';
 import { searchEncoder } from './search.js';
-import { logEncoder } from './log.js';
+import { commandEncoder } from './command.js';
 import { tableEncoder } from './table.js';
 import { memoryEncoder } from './memory.js';
 import { codeEncoder } from './code.js';
@@ -22,7 +22,7 @@ export const builtinEncoders = [
     passthroughEncoder,
     treeEncoder,
     searchEncoder,
-    logEncoder,
+    commandEncoder,
     tableEncoder,
     memoryEncoder,
     codeEncoder,

package/dist/context/encoders/log.js

@@ -1,52 +1,2 @@
-/**
- * Log Encoder(run_command):去 ANSI 颜色码 + 折叠连续重复行(≥3 → 单行 + [×N])。
- *
- * 输入:run_command 返回的 `[退出码 N]\n<合并 stdout+stderr>`,可能含 ANSI(tsc --pretty / 测试框架)、
- *  重复行(构建 / 编译日志)、尾部 `...(输出已截断)`、`[已中断]` / `[超时,已终止]` 前缀。
- * 输出:去 ANSI CSI 序列 + 连续重复行折叠;行顺序不变(退出码头恒在首、错误行与尾部原位保留)。
- *
- * 不变量(离线脚本断言):退出码行 `[退出码 N]` / `[已中断]` / `[超时,已终止]` 保留;
- *  重复行以 `[×N]` 标注计数(语义不丢——LLM 仍知该行重复 N 次);ANSI 去除语义无损(颜色码不含信息)。
- * 不做长度裁剪(由 pipeline 末尾 capToolResultForHistory 兜底 head+标记+tail,与改造前一致)。
- * run ≤2 原样保留(常见输出不必标注,避免噪音);run ≥3 才折叠(真正的大规模重复才省)。
- */
-const ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g;
-export const logEncoder = {
-    kind: 'log',
-    encode({ output }) {
-        // 去 ANSI CSI 序列(颜色 / 光标 / 清屏等),保留所有可见文本。
-        const stripped = output.replace(ANSI_RE, '');
-        const lines = stripped.split('\n');
-        // 折叠连续重复行:run ≥3 → 单行 + [×N];run ≤2 原样。
-        const out = [];
-        let i = 0;
-        let collapsedRuns = 0;
-        while (i < lines.length) {
-            let j = i;
-            while (j < lines.length && lines[j] === lines[i])
-                j++;
-            const run = j - i;
-            if (run >= 3) {
-                out.push(`${lines[i]}  [×${run}]`);
-                collapsedRuns++;
-            }
-            else {
-                for (let k = 0; k < run; k++)
-                    out.push(lines[i]);
-            }
-            i = j;
-        }
-        const text = out.join('\n');
-        return {
-            text,
-            meta: {
-                kind: 'log',
-                originalLen: output.length,
-                encodedLen: text.length,
-                note: collapsedRuns > 0
-                    ? `ANSI stripped, ${collapsedRuns} dup runs collapsed`
-                    : 'ANSI stripped',
-            },
-        };
-    },
-};
+/** @deprecated 使用 commandEncoder；保留别名避免破坏已有直接导入。 */
+export { commandEncoder as logEncoder } from './command.js';

package/dist/context/token-calibration.js

@@ -0,0 +1,104 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+const CACHE_VERSION = 1;
+const EWMA_ALPHA = 0.2;
+const MIN_CORRECTION = 0.5;
+const MAX_CORRECTION = 2;
+const MAX_ENTRIES = 64;
+let cache;
+const toolFingerprints = new WeakMap();
+function cachePath() {
+    return process.env.MOCODE_TOKEN_CALIBRATION_CACHE
+        || path.join(os.homedir(), '.mocode', 'token-calibration.json');
+}
+function hash(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function toolFingerprint(tools) {
+    const objectKey = tools;
+    const hit = toolFingerprints.get(objectKey);
+    if (hit)
+        return hit;
+    const fingerprint = hash(JSON.stringify(tools));
+    toolFingerprints.set(objectKey, fingerprint);
+    return fingerprint;
+}
+function calibrationKey(baseURL, model, tools) {
+    // 只把摘要写盘，避免 URL 中偶然携带的凭据出现在缓存文件。
+    return hash(`${baseURL}\0${model}\0${toolFingerprint(tools)}`);
+}
+function readCache() {
+    if (cache)
+        return cache;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(cachePath(), 'utf8'));
+        if (parsed.version === CACHE_VERSION && parsed.entries && typeof parsed.entries === 'object') {
+            cache = parsed;
+            return cache;
+        }
+    }
+    catch {
+        // 不存在或损坏都从空缓存开始；校准是增强能力，不能阻断请求。
+    }
+    cache = { version: CACHE_VERSION, entries: {} };
+    return cache;
+}
+function writeCache() {
+    if (!cache)
+        return;
+    try {
+        const entries = Object.entries(cache.entries)
+            .sort(([, a], [, b]) => b.updatedAt - a.updatedAt)
+            .slice(0, MAX_ENTRIES);
+        cache.entries = Object.fromEntries(entries);
+        const target = cachePath();
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        const tmp = `${target}.tmp-${process.pid}`;
+        fs.writeFileSync(tmp, JSON.stringify(cache), 'utf8');
+        fs.renameSync(tmp, target);
+    }
+    catch {
+        // 只影响跨进程复用；当前进程仍继续使用内存中的校准值。
+    }
+}
+function validEntry(entry) {
+    return !!entry
+        && Number.isFinite(entry.correction)
+        && entry.correction >= MIN_CORRECTION
+        && entry.correction <= MAX_CORRECTION
+        && Number.isInteger(entry.samples)
+        && entry.samples > 0;
+}
+/** 读取指定 provider/model/工具集合的历史校准；未命中时退回 1。 */
+export function getTokenCalibration(baseURL, model, tools) {
+    const entry = readCache().entries[calibrationKey(baseURL, model, tools)];
+    return validEntry(entry)
+        ? { correction: entry.correction, samples: entry.samples }
+        : { correction: 1, samples: 0 };
+}
+/** 用一次真实 prompt usage 更新 EWMA；只落比例和样本数，不保存任何消息内容。 */
+export function updateTokenCalibration(baseURL, model, tools, estimatedTokens, actualTokens) {
+    if (estimatedTokens <= 100
+        || actualTokens <= 100
+        || !Number.isFinite(estimatedTokens)
+        || !Number.isFinite(actualTokens)) {
+        return getTokenCalibration(baseURL, model, tools);
+    }
+    const key = calibrationKey(baseURL, model, tools);
+    const store = readCache();
+    const previous = store.entries[key];
+    const raw = Math.max(MIN_CORRECTION, Math.min(MAX_CORRECTION, actualTokens / estimatedTokens));
+    const correction = validEntry(previous)
+        ? previous.correction * (1 - EWMA_ALPHA) + raw * EWMA_ALPHA
+        : raw;
+    const next = {
+        correction,
+        samples: validEntry(previous) ? previous.samples + 1 : 1,
+        updatedAt: Date.now(),
+    };
+    store.entries[key] = next;
+    writeCache();
+    return { correction: next.correction, samples: next.samples };
+}

package/dist/llm/index.js

@@ -2,6 +2,7 @@ import OpenAI from 'openai';
 import { config } from '../config/index.js';
 import { tools } from '../tools/registry.js';
 import { getPlanDisabledTools } from '../tools/constants.js';
+import { ThinkTagFilter } from './think-filter.js';
 /**
  * LLM 调用重试策略:
  *   可重试  →  429 (rate limit) / 5xx (server) / APIConnectionError / Node 网络错 (ETIMEDOUT 等)
@@ -22,9 +23,6 @@ const RETRY_JITTER = 0.2;
  * 与 OpenAI 兼容协议的独立 `reasoning_content` 字段不同,这些模型把 thinking 直接嵌进 content
  * 字符串,期间不调 onText(spinner 持续转 ⠹ 思考中…),也不写入可见 content(history 不被思考段污染)。
  */
-// 用 \u003c 表示 <,绕开本工具对 < 的处理(直接写 '<\u003cthink\u003e' 里 < 会被吃掉)。
-const THINK_OPEN = '<think>';
-const THINK_CLOSE = '</think>';
 let client = new OpenAI({
     baseURL: config.baseURL,
     apiKey: config.apiKey,
@@ -276,15 +274,20 @@ async function chatOnce(messages, handlers, signal, toolsOverride) {
         ...(config.maxTokens ? { max_tokens: config.maxTokens } : {}),
         ...(config.includeUsage ? { stream_options: { include_usage: true } } : {}),
     }, signal ? { signal } : undefined);
-    // 流式  start end 标签过滤(见模块顶部 THINK_OPEN/CLOSE)。
-    // 跨 chunk 切分防御:buf 累积跨 chunk 边界,indexOf 扫描;为避免把跨 chunk 标签误判为
-    // 普通字符,buf 末尾为当前态保留 (label.length - 1) 个字符给下一 chunk 看。
+    // content 内嵌 think 标签由独立增量状态机过滤。它只暂存“可能组成标签”的后缀，
+    // 因而既能覆盖标签任意位置跨 chunk，也不会让普通正文固定延迟数个字符。
     let visibleContent = '';
     let consumedAny = false;
-    let inThink = false;
-    let buf = '';
+    const thinkFilter = new ThinkTagFilter();
     let usage;
     const toolAcc = new Map();
+    const emitVisible = (text) => {
+        if (!text)
+            return;
+        visibleContent += text;
+        handlers.onText?.(text);
+        consumedAny = true;
+    };
     for await (const chunk of stream) {
         // usage:末尾 chunk(choices 可能为空)在 include_usage 时携带;先读再 continue。
         if (chunk.usage) {
@@ -300,78 +303,12 @@ async function chatOnce(messages, handlers, signal, toolsOverride) {
         const delta = chunk.choices?.[0]?.delta;
         if (!delta)
             continue; // 末尾 usage-only chunk 等无 delta
-        if (delta.content) {
-            // 状态机切分 delta.content:inThink 外输出到 visibleContent + onText;
-            // inThink 内丢弃;标签起始/闭合用 indexOf 在 buf 里扫描。
-            // 末尾预留 (label.length - 1) 字符给下一 chunk 防切分误判。
-            buf += delta.content;
-            let i = 0;
-            while (true) {
-                if (inThink) {
-                    // 思考段内,扫描 THINK_CLOSE;末尾预留 THINK_CLOSE.length - 1 防跨 chunk 切分
-                    const endIdx = buf.indexOf(THINK_CLOSE, i);
-                    if (endIdx === -1) {
-                        // 思考段内未找到闭合;buf 短到不可能包含 </think> 时全丢(都是思考段内容),
-                        // 否则留 (THINK_CLOSE.length - 1) 给下一 chunk 防跨边界切分。
-                        const safeLen = buf.length >= THINK_CLOSE.length
-                            ? buf.length - (THINK_CLOSE.length - 1)
-                            : buf.length;
-                        i = safeLen;
-                        break;
-                    }
-                    inThink = false;
-                    i = endIdx + THINK_CLOSE.length;
-                }
-                else {
-                    // 普通段,扫描 THINK_OPEN;末尾预留 THINK_OPEN.length - 1 防跨 chunk 切分
-                    const startIdx = buf.indexOf(THINK_OPEN, i);
-                    if (startIdx === -1) {
-                        // buf 短到不可能包含 <think> 时全输出(无 think 标签的普通模型不受影响);
-                        // 否则留 (THINK_OPEN.length - 1) 给下一 chunk 防跨边界切分误判。
-                        const safeLen = buf.length >= THINK_OPEN.length
-                            ? buf.length - (THINK_OPEN.length - 1)
-                            : buf.length;
-                        const seg = buf.slice(i, safeLen);
-                        if (seg) {
-                            visibleContent += seg;
-                            handlers.onText?.(seg);
-                            consumedAny = true;
-                        }
-                        i = safeLen;
-                        break;
-                    }
-                    // THINK_OPEN 之前的普通段:输出
-                    if (startIdx > i) {
-                        const seg = buf.slice(i, startIdx);
-                        visibleContent += seg;
-                        handlers.onText?.(seg);
-                        consumedAny = true;
-                    }
-                    inThink = true;
-                    i = startIdx + THINK_OPEN.length;
-                }
-            }
-            buf = buf.slice(i);
-        }
+        if (delta.content)
+            emitVisible(thinkFilter.push(delta.content));
         if (delta.tool_calls) {
-            // 文本→工具转折点:若 buf 还残留普通文本的安全尾(为防跨 chunk 切分留的
-            // THINK_OPEN.length - 1 字符),立即 flush 到屏幕。否则这段尾巴会一直搁置到
-            // 流结束才由尾部防御输出,而那时 onToolCall 早已触发、TUI 已补换行+生成中
-            // spinner,用户看到「话没说完就去调工具」——history 完整但屏幕渲染顺序错位。
-            // inThink 段照旧丢弃(思考中模型不会同时吐 tool_call,理论上 buf 不会有思考段);
-            // 防御性保留 !inThink 判断。
-            if (buf && !inThink) {
-                visibleContent += buf;
-                // 给 onText 渲染时剥掉尾部 \n:md 渲染器(contentWriteMd)把尾部 \n 当段落分隔 → 产空行;
-                // 随后 onToolCall 检测到 lastChar !== '\n' 会经 contentWrite('\n') 补一个原始换行
-                // (不走 md,只是普通行分隔,无空行)—— 与改造前 onToolCall 补 \n 的行为一致。
-                // visibleContent 保留原 buf(含 \n),history 完整不受影响。
-                const tail = buf.replace(/\n+$/, '');
-                if (tail)
-                    handlers.onText?.(tail);
-                consumedAny = true;
-                buf = '';
-            }
+            // 不在这里 flush thinkFilter：其内部若有残留，只可能是 `<th` / `</thi` 一类
+            // 潜在标签前缀。旧实现把这段在工具转折点强制送进 onText，正是 `k>` 等残片
+            // 偶发混到工具摘要附近的来源。普通文本不会被状态机滞留。
             for (const tc of delta.tool_calls) {
                 const idx = tc.index ?? 0;
                 let entry = toolAcc.get(idx);
@@ -392,19 +329,8 @@ async function chatOnce(messages, handlers, signal, toolsOverride) {
             }
         }
     }
-    // 防御:循环内 buf.slice 已把可确认部分消费;此处覆盖流末尾的"安全尾":
-    //  - 普通段(stream 已结束,标签不会再出现):作为可见内容追加到 visibleContent + 调 onText
-    //    (之前注释说"不再调 onText"是 bug——安全尾里的真实文本会被屏幕吞掉,用户看到模型
-    //     话没说完就去调工具 / 直接结束;history 有但显示缺。现在补上 onText 让屏幕与 history 一致。)
-    //  - 思考段未闭合:丢弃,防 thinking 文本泄漏到 history
-    if (buf) {
-        if (!inThink) {
-            visibleContent += buf;
-            handlers.onText?.(buf);
-            consumedAny = true;
-        }
-        buf = '';
-    }
+    // 流结束后只释放普通态下真实的文本尾；未闭合思考段继续丢弃。
+    emitVisible(thinkFilter.finish());
     const toolCalls = [...toolAcc.entries()]
         .sort((a, b) => a[0] - b[0])
         .map(([, e]) => ({
@@ -510,11 +436,28 @@ export function estimateMessagesTokens(messages) {
         sum += messageTokens(m);
     return sum;
 }
-let schemaTokensCache;
-/** 估算 chatTools(工具 schema)占用的一次性 token,带缓存。 */
-export function estimateToolSchemaTokens() {
-    if (schemaTokensCache === undefined) {
-        schemaTokensCache = estimateTokens(JSON.stringify(chatTools)) + 16;
-    }
-    return schemaTokensCache;
+const schemaTokensCache = new WeakMap();
+/** 估算本次实际发送的工具 schema token；按工具数组实例缓存。 */
+export function estimateToolSchemaTokens(activeTools = chatTools) {
+    if (activeTools.length === 0)
+        return 0;
+    const key = activeTools;
+    const cached = schemaTokensCache.get(key);
+    if (cached !== undefined)
+        return cached;
+    const estimated = estimateTokens(JSON.stringify(activeTools)) + 16;
+    schemaTokensCache.set(key, estimated);
+    return estimated;
+}
+/** 把模型级校正系数统一应用到原始估算。 */
+export function correctTokenEstimate(estimate, correction = 1) {
+    const safeCorrection = Number.isFinite(correction)
+        ? Math.max(0.5, Math.min(2, correction))
+        : 1;
+    return estimate > 0 ? Math.max(1, Math.ceil(estimate * safeCorrection)) : 0;
+}
+/** 估算一次完整请求的 prompt token（messages + 本次实际工具 schema）。 */
+export function estimatePromptTokens(messages, activeTools = chatTools, correction = 1) {
+    const raw = estimateMessagesTokens(messages) + estimateToolSchemaTokens(activeTools);
+    return correctTokenEstimate(raw, correction);
 }

package/dist/llm/think-filter.js

@@ -0,0 +1,90 @@
+/**
+ * 增量过滤部分 OpenAI 兼容后端直接混在 content 中的 <think>...</think>。
+ *
+ * 关键点：流式 chunk 可以在标签任意字符间切开，因此不能仅在当前 chunk 内查找，
+ * 也不能把“短于标签”的缓冲直接输出。普通态还要吞掉孤立 </think>：部分后端把
+ * reasoning 放在独立字段，却仍在 content 的开头附带闭标签。
+ */
+const THINK_OPEN = '<think>';
+const THINK_CLOSE = '</think>';
+/** 返回 text 末尾与任一 tag 前缀重合的最长长度。 */
+function trailingTagPrefixLength(text, tags) {
+    const max = Math.min(text.length, Math.max(...tags.map((tag) => tag.length - 1)));
+    for (let length = max; length > 0; length--) {
+        const suffix = text.slice(-length);
+        if (tags.some((tag) => tag.startsWith(suffix)))
+            return length;
+    }
+    return 0;
+}
+/**
+ * 每次 push 返回当前已经能够确认是正文的文本；标签和思考内容永不返回。
+ * finish 必须在流结束时调用，以释放普通正文末尾暂存的 `<` 等潜在标签前缀。
+ */
+export class ThinkTagFilter {
+    buffer = '';
+    inThink = false;
+    push(chunk) {
+        if (!chunk)
+            return '';
+        this.buffer += chunk;
+        return this.drain(false);
+    }
+    finish() {
+        return this.drain(true);
+    }
+    drain(final) {
+        let visible = '';
+        while (this.buffer) {
+            if (this.inThink) {
+                const closeIdx = this.buffer.indexOf(THINK_CLOSE);
+                if (closeIdx >= 0) {
+                    this.buffer = this.buffer.slice(closeIdx + THINK_CLOSE.length);
+                    this.inThink = false;
+                    continue;
+                }
+                if (final) {
+                    // 未闭合思考段一直丢弃，不能在流结束时误当正文释放。
+                    this.buffer = '';
+                    break;
+                }
+                // 思考正文可立即丢弃，只保留可能跨 chunk 组成 </think> 的后缀。
+                const keep = trailingTagPrefixLength(this.buffer, [THINK_CLOSE]);
+                this.buffer = keep > 0 ? this.buffer.slice(-keep) : '';
+                break;
+            }
+            const openIdx = this.buffer.indexOf(THINK_OPEN);
+            const closeIdx = this.buffer.indexOf(THINK_CLOSE);
+            let tagIdx = -1;
+            let tag = '';
+            if (openIdx >= 0 && (closeIdx < 0 || openIdx < closeIdx)) {
+                tagIdx = openIdx;
+                tag = THINK_OPEN;
+            }
+            else if (closeIdx >= 0) {
+                // 独立 reasoning_content 后偶发残留的孤立闭标签也属于协议噪声。
+                tagIdx = closeIdx;
+                tag = THINK_CLOSE;
+            }
+            if (tagIdx >= 0) {
+                visible += this.buffer.slice(0, tagIdx);
+                this.buffer = this.buffer.slice(tagIdx + tag.length);
+                if (tag === THINK_OPEN)
+                    this.inThink = true;
+                continue;
+            }
+            if (final) {
+                visible += this.buffer;
+                this.buffer = '';
+                break;
+            }
+            // 只暂存“确实可能成为标签”的后缀；普通文本立即输出，不引入固定 6/7 字符延迟。
+            const keep = trailingTagPrefixLength(this.buffer, [THINK_OPEN, THINK_CLOSE]);
+            const emitLength = this.buffer.length - keep;
+            visible += this.buffer.slice(0, emitLength);
+            this.buffer = this.buffer.slice(emitLength);
+            break;
+        }
+        return visible;
+    }
+}

package/dist/repl/index.js

@@ -888,7 +888,6 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
         if (!loadSnapshots(loaded.id))
             rebuildFromHistory(history);
         contextState.lastUsage = undefined;
-        contextState.correction = 1;
         contextState.lifecycleStats = undefined;
         lastTurnUsage = undefined; // 续接:旧会话的 token 累计已无意义,清空等下轮覆写
         layout.clearContent();
@@ -1024,7 +1023,6 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             setCurrentSessionId(undefined, process.cwd()); // 同步清空 session/state
             turnCount = 0; // 反思 cadence 重新计数
             contextState.lastUsage = undefined;
-            contextState.correction = 1;
             contextState.lifecycleStats = undefined;
             lastTurnUsage = undefined; // 清空旧轮的 token 累计
             pendingAttachments = []; // 一并清空待发图片

package/dist/session/compact.js

@@ -1,4 +1,4 @@
-import { chat, estimateMessagesTokens, estimateToolSchemaTokens, estimateTokens, } from '../llm/index.js';
+import { chat, chatTools, correctTokenEstimate, estimatePromptTokens, estimateTokens, } from '../llm/index.js';
 import { config } from '../config/index.js';
 import { MAX_HISTORY_RESULT, MAX_MEMORY_RESULT, MAX_OLD_TOOL_STUB, MAX_SKILL_RESULT } from '../tools/constants.js';
 import { ui } from '../ui/theme.js';
@@ -7,12 +7,9 @@ import * as layout from '../ui/layout.js';
 import { pruneAfterCompaction } from '../rollback/index.js';
 import { toText } from '../context/utils.js';
 export function createContextState() {
-    return { lastEstimate: 0, correction: 1 };
+    return { lastEstimate: 0, correction: 1, calibrationSamples: 0 };
 }
-export const contextState = {
-    lastEstimate: 0,
-    correction: 1,
-};
+export const contextState = createContextState();
 /** 中截:text 太长时保 head + 标记 + tail,总长 ≤ max。 */
 export function truncateMid(text, max) {
     if (text.length <= max)
@@ -240,20 +237,22 @@ async function defaultSummarize(older, focus) {
  */
 export async function compactHistory(history, opts) {
     const state = opts.contextState ?? contextState;
-    const schemaTokens = estimateToolSchemaTokens();
-    const estimateBefore = estimateMessagesTokens(history) + schemaTokens;
+    const activeTools = opts.tools ?? chatTools;
+    const estimateBefore = estimatePromptTokens(history, activeTools, state.correction);
     state.lastEstimate = estimateBefore;
     const groups = groupFromEnd(history);
-    // 保近期:从尾向前累积直到预算花完(至少保 1 组),永不劈开 group。
+    // 保近期:按校正后的 token 累积到 40% window(至少保 1 组),永不劈开 group。
     const keepBudget = Math.floor(opts.window * 0.4);
     const kept = [];
     let keptTokens = 0;
     for (let k = groups.length - 1; k >= 0; k--) {
         const g = groups[k];
-        if (kept.length >= 1 && keptTokens + groupTokens(g) > keepBudget)
+        const nextTokens = keptTokens + groupTokens(g);
+        if (kept.length >= 1
+            && correctTokenEstimate(nextTokens, state.correction) > keepBudget)
             break;
         kept.unshift(g);
-        keptTokens += groupTokens(g);
+        keptTokens = nextTokens;
     }
     const oldGroups = groups.slice(0, groups.length - kept.length);
     const noop = {
@@ -312,10 +311,9 @@ export async function compactHistory(history, opts) {
             history.length = 0;
             history.push(...rebuilt);
             pruneAfterCompaction(history);
-            const estimateAfter = estimateMessagesTokens(history) + schemaTokens;
+            const estimateAfter = estimatePromptTokens(history, activeTools, state.correction);
             state.lastEstimate = estimateAfter;
             state.lastUsage = undefined;
-            state.correction = 1;
             layout.contentWrite(`  ${ui.bold}${ui.accent}●${ui.reset} ${ui.accent}强制压缩(focus on early history)${ui.reset}  ${ui.dim}${estimateBefore} → ${estimateAfter} tokens${ui.reset}\n`);
             return {
                 compacted: true,
@@ -400,10 +398,9 @@ export async function compactHistory(history, opts) {
         history.length = 0;
         history.push(...rebuilt);
         pruneAfterCompaction(history); // 摘要删了旧轮次 → 按存活轮次裁剪回滚日志
-        const estimateAfter = estimateMessagesTokens(history) + schemaTokens;
+        const estimateAfter = estimatePromptTokens(history, activeTools, state.correction);
         state.lastEstimate = estimateAfter;
-        state.lastUsage = undefined; // 压缩后旧 usage 失效,/context 改用估算
-        state.correction = 1;
+        state.lastUsage = undefined; // 压缩后旧 usage 失效,/context 改用校正估算
         layout.contentWrite(`  ${ui.bold}${ui.accent}●${ui.reset} ${ui.accent}压缩上下文${ui.reset}  ${ui.dim}${estimateBefore} → ${estimateAfter} tokens${ui.reset}\n`);
         // 抖动保护:压缩后仍超阈 → 提示 /clear,不死循环
         if (estimateAfter >= opts.threshold * opts.window) {
@@ -419,10 +416,9 @@ export async function compactHistory(history, opts) {
         };
     }
     // 摘要失败:回退仅微压缩(tool content 已原地改),结构不动
-    const estimateAfter = estimateMessagesTokens(history) + schemaTokens;
+    const estimateAfter = estimatePromptTokens(history, activeTools, state.correction);
     state.lastEstimate = estimateAfter;
-    state.lastUsage = undefined; // 结构虽未变,但 token 数已变,旧 usage 失效
-    state.correction = 1;
+    state.lastUsage = undefined; // token 数已变,旧 usage 失效
     if (microcompactDone) {
         layout.contentWrite(`  ${ui.bold}${ui.accent}●${ui.reset} ${ui.accent}微压缩旧工具结果${ui.reset}  ${ui.dim}${estimateBefore} → ${estimateAfter} tokens${ui.reset}\n`);
         return {
@@ -460,9 +456,8 @@ export async function compactHistory(history, opts) {
  * 强制走 compactHistory(manual/force 参数透传)。返 CompactResult 给 caller 文案展示。
  * 默认 manual=false 自动路径完全不变。
  */
-export async function maybeCompact(history, report, manualOpts, state = contextState) {
-    const schemaTokens = estimateToolSchemaTokens();
-    const est = estimateMessagesTokens(history) + schemaTokens;
+export async function maybeCompact(history, report, manualOpts, state = contextState, activeTools = chatTools) {
+    const est = estimatePromptTokens(history, activeTools, state.correction);
     state.lastEstimate = est;
     const isManual = manualOpts?.manual === true;
     // 手动路径:旁路 autoCompact / report / 总阈三重门
@@ -487,6 +482,7 @@ export async function maybeCompact(history, report, manualOpts, state = contextS
         focus: manualOpts?.focus,
         manual: isManual,
         force: manualOpts?.force,
+        tools: activeTools,
         contextState: state,
     });
     return r;

package/dist/session/scheduler.js

@@ -31,6 +31,7 @@
 //   - 关时 agent 仍走原 maybeCompact(history)无 report 路径,零行为变化
 //   - 手动 /compact 走 manualCompact;关时退化直接调 compactHistory(history, { focus })
 import { evaluateBudget, scheduleActions, formatReport, } from '../context/budget.js';
+import { chatTools } from '../llm/index.js';
 import { config } from '../config/index.js';
 import { maybeCompact, contextState } from './compact.js';
 import * as layout from '../ui/layout.js';
@@ -44,8 +45,8 @@ export function createBudgetScheduler(state = contextState) {
         observePush(_history, _idx) {
             // 占位:push-time 三闸(cap / pruner / lifecycle)已自动跑;此接缝供将来演进。
         },
-        async runStep(history, step) {
-            const report = evaluateBudget(history, config.contextWindowTokens, step, state.correction);
+        async runStep(history, step, activeTools = chatTools) {
+            const report = evaluateBudget(history, config.contextWindowTokens, step, state.correction, activeTools);
             const actions = scheduleActions(report);
             let compactHistoryCalled = false;
             let historyRebuilt = false;
@@ -56,7 +57,7 @@ export function createBudgetScheduler(state = contextState) {
                 }
                 else if (a.kind === 'compact_history') {
                     // 路由到 maybeCompact；把结构重建信号传回 core，使 lifecycle 按新 index 恢复。
-                    const result = await maybeCompact(history, report, undefined, state);
+                    const result = await maybeCompact(history, report, undefined, state, activeTools);
                     compactHistoryCalled = true;
                     historyRebuilt ||= result?.historyRebuilt === true;
                 }
@@ -80,9 +81,9 @@ export function createBudgetScheduler(state = contextState) {
     return obs;
 }
 /** 便捷:agent/core.ts 不需要每次 createBudgetScheduler,直接 runScheduler(history, step)。 */
-export async function runScheduler(history, step, state = contextState) {
+export async function runScheduler(history, step, state = contextState, activeTools = chatTools) {
     const s = createBudgetScheduler(state);
-    return s.runStep(history, step);
+    return s.runStep(history, step, activeTools);
 }
 /** 手动 /compact 入口(repl):与自动路径完全一致——五区 ROI 调度,但 history 摘要强制执行。
  *  即便 layers.history.overBudget=false 或 totalOver=false,manual 仍产 compact_history action

package/dist/tools/builtins/run-command.js

@@ -1,6 +1,29 @@
 import { spawn, spawnSync } from 'node:child_process';
 import { MAX_OUTPUT } from '../constants.js';
 import { getSandboxRoot, filterEnv, isCommandDenied } from '../../sandbox/index.js';
+const OUTPUT_HEAD_LIMIT = Math.floor(MAX_OUTPUT * 0.4);
+const OUTPUT_TAIL_LIMIT = MAX_OUTPUT - OUTPUT_HEAD_LIMIT;
+/** 有界采集：短输出逐字保留；超限后保留 head+tail，避免构建/测试错误只出现在尾部时被丢弃。 */
+class BoundedCommandOutput {
+    head = '';
+    tail = '';
+    total = 0;
+    append(text) {
+        this.total += text.length;
+        const headRoom = OUTPUT_HEAD_LIMIT - this.head.length;
+        const headPart = headRoom > 0 ? text.slice(0, headRoom) : '';
+        this.head += headPart;
+        const rest = text.slice(headPart.length);
+        if (rest)
+            this.tail = (this.tail + rest).slice(-OUTPUT_TAIL_LIMIT);
+    }
+    render() {
+        if (this.total <= MAX_OUTPUT)
+            return this.head + this.tail;
+        const removed = this.total - MAX_OUTPUT;
+        return `${this.head}\n...(输出已截断 ${removed} 字符,保留开头与结尾)...\n${this.tail}`;
+    }
+}
 // ---------- run_command ----------
 export const runCommandTool = {
     name: 'run_command',
@@ -25,7 +48,7 @@ export const runCommandTool = {
             const isWin = process.platform === 'win32';
             // 沙箱 best-effort:cwd 钉死 sandbox root(相对路径写落在牢内)+ env 脱敏(剥 *KEY/*TOKEN 等,防 LLM_API_KEY 泄子进程)
             const child = spawn(isWin ? 'cmd.exe' : 'bash', isWin ? ['/c', command] : ['-c', command], { cwd: getSandboxRoot() ?? process.cwd(), env: filterEnv(process.env) });
-            let out = '';
+            const output = new BoundedCommandOutput();
             let finished = false;
             let timer;
             // 杀整棵进程树。child.kill() 在 Windows 只杀 cmd.exe、npm 等子进程会孤儿继续跑(占锁、污染下一步),
@@ -50,7 +73,7 @@ export const runCommandTool = {
             // abort(用户 Ctrl+C,经 executeTool ctx.signal 透传)→ 杀子进程树 + 返[已中断]
             const onAbort = () => {
                 killTree();
-                finish(`[已中断]\n${out.trim()}`);
+                finish(`[已中断]\n${output.render().trim()}`);
             };
             const finish = (s) => {
                 if (finished)
@@ -61,21 +84,18 @@ export const runCommandTool = {
                 done(s);
             };
             const onChunk = (chunk) => {
-                if (out.length < MAX_OUTPUT)
-                    out += chunk.toString('utf8');
+                output.append(chunk.toString('utf8'));
             };
             child.stdout.on('data', onChunk);
             child.stderr.on('data', onChunk);
             child.on('error', (e) => finish(`执行失败: ${e.message}`));
             child.on('close', (code) => {
-                let r = out.trim();
-                if (out.length >= MAX_OUTPUT)
-                    r += '\n...(输出已截断)';
-                finish(`[退出码 ${code}]\n${r || '(无输出)'}`);
+                const result = output.render().trim();
+                finish(`[退出码 ${code}]\n${result || '(无输出)'}`);
             });
             timer = setTimeout(() => {
                 killTree();
-                finish(`[超时,已终止]\n${out.trim()}`);
+                finish(`[超时,已终止]\n${output.render().trim()}`);
             }, timeout);
             // 外部 abort signal:已 aborted 即时杀(防御;agent 循环顶检查通常会先拦),否则挂监听
             if (ctx?.signal) {

package/package.json

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