mocode-ai 0.6.5 → 0.6.7

package/dist/agent/core.js

@@ -5,19 +5,31 @@
 // 与 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';
 import { getAgentMode, setAgentMode } from './mode.js';
 import { maybeCompact, contextState, dropContextFromHistory } from '../session/index.js';
 import { createBudgetScheduler } from '../session/scheduler.js';
-import { optimizeToolResult } from '../context/index.js';
+import { optimizeToolResult, HOT_TURN_WINDOW, userTurnBoundary } from '../context/index.js';
+import { createAgeAwareEncodingState, } from '../context/age-aware.js';
 import { createRelevancePruner } from '../context/relevance.js';
 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';
+/** Stable per-history age state survives user turns; WeakMap avoids retaining closed sessions. */
+const ageAwareStateByHistory = new WeakMap();
+function ageAwareStateFor(history) {
+    const existing = ageAwareStateByHistory.get(history);
+    if (existing)
+        return existing;
+    const created = createAgeAwareEncodingState(history);
+    ageAwareStateByHistory.set(history, created);
+    return created;
+}
 /** 解析工具 arguments JSON;非法或空返 null(调用方据此降级到普通 preview)。 */
 function parseArgs(raw) {
     try {
@@ -104,16 +116,17 @@ function readDiffContext(tc, parsed) {
  *  - lifecycle 也在每个 runAgentCore 实例化一次,登记 grep/glob/codegraph 等 producer
  *    与 read/edit/write 的 consumer 关系;孤立+老化自动 STUB(观察类工具永不到 STUB)。
  *  - 开关关闭时 lifecycle=null 完全跳过。 */
-function pushToolResult(history, tc, output, pruner, lifecycle, scheduler, runtimeContextState = contextState) {
+function pushToolResult(history, tc, output, pruner, lifecycle, _scheduler, runtimeContextState = contextState) {
+    const succeeded = isToolResultSuccess(output);
+    const ageAware = config.contextOptimize ? ageAwareStateFor(history) : null;
+    const encodingContext = ageAware?.preparePush(tc, succeeded);
     const msg = {
         role: 'tool',
         tool_call_id: tc.id,
-        // optimizeToolResult:classifier 选 encoder → encode(保不变量压缩)→ capToolResultForHistory 兜底。
-        // tc.arguments 透传给 encoder(上下文感知编码,如 read_file 的 offset/limit)。永不抛错。
-        content: optimizeToolResult(tc.name, output, tc.arguments),
+        // 初次 push 始终保守(age=0);旧 Cold 结果在下一 step 的 sweep 中按类型降级。
+        content: optimizeToolResult(tc.name, output, tc.arguments, encodingContext),
     };
     history.push(msg);
-    const succeeded = isToolResultSuccess(output);
     // 失败 read 不得淘汰旧 read；失败 consumer 也不能改变 lifecycle 上游状态。
     if (pruner)
         pruner.observePush(history, msg, succeeded);
@@ -192,11 +205,14 @@ export async function runAgentCore(opts) {
         ? createLifecycleEngine(history)
         : null;
     runtimeContextState.lifecycleStats = lifecycle?.stats();
-    // 预算调度器:每个 runAgentCore 实例一个,步前 evaluateBudget + scheduleActions。
-    // 决策按 ROI 分发(cold tools 优先 / history 摘要最后);contextBudget 开关关闭时为 null。
+    // 预算调度器:每个 runAgentCore 实例一个，在 age-aware sweep 后评估并执行 warn / compact。
+    // contextBudget 开关关闭时为 null。
     const scheduler = config.contextBudget !== false
         ? createBudgetScheduler(runtimeContextState) // 在 step 循环之外实例化一次,跨步持有 lastRunLog
         : null;
+    // age-aware encoder 与 history 数组同寿命；每轮重建一次以覆盖外部 /compact 等原地修改。
+    const ageAware = config.contextOptimize ? ageAwareStateFor(history) : null;
+    ageAware?.rehydrate(history);
     // 本轮流式状态:首个正文 token 到达即停 spinner(思考期间 spinner 持续转「思考中…」,不写思考内容)。
     let mode = 'idle';
     let gotText = false;
@@ -227,6 +243,7 @@ export async function runAgentCore(opts) {
         hooks.onAbort?.();
         history.length = 0;
         history.push(...savedHistory);
+        ageAware?.rehydrate(history);
         setAgentMode(savedMode);
     };
     try {
@@ -236,22 +253,34 @@ export async function runAgentCore(opts) {
                 abortRestore();
                 return { completed: false, finalText: null };
             }
-            // 步前:五区 Budget Scheduler 决策——按 ROI 调度(冷工具优先 / history 摘要最后)。
-            // 开关关闭(scheduler=null)时退化回原 maybeCompact 路径,零行为变化。
+            // 本步只计算一次实际工具集合，调度、请求和 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;
+            // 初次 tool push 只做保守编码；预算评估前先对 Cold 且 age 达阈值的旧结果降级，
+            // 避免 scheduler 根据马上会被 sweep 的陈旧占用误触发 history compact。
+            ageAware?.sweep(history, userTurnBoundary(history, HOT_TURN_WINDOW));
+            // 步前:五区 Budget Scheduler 在优化后的 history 上决策；开关关闭时退化回原 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 已全部失效。
-            // 立即从新 history 恢复状态和 producer 索引，再允许后续 pushTool/pushMutation 使用。
-            if (historyRebuilt && lifecycle) {
-                lifecycle = createLifecycleEngine(history);
-                runtimeContextState.lifecycleStats = lifecycle.stats();
+            // compact 用新消息数组原地重建 history 后，所有按消息位置恢复的状态都需重建。
+            if (historyRebuilt) {
+                if (lifecycle) {
+                    lifecycle = createLifecycleEngine(history);
+                    runtimeContextState.lifecycleStats = lifecycle.stats();
+                }
+                ageAware?.rehydrate(history);
             }
             hooks.onStepStart?.(); // 主 agent:spinner.start('思考中')
             mode = 'idle';
@@ -259,11 +288,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 +303,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/age-aware.js

@@ -0,0 +1,136 @@
+// Age-aware tool-result encoding coordinator.
+// Initial pushes stay conservative; old Cold results are re-encoded before chat.
+import { TOOL_OLD_AGE } from './budget.js';
+import { optimizeToolResult } from './pipeline.js';
+import { canonicalizePath, extractPath, isToolResultSuccess, toText, } from './utils.js';
+/**
+ * Tracks successful first reads and tool-result age without coupling encoders to
+ * lifecycle's mutable history indexes. All methods are fail-safe and idempotent.
+ */
+export class AgeAwareEncodingState {
+    pushOrdinal = 0;
+    records = new Map();
+    seenReadPaths = new Set();
+    constructor(history = []) {
+        this.rehydrate(history);
+    }
+    /** Build the conservative context for a newly completed tool result. */
+    preparePush(tc, succeeded) {
+        const path = tc.name === 'read_file'
+            ? canonicalizePath(extractPath(tc.arguments))
+            : null;
+        const isFirstRead = path ? !this.seenReadPaths.has(path) : undefined;
+        this.records.set(tc.id, {
+            toolCallId: tc.id,
+            toolName: tc.name,
+            argsRaw: tc.arguments,
+            pushOrdinal: this.pushOrdinal,
+            succeeded,
+            isFirstRead,
+            agedEncoded: false,
+        });
+        this.pushOrdinal++;
+        // Failed reads must not consume the "first successful read" privilege.
+        if (succeeded && path)
+            this.seenReadPaths.add(path);
+        return {
+            age: 0,
+            isCold: false,
+            isFirstRead,
+            phase: 'push',
+        };
+    }
+    /** Re-encode eligible tool messages in the Cold prefix in place. */
+    sweep(history, hotBoundary) {
+        try {
+            const end = Math.min(Math.max(hotBoundary, 1), history.length);
+            for (let idx = 1; idx < end; idx++) {
+                const message = history[idx];
+                if (message.role !== 'tool')
+                    continue;
+                const toolMessage = message;
+                const id = toolMessage.tool_call_id;
+                const record = id ? this.records.get(id) : undefined;
+                if (!record || !record.succeeded || record.agedEncoded)
+                    continue;
+                const content = toText(toolMessage.content);
+                if (!content || content.startsWith('⌦[')) {
+                    record.agedEncoded = true;
+                    continue;
+                }
+                // Exclude the result's own push: immediately after insertion its age is 0.
+                const age = Math.max(0, this.pushOrdinal - record.pushOrdinal - 1);
+                if (age < TOOL_OLD_AGE)
+                    continue;
+                const encoded = optimizeToolResult(record.toolName, content, record.argsRaw, {
+                    age,
+                    isCold: true,
+                    isFirstRead: record.isFirstRead,
+                    phase: 'sweep',
+                });
+                // Aged encoding is a degradation step: never replace content with a
+                // representation that is equal-sized or larger.
+                if (encoded.length < content.length)
+                    toolMessage.content = encoded;
+                record.agedEncoded = true;
+            }
+        }
+        catch {
+            // Context optimization must never block an agent request.
+        }
+    }
+    /** Rebuild stable state after resume or structural history compaction. */
+    rehydrate(history) {
+        this.pushOrdinal = 0;
+        this.records.clear();
+        this.seenReadPaths.clear();
+        try {
+            const calls = new Map();
+            for (const message of history) {
+                if (message.role === 'assistant') {
+                    const toolCalls = message.tool_calls;
+                    for (const tc of toolCalls ?? []) {
+                        if (!tc.id || !tc.function?.name)
+                            continue;
+                        calls.set(tc.id, {
+                            name: tc.function.name,
+                            argsRaw: tc.function.arguments ?? '',
+                        });
+                    }
+                    continue;
+                }
+                if (message.role !== 'tool')
+                    continue;
+                const toolMessage = message;
+                const id = toolMessage.tool_call_id;
+                const call = id ? calls.get(id) : undefined;
+                if (!id || !call)
+                    continue;
+                const content = toText(toolMessage.content);
+                const succeeded = isToolResultSuccess(content);
+                const path = call.name === 'read_file'
+                    ? canonicalizePath(extractPath(call.argsRaw))
+                    : null;
+                const isFirstRead = path ? !this.seenReadPaths.has(path) : undefined;
+                this.records.set(id, {
+                    toolCallId: id,
+                    toolName: call.name,
+                    argsRaw: call.argsRaw,
+                    pushOrdinal: this.pushOrdinal,
+                    succeeded,
+                    isFirstRead,
+                    agedEncoded: false,
+                });
+                this.pushOrdinal++;
+                if (succeeded && path)
+                    this.seenReadPaths.add(path);
+            }
+        }
+        catch {
+            // A partial rebuild is conservative: unknown records simply stay full.
+        }
+    }
+}
+export function createAgeAwareEncodingState(history = []) {
+    return new AgeAwareEncodingState(history);
+}

package/dist/context/budget.js

@@ -1,30 +1,13 @@
 // 五区 Context Budget Scheduler。
 //
-// 目的:把当前四道独立闸(cap / pipeline / relevance / maybeCompact)统一为
-//       「先看预算报告,再按 ROI 排序调度」的单一入口。
+// 目的:把当前请求拆成 System / History / Tool-Recent / Tool-Old / Summary + Reserve，
+//      统一报告各区占用，并只调度执行层能够真正落地的 warn / compact_history。
 //
-// 设计原则(对应用户拍板的设计方案):
-//   1. 五区分账:不是把 history 当一个黑盒,而是把上下文切成 5 区逐区配预算
-//      (System / History / Tool-Recent / Tool-Old / Summary) + 1 个 Reserve。
-//      Tool 内部再分 Hot/Cold:
-//        - Cold Tool(老化区,scheduler 优先压缩——ROI 最低,LLM 复述成本最低)
-//        - Hot Tool(当前±N 步内,scheduler **不主动 stub**——避免干扰 agent 当前步)
-//      注:**Hot 区「scheduler 不主动」≠ 「绝对不动」**。lifecycle age stub、pruner
-//      same-path 替代、agent 的 drop_context 工具仍可动 Hot 区;它们语义更精细(知道
-//      哪条已无关),不会盲目 stub。Scheduler 只在更粗的层面决策,粗判断不踩精细判断。
-//      Hot 区超预算时 scheduler 仅 cap(降单条上限,不丢内容)。
-//   2. ROI 排序:History > Summary > Hot Tool > Cold Tool。压缩时先动 Cold Tool
-//      (LLM 复述成本最低),再动 History(摘要成本高);Hot Tool 与 System 雷打不动(指 scheduler 层面)。
-//   3. 零行为变化兜底:调度器不是闸,而是「报告 + 决策」——执行仍复用现有
-//      cap / pipeline / relevance / compact / lifecycle / drop_context 实现,只是触发条件更精准。
-//
-// 依赖:本文件是叶子级,只依赖 ChatMessage / estimateTokens,绝不反向依赖
-//      agent / session / compact(避免循环与耦合)。具体执行动作由 agent/core.ts
-//      拿 ScheduleAction[] 去调现有闸。
-//
-// 开关(MOCODE_BUDGET_SCHEDULER):默认 true。false 时 agent/core.ts 走老路径
-//      (直接 maybeCompact),完全跳过本模块,零行为变化。
-import { estimateMessagesTokens, estimateTokens } from '../llm/index.js';
+// push-time cap、pipeline、relevance、lifecycle 与 age-aware sweep 负责工具结果优化；
+// scheduler 在这些处理完成后评估，不重复生成 Cold/Hot tool 压缩动作。
+// 本文件保持叶子级，只依赖 ChatMessage / token estimate，具体执行由 session/scheduler.ts 完成。
+// contextBudget 开关关闭时，agent/core.ts 退化为直接调用 maybeCompact。
+import { chatTools, estimateMessagesTokens, estimateToolSchemaTokens, messageTokens, } from '../llm/index.js';
 import { toText } from './utils.js';
 /** 五区分账(占比对齐 CONTEXT_WINDOW)。顺序固定,便于遍历。 */
 export const BUDGET_LAYERS = [
@@ -35,33 +18,30 @@ export const BUDGET_LAYERS = [
     'summary',
     'reserve', // Reserve(不占内容,只占预算分配;5%)
 ];
-/** 占比(总和 = 0.95,留 5% 给 Reserve)。对齐用户修正版:
- *  Recent Tool 25%(原 40% 偏大,因 Hot 区不该被压)+ Old Tool 25% 同等 +
- *  History 20% + System 15% + Summary 10%(平时 0 占用,触发后才用) */
-export const BUDGET_RATIO = {
-    system: 0.15,
-    history: 0.20,
-    toolRecent: 0.25,
-    toolOld: 0.25,
-    summary: 0.10,
-    reserve: 0.05,
+export const DEFAULT_BUDGET_POLICY = {
+    ratios: {
+        system: 0.15,
+        history: 0.20,
+        toolRecent: 0.25,
+        toolOld: 0.25,
+        summary: 0.10,
+        reserve: 0.05,
+    },
+    hotTurnWindow: 4,
+    toolOldAge: 2,
+    compactKeepRatio: 0.40,
+    totalTriggerRatio: 0.82,
+    schedulerTargetRatio: 0.80,
+    estimateSafetyFactor: 1.05,
+    compactHeadroomTokens: 1500,
 };
-/** Hot/Cold 划分:当前 step 起往前 HOT_TURN_WINDOW 个 user turn 之内的工具结果视为 Hot,
- * 之外的视为 Cold。0 = 全 Cold(等同老路径);越短 Hot 越小,压缩越激进。 */
-export const HOT_TURN_WINDOW = 4;
-/** 工具消息推入历史后,经过的「消费者 push 次数」即 age。
- * Cold 区内:age ≥ TOOL_OLD_AGE 的非观察类工具结果可被调度器就地 stub。
- * 默认 2 = 跨过 2 个消费者 push 仍未被消费,等同 lifecycle 的 DEFAULT_AGE_THRESHOLD。 */
-export const TOOL_OLD_AGE = 2;
+/** 兼容既有调用方的只读别名；配置只在 DEFAULT_BUDGET_POLICY 中维护。 */
+export const BUDGET_RATIO = DEFAULT_BUDGET_POLICY.ratios;
+export const HOT_TURN_WINDOW = DEFAULT_BUDGET_POLICY.hotTurnWindow;
+export const TOOL_OLD_AGE = DEFAULT_BUDGET_POLICY.toolOldAge;
 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 +59,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 +70,12 @@ 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));
+    const systemCosts = {
+        prompt: sysMsg ? msgTokens(sysMsg) : 0,
+        toolSchemas: estimateToolSchemaTokens(activeTools),
+    };
+    // 工具 schema 与 system prompt 同属请求固定开销；必须计入总量才能可靠触发压缩。
+    layers.system.actual = adj(systemCosts.prompt + systemCosts.toolSchemas);
     // Summary 检测:role:'system' 且不是 history[0] 的,视为摘要(compact.ts 摘要插 index 1)。
     // 简单启发:若 history[1]?.role === 'system' 且 content 含「# 会话摘要」特征串,计入 summary。
     // 命中时循环跳过 i=1;不命中时当作普通 message(罕见,落到下方 user/assistant 分支)。
@@ -135,61 +120,46 @@ export function evaluateBudget(history, window, step = 0, correction = 1) {
     // 按 overRatio 降序
     triggers.sort((a, b) => layers[b].overRatio - layers[a].overRatio);
     const total = BUDGET_LAYERS.reduce((s, k) => s + (k === 'reserve' ? 0 : layers[k].actual), 0);
-    // 安全裕量:用 0.82 而非 0.85,预留 3% 给 correction 波动与新消息增量。
-    const totalOver = total >= 0.82 * window;
+    const totalOver = total >= DEFAULT_BUDGET_POLICY.totalTriggerRatio * window;
     return {
         step,
         total,
         window,
         layers,
+        systemCosts,
         triggers,
         totalOver,
         hotBoundary: hotStart,
         correction,
     };
 }
-/** 根据 BudgetReport 生成调度动作(从轻到重,直至总占用回落到阈值以下)。
- * 规则:
- *   - system 超 → warn(不压,配置问题不是内容问题)
- *   - toolOld 超 → 先 L1(中截超大)→ L2(same-path 已有 relevance)→ L3(age stub,新增)
- *   - toolRecent 超 → cap(只降低单条上限,不 stub)
- *   - history 超 或 totalOver → compact_history(调 maybeCompact / compactHistory)
- *   - summary 超 → 不动(摘要本身就压缩产物,删它等于丢历史,只能放任或扩 Recent 预算)
- *
- * 安全裕量:headroom 按 0.80 * window - total * 1.05 计算(预留 5% 应对 correction 误差
- * 与新消息增量),避免估算偏差导致被 API 硬截断。 */
+/** 根据 BudgetReport 生成可执行动作。
+ * push-time cap、relevance、lifecycle 与 age-aware sweep 已在评估前完成，
+ * 因此这里不再生成无法执行的 Cold/Hot tool action。
+ * History 或总量超预算时才考虑昂贵的 LLM 摘要。 */
 export function scheduleActions(report) {
     const actions = [];
     const { layers, totalOver, total } = report;
-    // 收紧:0.80 阈值(原 0.85)+ total * 1.05 放大(估算不确定性缓冲)
-    const headroom = 0.80 * report.window - total * 1.05;
-    // system 超 → warn,不是 schedule 目标
+    const policy = DEFAULT_BUDGET_POLICY;
+    const headroom = policy.schedulerTargetRatio * report.window
+        - total * policy.estimateSafetyFactor;
     if (layers.system.overBudget) {
+        const { prompt, toolSchemas } = report.systemCosts;
+        const { actual, budget } = layers.system;
+        const excess = actual - budget;
+        const percent = ((actual / Math.max(budget, 1)) * 100).toFixed(0);
         actions.push({
             kind: 'warn',
             layer: 'system',
-            reason: `System prompt 超预算(${layers.system.actual} > ${layers.system.budget}),请检查配置/MOCODE.md`,
+            reason: `固定请求开销 ${actual}/${budget} tokens (+${excess}, ${percent}%)；`
+                + `系统提示 ${prompt} + 工具 schema ${toolSchemas}，校正 ×${report.correction.toFixed(2)}。`
+                + '系统提示偏高时检查 MOCODE.md；工具 schema 偏高时减少可用工具；CONTEXT_WINDOW_TOKENS 应匹配模型真实窗口。',
         });
     }
-    // 渐进:toolOld(轻→重)
-    if (layers.toolOld.overBudget && layers.toolOld.overRatio > 0.1) {
-        actions.push({ kind: 'shrink_cold_tools', level: 1 });
-    }
-    if (layers.toolOld.overBudget && layers.toolOld.overRatio > 0.3) {
-        actions.push({ kind: 'shrink_cold_tools', level: 2 });
-    }
-    if (layers.toolOld.overBudget && layers.toolOld.overRatio > 0.6) {
-        actions.push({ kind: 'shrink_cold_tools', level: 3 });
-    }
-    // Hot 区只 cap
-    if (layers.toolRecent.overBudget && layers.toolRecent.overRatio > 0.15) {
-        actions.push({ kind: 'cap_hot_tools', aggressive: layers.toolRecent.overRatio > 0.5 });
-    }
-    // History / total 超 → 摘要(最贵);headroom < -1500 真正触发(原 -2000,裕量收紧后同步调低),让 cold tools 先动
-    if ((layers.history.overBudget || totalOver) && headroom < -1500) {
+    if ((layers.history.overBudget || totalOver)
+        && headroom < -policy.compactHeadroomTokens) {
         actions.push({ kind: 'compact_history' });
     }
-    // 排序(同 kind 已在上面排好):warn → cold L1→L2→L3 → cap_hot → compact_history
     return actions;
 }
 /** 拍平成人类可读(供 /context 命令与 check-budget 脚本用)。 */