mocode-ai 0.6.6 → 0.6.7

package/dist/agent/core.js

@@ -12,13 +12,24 @@ 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 {
@@ -105,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);
@@ -193,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;
@@ -228,6 +243,7 @@ export async function runAgentCore(opts) {
         hooks.onAbort?.();
         history.length = 0;
         history.push(...savedHistory);
+        ageAware?.rehydrate(history);
         setAgentMode(savedMode);
     };
     try {
@@ -245,8 +261,10 @@ export async function runAgentCore(opts) {
             const storedCalibration = getTokenCalibration(requestBaseURL, requestModel, activeTools);
             runtimeContextState.correction = storedCalibration.correction;
             runtimeContextState.calibrationSamples = storedCalibration.samples;
-            // 步前:五区 Budget Scheduler 决策——按 ROI 调度(冷工具优先 / history 摘要最后)。
-            // 开关关闭(scheduler=null)时退化回原 maybeCompact 路径,零行为变化。
+            // 初次 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) {
@@ -256,11 +274,13 @@ export async function runAgentCore(opts) {
                 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';

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,29 +1,12 @@
 // 五区 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),完全跳过本模块,零行为变化。
+// 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)。顺序固定,便于遍历。 */
@@ -35,24 +18,27 @@ 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) {
     // 与请求预估复用同一实现，避免角色结构开销、多模态和 tool_calls 在两个预算路径中漂移。
     return messageTokens(m);
@@ -84,8 +70,12 @@ export function evaluateBudget(history, window, step = 0, correction = 1, active
     // 校正后的 token 数:raw * correction,最小 1(raw > 0 时)。
     const adj = (raw) => (raw > 0 ? Math.max(1, Math.round(raw * correction)) : 0);
     const sysMsg = history[0];
+    const systemCosts = {
+        prompt: sysMsg ? msgTokens(sysMsg) : 0,
+        toolSchemas: estimateToolSchemaTokens(activeTools),
+    };
     // 工具 schema 与 system prompt 同属请求固定开销；必须计入总量才能可靠触发压缩。
-    layers.system.actual = adj((sysMsg ? msgTokens(sysMsg) : 0) + estimateToolSchemaTokens(activeTools));
+    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 分支)。
@@ -130,61 +120,46 @@ export function evaluateBudget(history, window, step = 0, correction = 1, active
     // 按 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 脚本用)。 */