mocode-ai 0.6.6 → 0.6.7

package/dist/context/relevance.js

@@ -1,93 +1,129 @@
-// Relevance Pruner:read_file 相关性裁剪(纯静态分析,零 LLM 调用)。
-//
-// 场景(用户描述):
-//   1) read foo.ts → 后来又 read foo.ts → 旧结果无价值 → 替换为存根
-//   2) read foo.ts → edit foo.ts → read foo.ts → 中间那次 read 之前的所有旧 read
-//      在 mutation 之后已失效 → 替换为存根
-//
-// 与现有子系统的关系:
-//   - Context Optimization Pipeline(`pipeline.ts`):单条上限 + 类型化编码。本层在其外,
-//     在 pushToolResult 出口再做一次"跨条"裁剪。
-//   - drop_context(`session/drop.ts`):agent 主动剔除已知无关的旧 tool 结果。本层是被动自动,
-//     不需要 agent 调;两者并存不冲突。
-//   - compact(`session/compact.ts`):阈值触发的整体微压缩+摘要。本层只裁"明确失效"的旧 read,
-//     不触发摘要;门槛更低、零成本。
-//
-// 不变量(对齐 drop_context / compact):
-//   - 只改 .content,不删消息、不动 tool_call_id、不动 tool_calls 数组结构。
-//   - 当前轮保护区:不剔除"最后一个 user 消息及其之后"的 read_file 结果(agent 本轮还在用,
-//     剔除会破坏正在进行的推理)。实现复用 drop.ts 的 lastUserIndex 思路。
-//   - 幂等:已 stub(含「已过时」标记)不重复 stub,避免反复重写同一条消息。
-//   - 永不抛错(对齐「调度器永不抛错」契约);无匹配 / 解析失败 / 异常 → 静默 no-op。
-//   - TUI 渲染(hooks.onToolResult)用原始 output,与本层解耦——屏上看全量,LLM 看裁剪后版。
-//
-// 零行为变化兜底:开关 `config.contextRelprune` 关闭时,pipeline 路径完全不调本模块。
-import { canonicalizePath, extractPath, lastUserIndex, toText, toolNameOf } from './utils.js';
-/** stub 标记前缀(供幂等判定)。drop_context 用的是「⌦[已剔除:与当前任务无关]」,
- *  本层用「⌦[已过时:同 path 已有新 read / 已被 mutation 覆写]」,区分两类剔除来源。 */
-const STUB_PREFIX = '⌦[已过时:同 path 已有新 read / 已被 mutation 覆写]';
+// Relevance Pruner: statically removes tool results that a newer observation supersedes.
+// It never deletes messages or changes tool_call_id pairing; only tool content is stubbed.
+import { canonicalizePath, extractPath, isToolResultSuccess, lastUserIndex, toText, } from './utils.js';
+/** Shared prefix lets /context count read and observation supersession together. */
+const STUB_PREFIX = '⌦[已过时:';
+const READ_STUB_REASON = '同 path 已有新 read / 已被 mutation 覆写';
+function parseArgs(raw) {
+    try {
+        const parsed = raw.trim() ? JSON.parse(raw) : {};
+        return parsed && typeof parsed === 'object'
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizedInteger(value, fallback) {
+    const n = Number(value);
+    return Number.isFinite(n) ? Math.trunc(n) : fallback;
+}
+/** Only complete semantic-query equality is safe for whole-message replacement. */
+function observationKey(call) {
+    const args = call.args;
+    if (!args)
+        return null;
+    if (call.name === 'grep') {
+        if (typeof args.pattern !== 'string')
+            return null;
+        const rawMax = normalizedInteger(args.max_per_file, 15);
+        return JSON.stringify({
+            tool: 'grep',
+            pattern: args.pattern,
+            glob: typeof args.glob === 'string' ? args.glob : '**/*',
+            maxPerFile: Math.min(Math.max(rawMax, 1), 50),
+        });
+    }
+    if (call.name === 'codegraph') {
+        if (typeof args.action !== 'string' || typeof args.query !== 'string')
+            return null;
+        const query = args.action === 'explore'
+            ? args.query.trim().replace(/\s+/g, ' ')
+            : args.query.trim();
+        return JSON.stringify({
+            tool: 'codegraph',
+            action: args.action,
+            query,
+            file: typeof args.file === 'string' ? args.file.trim().replace(/\\/g, '/') : '',
+            offset: args.offset === undefined ? null : normalizedInteger(args.offset, 0),
+            limit: args.limit === undefined ? null : normalizedInteger(args.limit, 0),
+        });
+    }
+    return null;
+}
+function observationLabel(call) {
+    const args = call.args ?? {};
+    if (call.name === 'grep') {
+        const pattern = JSON.stringify(String(args.pattern ?? '')).slice(0, 80);
+        const glob = JSON.stringify(String(args.glob ?? '**/*')).slice(0, 80);
+        return `grep(pattern=${pattern}, glob=${glob})`;
+    }
+    const action = String(args.action ?? '');
+    const query = JSON.stringify(String(args.query ?? '')).slice(0, 100);
+    return `codegraph(action=${action}, query=${query})`;
+}
 /**
- * 维护「path → 该 path 所有 read_file tool 消息的 history index」映射。
- *  - observePush:把刚 push 的 read_file tool 消息登记,并把同 path 的"更早" read 全部 stub。
- *  - observeMutation:把该 mutation path 的"在 mutation 之前的" read 全部 stub。
- *
- * 设计:每个 agent 会话(每个 runAgentCore 实例)持有一个 pruner。会话结束/换 plan 时
- * 可新建;不持久化(history 重建时索引自然过期)。
- *
- * 零依赖:仅依赖 ChatMessage 形状;不 import llm / tools / agent。
+ * Cross-message relevance pruning:
+ * - read_file: a newer successful read of the same canonical path supersedes old reads.
+ * - grep/codegraph: a newer successful call with the exact same semantic arguments
+ *   supersedes old results. Partial file overlap is intentionally not enough.
  */
 export class RelevancePruner {
-    /** path → [history index, ...]  按插入序;最新在末尾。 */
     readByPath = new Map();
-    /** 把刚 push 的消息通知 pruner。
-     *  - 只处理成功的 read_file tool 消息；失败读取不能淘汰旧的有效结果。
-     *  - 登记当前 canonical path，并反向 stub 同 path 旧 read。
-     */
+    observationByKey = new Map();
     observePush(history, msg, succeeded = true) {
         try {
             if (!succeeded || msg.role !== 'tool')
                 return;
-            const m = msg;
             const idx = history.length - 1;
             if (idx < 1 || history[idx] !== msg)
-                return; // 防御:必须刚 push 到末尾
-            if (toolNameOf(history, idx) !== 'read_file')
                 return;
             const content = toText(msg.content);
             if (content.startsWith(STUB_PREFIX))
-                return; // 已是存根(防御)
-            const path = this.pathAt(history, idx);
-            if (!path)
-                return;
-            // 先 stub 旧 read(同 canonical path,idx 之前),再登记新 idx。
-            this.stubPriorReads(history, path, idx);
-            const list = this.readByPath.get(path);
-            if (list)
+                return;
+            const call = this.callAt(history, idx);
+            if (!call)
+                return;
+            if (call.name === 'read_file') {
+                const path = canonicalizePath(extractPath(call.argsRaw));
+                if (!path)
+                    return;
+                this.stubPriorReads(history, path, idx);
+                const list = this.readByPath.get(path) ?? [];
                 list.push(idx);
-            else
-                this.readByPath.set(path, [idx]);
+                this.readByPath.set(path, list);
+                return;
+            }
+            const key = observationKey(call);
+            if (!key)
+                return;
+            this.stubPriorObservations(history, call.name, key, idx);
+            const list = this.observationByKey.get(key) ?? [];
+            list.push(idx);
+            this.observationByKey.set(key, list);
         }
         catch {
-            /* 永不抛错 */
+            // Relevance pruning must never block tool-result insertion.
         }
     }
-    /** 从 tool_call arguments 取得并规范化某条 read_file 的路径。 */
-    pathAt(history, idx) {
+    callAt(history, idx) {
         const tcId = history[idx]?.tool_call_id;
         if (!tcId)
             return null;
         for (let j = idx - 1; j >= 1; j--) {
-            const mm = history[j];
-            if (mm.role !== 'assistant')
+            const message = history[j];
+            if (message.role !== 'assistant')
+                continue;
+            const calls = message.tool_calls;
+            const hit = calls?.find((tc) => tc?.id === tcId);
+            if (!hit?.function?.name)
                 continue;
-            const tcs = mm.tool_calls;
-            const hit = tcs?.find((tc) => tc?.id === tcId);
-            if (hit)
-                return canonicalizePath(extractPath(hit.function?.arguments));
+            const argsRaw = hit.function.arguments ?? '';
+            return { name: hit.function.name, argsRaw, args: parseArgs(argsRaw) };
         }
         return null;
     }
-    /** 成功 mutation 后，把该 canonical path 在 mutation 之前的 read 全部 stub。 */
     observeMutation(history, path) {
         try {
             const canonicalPath = canonicalizePath(path);
@@ -100,93 +136,102 @@ export class RelevancePruner {
             this.readByPath.delete(canonicalPath);
         }
         catch {
-            /* 永不抛错 */
+            // Never throw from mutation cleanup.
         }
     }
-    /**
-     * 把 history 里 "canonical path 同 + index < beforeIdx + 不在当前轮保护区" 的 read_file
-     * tool 消息替换为存根。索引是快路径，全表扫描用于恢复 resume 历史；两条路径都重新校验 path。
-     */
     stubPriorReads(history, path, beforeIdx) {
         const targetPath = canonicalizePath(path);
         if (!targetPath)
             return;
-        const guard = lastUserIndex(history);
-        const protectedFrom = guard > 0 ? guard : 0;
-        const stubOne = (i) => {
-            if (i >= beforeIdx)
+        const protectedFrom = Math.max(0, lastUserIndex(history));
+        const stubOne = (idx) => {
+            if (idx >= beforeIdx || (protectedFrom > 0 && idx >= protectedFrom))
                 return;
-            if (i >= protectedFrom && protectedFrom > 0)
-                return; // 当前轮保护区
-            const m = history[i];
-            if (!m || m.role !== 'tool')
+            const message = history[idx];
+            if (!message || message.role !== 'tool')
                 return;
-            const content = toText(m.content);
+            const content = toText(message.content);
             if (content.startsWith(STUB_PREFIX))
-                return; // 幂等
-            if (toolNameOf(history, i) !== 'read_file')
                 return;
-            if (this.pathAt(history, i) !== targetPath)
-                return; // 防止 fallback 扫描误裁其他文件
-            const tcId = m.tool_call_id;
-            if (!tcId)
+            const call = this.callAt(history, idx);
+            if (call?.name !== 'read_file')
+                return;
+            if (canonicalizePath(extractPath(call.argsRaw)) !== targetPath)
+                return;
+            if (!message.tool_call_id)
                 return;
-            const stub = `${STUB_PREFIX} read_file(${targetPath}) ${content.length} 字符 → 已被新 read / mutation 替代 · id …${tcId.slice(-6)}⌫`;
-            m.content = stub;
+            message.content =
+                `${STUB_PREFIX}${READ_STUB_REASON}] read_file(${targetPath}) ${content.length} 字符 ` +
+                    `→ 已被新 read / mutation 替代 · id …${message.tool_call_id.slice(-6)}⌫`;
         };
-        const indexed = this.readByPath.get(targetPath);
-        if (indexed) {
-            for (const i of indexed)
-                stubOne(i);
-        }
+        for (const idx of this.readByPath.get(targetPath) ?? [])
+            stubOne(idx);
         const scanEnd = Math.min(beforeIdx, protectedFrom > 0 ? protectedFrom : beforeIdx);
-        for (let i = 1; i < scanEnd; i++)
-            stubOne(i);
+        for (let idx = 1; idx < scanEnd; idx++)
+            stubOne(idx);
+    }
+    stubPriorObservations(history, toolName, key, beforeIdx) {
+        const protectedFrom = Math.max(0, lastUserIndex(history));
+        const stubOne = (idx) => {
+            if (idx >= beforeIdx || (protectedFrom > 0 && idx >= protectedFrom))
+                return;
+            const message = history[idx];
+            if (!message || message.role !== 'tool')
+                return;
+            const content = toText(message.content);
+            if (content.startsWith(STUB_PREFIX) || !isToolResultSuccess(content))
+                return;
+            const call = this.callAt(history, idx);
+            if (!call || call.name !== toolName || observationKey(call) !== key)
+                return;
+            if (!message.tool_call_id)
+                return;
+            const reason = toolName === 'grep'
+                ? '相同 grep 查询已有更新结果'
+                : '相同 codegraph 查询已有更新结果';
+            message.content =
+                `${STUB_PREFIX}${reason}] ${observationLabel(call)} ${content.length} 字符 ` +
+                    `→ 已被更新查询替代 · id …${message.tool_call_id.slice(-6)}⌫`;
+        };
+        for (const idx of this.observationByKey.get(key) ?? [])
+            stubOne(idx);
+        // The fallback scan restores correctness after resume/compact when this instance
+        // has no index for older messages.
+        const scanEnd = Math.min(beforeIdx, protectedFrom > 0 ? protectedFrom : beforeIdx);
+        for (let idx = 1; idx < scanEnd; idx++)
+            stubOne(idx);
     }
 }
-/** 默认单例:每个 agent 循环一个。runAgentCore 入口 new 一个,后续 observe 共享。 */
 export function createRelevancePruner() {
     return new RelevancePruner();
 }
-/** 解析一条 stub 字符串,提取原 content 长度(若可解析)。失败返 null。 */
+/** Parse the original content length recorded by any relevance stub. */
 function parseStubOriginalLen(stub) {
-    // 格式:⌦[已过时:同 path 已有新 read / 已被 mutation 覆写] read_file(<path>) <N> 字符 → ...
-    const m = / read_file\([^)]+\) (\d+) 字符 /.exec(stub);
-    if (!m)
+    const match = /\) (\d+) 字符 →/.exec(stub);
+    if (!match)
         return null;
-    const n = Number(m[1]);
-    return Number.isFinite(n) && n >= 0 ? n : null;
+    const value = Number(match[1]);
+    return Number.isFinite(value) && value >= 0 ? value : null;
 }
-/**
- * 扫 history,统计被相关性裁剪 stub 的 read_file tool 消息(条数 + 原字节数)。
- * 供 /context 渲染统计行用(让用户直观看到「prune 帮了多少」)。
- * 永不抛错(对齐本模块契约);history 为空 / 无 stub 时返零值。
- *
- * 注意:stub 后只剩 stub 字符串(原 content 已丢失),故只能从 stub 字符串里 parse
- * 原字节数,误差 = stub 时记录的 content.length(精确);token 估算走 estimateTokens。
- */
+/** Aggregate relevance/lifecycle compression for the /context panel. */
 export function computePruneStats(history) {
     let stubbed = 0;
     let originalChars = 0;
     let stubChars = 0;
-    for (const m of history) {
-        if (m.role !== 'tool')
+    for (const message of history) {
+        if (message.role !== 'tool')
             continue;
-        const c = toText(m.content);
-        // Relevance Pruner 的 stub(⌦[已过时:...) 和 Lifecycle Engine 的 DIGEST(⌦[摘要:...) 都统计。
-        const isPruneStub = c.startsWith(STUB_PREFIX);
-        const isDigest = c.startsWith('⌦[摘要:');
+        const content = toText(message.content);
+        const isPruneStub = content.startsWith(STUB_PREFIX);
+        const isDigest = content.startsWith('⌦[摘要:');
         if (!isPruneStub && !isDigest)
             continue;
         stubbed++;
-        stubChars += c.length;
-        const orig = parseStubOriginalLen(c);
-        if (orig != null)
-            originalChars += orig;
+        stubChars += content.length;
+        const original = parseStubOriginalLen(content);
+        if (original != null)
+            originalChars += original;
     }
-    // token 估算:用 estimateTokens(懒导入,避免循环依赖 llm)
-    // 这里偷懒:走粗略 chars/4(中文混合下会过估,安全侧)
-    // 准确应调 estimateTokens,但 /context 已经是粗算,误差可接受
     const originalTokens = Math.ceil(originalChars / 4);
     const stubTokens = Math.ceil(stubChars / 4);
     return {

package/dist/session/compact.js

@@ -6,6 +6,7 @@ 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, calibrationSamples: 0 };
 }
@@ -241,8 +242,8 @@ export async function compactHistory(history, opts) {
     const estimateBefore = estimatePromptTokens(history, activeTools, state.correction);
     state.lastEstimate = estimateBefore;
     const groups = groupFromEnd(history);
-    // 保近期:按校正后的 token 累积到 40% window(至少保 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--) {

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,30 +1,17 @@
-// 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
@@ -36,15 +23,10 @@ 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, activeTools = chatTools) {
             const report = evaluateBudget(history, config.contextWindowTokens, step, state.correction, activeTools);
             const actions = scheduleActions(report);
@@ -53,7 +35,7 @@ export function createBudgetScheduler(state = contextState) {
             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 恢复。
@@ -61,9 +43,6 @@ export function createBudgetScheduler(state = contextState) {
                     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,
@@ -85,9 +64,9 @@ export async function runScheduler(history, step, state = contextState, activeTo
     const s = createBudgetScheduler(state);
     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。
  *

package/dist/tools/constants.js

@@ -23,23 +23,6 @@ export const GC_DAYS = 90;
 /** memory_search 结果(召回的记忆正文)的放宽上限:指令性内容,中截破坏语义,对齐 use_skill。 */
 export const MAX_MEMORY_RESULT = 64000;
 export const IGNORE = ['**/node_modules/**', '**/.git/**'];
-// ── Context Budget Scheduler(五区分账)────────────────────────────────────
-/** Hot/Cold 划分:当前 step 起往前 N 个 user turn 之内的工具结果视为 Hot(绝对不压),
- * 之外的视为 Cold(可调度器压)。默认 4 = 跨过 4 个用户问题仍生效。 */
-export const HOT_TURN_WINDOW = 4;
-/** Cold 区内可被就地 stub 的 tool 消息最低 age(经过的消费者 push 数)。默认 2,
- * 与 lifecycle.ts DEFAULT_AGE_THRESHOLD 对齐。 */
-export const TOOL_OLD_AGE = 2;
-/** 五区预算占比(总和 0.95,留 5% 给 Reserve)。对齐 user 修正版:
- * System 15 / History 20 / Hot Tool 25 / Cold Tool 25 / Summary 10。 */
-export const BUDGET_RATIO = {
-    system: 0.15,
-    history: 0.20,
-    toolRecent: 0.25,
-    toolOld: 0.25,
-    summary: 0.10,
-    reserve: 0.05,
-};
 // ── plan 模式(只读规划,不执行)──────────────────────────────────────────────
 /**
  * plan 模式下从工具 schema 里剔除的工具(模型根本看不到 → 调不到):

package/package.json

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