mocode-ai 0.6.5 → 0.6.7

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';
@@ -6,13 +6,11 @@ import { Spinner } from '../ui/spinner.js';
 import * as layout from '../ui/layout.js';
 import { pruneAfterCompaction } from '../rollback/index.js';
 import { toText } from '../context/utils.js';
+import { DEFAULT_BUDGET_POLICY } from '../context/budget.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 +238,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。
-    const keepBudget = Math.floor(opts.window * 0.4);
+    // 保近期:按策略中的 token 比例累积(至少保 1 组),永不劈开 group。
+    const keepBudget = Math.floor(opts.window * DEFAULT_BUDGET_POLICY.compactKeepRatio);
     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 +312,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 +399,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 +417,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 +457,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 +483,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/index.js

@@ -6,9 +6,9 @@
  */
 export { compactHistory, maybeCompact, capToolResultForHistory, truncateMid, contextState, createContextState, } from './compact.js';
 // ── Context Budget Scheduler 接缝 ────────────────────────────────────────
-// agent/core.ts 步前调 runScheduler(history, step):评估五区预算 → 按 ROI 调度
-// shrink_cold_tools / cap_hot_tools / compact_history。开关关闭时退化为 maybeCompact。
-// repl /compact 命令调 manualCompact(history, focus?):与自动路径完全一致,focus 透传摘要 prompt。
+// agent/core.ts 在 age-aware sweep 后调用 runScheduler(history, step):评估五区预算，
+// 只执行可落地的 warn / compact_history；开关关闭时退化为 maybeCompact。
+// repl /compact 命令调 manualCompact(history, focus?):与自动路径共享决策，focus 透传摘要 prompt。
 export { runScheduler, manualCompact, createBudgetScheduler, } from './scheduler.js';
 export { dropContextFromHistory, formatDropResult, } from './drop.js';
 export { newSessionId, saveSession, loadSession, listSessions, sessionDir, } from './persist.js';

package/dist/session/scheduler.js

@@ -1,68 +1,48 @@
-// Context Budget Scheduler(执行层):把 scheduleActions() 产生的动作落到既有闸上。
-//
-// 关系图:
+// Context Budget Scheduler(执行层):评估五区预算并执行可落地的动作。
 //
 //   agent/core.ts (步前)              repl /compact 命令(手动)
 //     ↓ runScheduler(history, step)    ↓ manualCompact(history, focus?)
 //   session/scheduler.ts(本文件)
 //     ├─ evaluateBudget(history, window, step) → BudgetReport
-//     │     ↓
-//     ├─ scheduleActions(report) → ScheduleAction[]
-//     │     ↓
+//     ├─ scheduleActions(report) → warn | compact_history
 //     └─ 执行 actions:
-//          - warn:                  仅写日志
-//          - shrink_cold_tools L1:  由 push-time cap.ts(MAX_HISTORY_RESULT)自动处理;此处 no-op
-//          - shrink_cold_tools L2:  由 pruner.observePush(relevance.ts)自动处理;此处 no-op
-//          - shrink_cold_tools L3:  由 lifecycle.pushTool(lifecycle.ts)自动处理;此处 no-op
-//          - cap_hot_tools:         Hot 区只 cap,实际仍由 push-time cap 走;此处 no-op + 记日志
-//          - compact_history:       调 maybeCompact(history, report)── report 路由到 ROI 调度
+//          - warn:            仅写日志
+//          - compact_history: 调 maybeCompact(history, report)
 //
-// 设计意图:
-//   - **L1/L2/L3 不重复实现**——push-time 已经自动跑过这三级。再在调度器做一遍是 Double-Action
-//     且破坏「调度器永不抛错 + 幂等」契约。调度器只负责"决策时点",push-time 闸负责"执行"。
-//   - **hotBoundary** 仍由调度器算出来供 lifecycle 内部用(将来可演进成「仅 Cold 区跑 age stub」)——
-//     现版本先全面暴露给 report,暂不传参给 lifecycle。
-//   - **actionLog**:每次执行的决策落进 contextState.schedulerLog,供 /context 命令与调试用。
-//   - **manualCompact**:手动入口(用户敲 /compact),与 runScheduler 共享决策路径;唯一差别是
-//     即使 history 不超预算也强制产 compact_history(focus 透传)。对齐用户拍板的方案 A。
+// push-time cap / relevance / lifecycle / age-aware sweep 在进入 scheduler 前独立完成，
+// scheduler 不再生成无法执行的 Cold/Hot tool action。每次决策写入 actionLog，供 /context 调试。
+// manualCompact 与自动路径共享 scheduleActions，但用户显式触发时强制追加 compact_history。
 //
 // 开关:
 //   - config.contextBudget !== false(默认 true):agent 调 runScheduler
 //   - 关时 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';
 import { ui } from '../ui/theme.js';
-/** 创建 runAgentCore 闭包持有的 scheduler(每次 agent 启动一个新实例)。
- *  observePush 当前只是占位:真正 L1/L2/L3 已由 cap / pruner / lifecycle 在 push 时跑;
- *  保留接口为后续「调度器注入 hotBoundary 给 lifecycle」演进留接缝。 */
+/** 创建 runAgentCore 闭包持有的 scheduler(每次 agent 启动一个新实例)。 */
 export function createBudgetScheduler(state = contextState) {
     const obs = {
         lastRunLog: null,
-        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;
             for (const a of actions) {
                 if (a.kind === 'warn') {
                     // system 超:写一行提示(配置漂移应由用户处理,不是调度器压)
-                    layout.contentWrite(`  ${ui.yellow}●${ui.reset} ${ui.yellow}调度器警告:${a.layer} ${a.reason}${ui.reset}\n`);
+                    layout.contentWrite(`  ${ui.yellow}●${ui.reset} ${ui.yellow}调度器警告 [${a.layer}] ${a.reason}${ui.reset}\n`);
                 }
                 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;
                 }
-                // shrink_cold_tools L1/L2/L3 与 cap_hot_tools:已由 push-time 闸在每次 push 自动跑
-                // (cap = MAX_HISTORY_RESULT;pruner = same-path 新旧替换;lifecycle = age stub)。
-                // 调度器不重复,只把决策记录下来供调试。
             }
             const log = {
                 step,
@@ -80,13 +60,13 @@ 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
- *  把 focus 透传给 LLM 摘要 prompt。其它 ROI 决策(cold tools / cap hot / warn)按 scheduleActions 走。
+/** 手动 /compact 入口(repl):与自动路径共享预算评估和可执行 action，但强制执行 history 摘要。
+ *  即便 layers.history.overBudget=false 或 totalOver=false，manual 仍追加 compact_history，
+ * 并把 focus 透传给 LLM 摘要 prompt。
  *
  *  关系:runScheduler 是「自动触发」,manualCompact 是「用户显式触发」,二者共享 scheduleActions。
  *