mocode-ai 0.6.2 → 0.6.4

package/dist/agent/core.js

@@ -14,6 +14,7 @@ import { maybeCompact, contextState, dropContextFromHistory } from '../session/i
 import { createBudgetScheduler } from '../session/scheduler.js';
 import { optimizeToolResult } from '../context/index.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';
@@ -103,7 +104,7 @@ 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) {
+function pushToolResult(history, tc, output, pruner, lifecycle, scheduler, runtimeContextState = contextState) {
     const msg = {
         role: 'tool',
         tool_call_id: tc.id,
@@ -112,14 +113,13 @@ function pushToolResult(history, tc, output, pruner, lifecycle, scheduler) {
         content: optimizeToolResult(tc.name, output, tc.arguments),
     };
     history.push(msg);
-    // 相关性裁剪:只动 read_file / edit_file / write_file 三类(其它 tool 与本层无关)。
-    // pruner 内部 try/catch + 幂等,永不抛错;开关关闭时 pruner=null 完全跳过。
+    const succeeded = isToolResultSuccess(output);
+    // 失败 read 不得淘汰旧 read；失败 consumer 也不能改变 lifecycle 上游状态。
     if (pruner)
-        pruner.observePush(history, msg);
-    // 观察者生命周期:新 push 一律先登记 LIVE;内部自动维护 producer/consumer 图 + 老化 STUB。
-    // lifecycle 内部 try/catch + 幂等;开关关闭时 lifecycle=null 完全跳过。
+        pruner.observePush(history, msg, succeeded);
     if (lifecycle)
-        lifecycle.pushTool(history, history.length - 1);
+        lifecycle.pushTool(history, history.length - 1, succeeded);
+    runtimeContextState.lifecycleStats = lifecycle?.stats();
 }
 /**
  * agent 核心循环(纯逻辑):
@@ -186,7 +186,12 @@ export async function runAgentCore(opts) {
     // 观察者生命周期引擎:每个 runAgentCore 实例一个,纯静态、自动维护 grep/glob/codegraph 等
     // producer 与 read/edit/write 的 consumer 引用关系;孤立+老化的非观察类工具自动 STUB。
     // 开关关闭时为 null,所有 pushToolResult / mutation 调用走无 lifecycle 路径(零行为变化)。
-    const lifecycle = config.contextLifecycle ? createLifecycleEngine() : null;
+    // 引擎需要从已有会话 history 恢复观察结果的年龄和 path 索引；不能只追踪本次
+    // runAgentCore，否则跨用户轮次的 grep/glob 永远不会衰减。
+    let lifecycle = config.contextLifecycle
+        ? createLifecycleEngine(history)
+        : null;
+    runtimeContextState.lifecycleStats = lifecycle?.stats();
     // 预算调度器:每个 runAgentCore 实例一个,步前 evaluateBudget + scheduleActions。
     // 决策按 ROI 分发(cold tools 优先 / history 摘要最后);contextBudget 开关关闭时为 null。
     const scheduler = config.contextBudget !== false
@@ -234,11 +239,19 @@ export async function runAgentCore(opts) {
             // 步前:五区 Budget Scheduler 决策——按 ROI 调度(冷工具优先 / history 摘要最后)。
             // 开关关闭(scheduler=null)时退化回原 maybeCompact 路径,零行为变化。
             // 此时 spinner 已停,通知行干净。
+            let historyRebuilt = false;
             if (scheduler) {
-                await scheduler.runStep(history, step);
+                historyRebuilt = await scheduler.runStep(history, step);
             }
             else {
-                await maybeCompact(history, undefined, undefined, runtimeContextState);
+                const compactResult = await maybeCompact(history, undefined, undefined, runtimeContextState);
+                historyRebuilt = compactResult?.historyRebuilt === true;
+            }
+            // compact 用新消息数组原地重建 history 后，旧 lifecycle 的数字 index 已全部失效。
+            // 立即从新 history 恢复状态和 producer 索引，再允许后续 pushTool/pushMutation 使用。
+            if (historyRebuilt && lifecycle) {
+                lifecycle = createLifecycleEngine(history);
+                runtimeContextState.lifecycleStats = lifecycle.stats();
             }
             hooks.onStepStart?.(); // 主 agent:spinner.start('思考中')
             mode = 'idle';
@@ -438,16 +451,13 @@ export async function runAgentCore(opts) {
                         // Thrashing:同上(history 附 hint,UI 干净)
                         const hint = recordAndHint(tc.name, tc.arguments);
                         pushToolResult(history, tc, hint ? `${output}${hint}` : output, relprune, lifecycle, scheduler);
-                        // 相关性裁剪 mutation 通知:edit_file/write_file 后,该 path 之前的所有 read_file
-                        // 结果已失效(已不再是文件当前状态)→ stub 为存根。pruner 内部 try/catch + 幂等。
-                        // 非 mutation 工具(run_command/use_skill/memory_* 等)此处 path="" 不触发。
-                        // 观察者生命周期:mutation push 后通知 lifecycle 把同 path 的旧 read 标 REFERENCED。
-                        if (relprune && isMutationTool(tc.name)) {
+                        // 只有成功 mutation 才会使旧 read 失效；pruner 与 lifecycle 独立启停。
+                        if (isMutationTool(tc.name) && isToolResultSuccess(output)) {
                             const mp = mutationParsed?.path;
                             if (typeof mp === 'string' && mp) {
-                                relprune.observeMutation(history, mp);
-                                if (lifecycle)
-                                    lifecycle.pushMutation(history, history.length - 1, mp);
+                                relprune?.observeMutation(history, mp);
+                                lifecycle?.pushMutation(history, history.length - 1, mp);
+                                runtimeContextState.lifecycleStats = lifecycle?.stats();
                             }
                         }
                         i++;

package/dist/context/lifecycle.js

@@ -9,9 +9,11 @@
 //   - OBSOLETE:无任何消费者引用,且距离当前 push 已老化 N 步(默认 2)。
 //   - STUB:已被替换为存根(物理上 content 变成「⌦[无消费者:...]」)。
 //
-// 用户拍板的激进风险护栏(避免误伤):
-//   - grep/glob/codegraph/web_search/web_fetch 等「观察/检索类」工具,**永远只到 REFERENCED**,
-//     不参与自动 STUB。理由:返回多个候选(grep 10 文件但你只读 1 个),剩余候选可能后续被消费。
+// 观察类工具两阶段衰减(避免误伤):
+//   - grep/glob/codegraph/web_search/web_fetch 等「观察/检索类」工具两阶段衰减:
+//     Phase 1(10 步):LIVE → REFERENCED,保留完整内容(返回多个候选,剩余候选可能后续被消费)。
+//     Phase 2(+5 步):REFERENCED → DIGEST,替换为摘要存根(保留文件列表+命中数+参数,丢弃详情),
+//     释放 ~90% token。states 仍为 REFERENCED,不引入新状态。
 //   - 当前轮保护区(最后一个 user 之后的工具结果)完全不动。
 //   - 已 STUB(含「⌦[已过时:...]」或「⌦[已剔除:...]」或本层的「⌦[无消费者:...]」)不重复处理。
 //   - 永不抛错(对齐上下文管道的「调度器永不抛错」契约)。
@@ -19,15 +21,16 @@
 //
 // 与 Relevance Pruner 的分工(不重复):
 //   - Relevance Pruner:管 read_file 同 path 旧 read + mutation 覆写 → 直接 STUB。
-//   - 本层:管「无消费者的观察类工具老化后 → STUB」 + 「被消费的工具 → REFERENCED 标记(可视)」。
+//   - 本层:管「观察类工具老化后 → DIGEST、普通孤立工具老化后 → STUB」+
+//     「被消费的工具 → REFERENCED 标记(可视)」。
 //
 // 触发点(agent/core.ts):
 //   - pushToolResult 出口,新 message idx = history.length - 1。
 //   - mutation 分支额外调 pushMutation 通知(也走 observeMutation 同语义)。
 //
 // 开关:`config.contextLifecycle`(默认 true;MOCODE_LIFECYCLE=false 回退)。
-import { extractPath, lastUserIndex, toText, toolNameOf } from './utils.js';
-/** 观察类工具(永远只到 REFERENCED,不参与自动 STUB)。 */
+import { canonicalizePath, extractPath, isToolResultSuccess, lastUserIndex, toText, toolNameOf, } from './utils.js';
+/** 观察类工具(LIVE → REFERENCED → DIGEST 两阶段衰减,永不自动 STUB)。 */
 const OBSERVER_TOOLS = new Set([
     'grep',
     'glob',
@@ -42,10 +45,19 @@ const CONSUMER_TOOLS = new Set(['read_file', 'edit_file', 'write_file']);
 const MUTATION_TOOLS = new Set(['edit_file', 'write_file']);
 /** 存根前缀(区分 Relevance Pruner 与 drop_context)。 */
 const STUB_PREFIX_NO_CONSUMER = '⌦[无消费者:观察结果已无引用价值]';
+/** 观察类工具摘要前缀(DIGEST 状态标记)。 */
+const DIGEST_PREFIX = '⌦[摘要:';
 /** 老化阈值:某条工具消息自 push 以来经历的「消费者 push」次数。
  *  ≥ 这个值且仍为 LIVE 且非观察类 → 视为 OBSOLETE → STUB。
  *  默认 2:等价于「跨过两个消费者 push 仍无人引用」= 跨过整轮最末尾的工具调用。 */
 const DEFAULT_AGE_THRESHOLD = 2;
+/** 观察类工具 Phase 1:LIVE → REFERENCED 的老化阈值(普通工具用 DEFAULT_AGE_THRESHOLD=2)。
+ *  10 步后才降为 REFERENCED,保留完整内容;理由:返回多个候选(grep 10 文件但只读 1 个),
+ *  剩余候选可能后续被消费,给足够时间窗口。 */
+const OBSERVER_REFERENCED_AGE = 10;
+/** 观察类工具 Phase 2:REFERENCED → DIGEST 的老化阈值(从 REFERENCED 起再累积)。
+ *  +5 步后替换为摘要存根,保留文件列表+命中数+参数,丢弃详情;释放 ~90% token。 */
+const OBSERVER_DIGEST_AGE = 5;
 /** 从 tool 结果的 content 中提取「生产者命中过的 path 列表」。
  *  - read_file:没有 path 列表(本身就是单 path 消费者,无需再追生产者)。
  *  - grep:content 是 `file:line: ...` 行,提取每行的 file 段(只保留绝对路径形态或与 pattern 匹配的)。
@@ -58,14 +70,22 @@ function extractProducerPaths(toolName, content) {
     if (!content)
         return [];
     const out = new Set();
+    const addPath = (raw) => {
+        const canonical = canonicalizePath(raw);
+        if (canonical)
+            out.add(canonical);
+    };
     try {
         if (toolName === 'grep') {
-            // 典型行:`src/foo.ts:42: hello world` 或 `path\to\file.ts:42: ...`
-            // 取冒号前段(冒号必须跟在数字前面避免切到路径里的冒号)。
-            const re = /^([^\s:][^:]*?\.[A-Za-z0-9]+):(\d+):/gm;
+            // grep 内置工具的结构化输出是 `path: N 处匹配,行号 [...]`；旧格式也可能是
+            // `path:line: content`。两者都必须建立 producer 索引，供后续 read_file 关联。
+            const rawLine = /^(.+?\.[A-Za-z0-9]+):\d+:/gm;
+            const summaryHeader = /^(.+?\.[A-Za-z0-9]+):\s*\d+\s*(?:处匹配|matches?)[,，]/gmi;
             let m;
-            while ((m = re.exec(content)))
-                out.add(m[1]);
+            while ((m = rawLine.exec(content)))
+                addPath(m[1]);
+            while ((m = summaryHeader.exec(content)))
+                addPath(m[1]);
         }
         else if (toolName === 'glob') {
             // glob 输出一般是「paths:」+ 换行 + 多路径;每行一个绝对或相对路径。
@@ -76,7 +96,7 @@ function extractProducerPaths(toolName, content) {
                     continue;
                 // 含扩展名或含路径分隔符
                 if (/\.[A-Za-z0-9]+$/.test(t) || t.includes('/') || t.includes('\\'))
-                    out.add(t);
+                    addPath(t);
             }
         }
         else if (toolName === 'codegraph') {
@@ -84,7 +104,7 @@ function extractProducerPaths(toolName, content) {
             for (const line of content.split(/\r?\n/)) {
                 const m = /^([^\s:][^:]*?\.[A-Za-z0-9]+):(\d+):/.exec(line);
                 if (m)
-                    out.add(m[1]);
+                    addPath(m[1]);
             }
         }
         else if (toolName === 'web_search' || toolName === 'web_fetch') {
@@ -113,17 +133,114 @@ export class LifecycleEngine {
     /** producer 路径 → 生产者工具消息 idx 列表(逆查用:某个 path 被消费时,反查上游 producer)。
      * 注意:不存 read_file,因为 read 自身就是消费者不充当 producer。 */
     producersByPath = new Map();
+    /** 已被 DIGEST 的 tool 消息 idx 集合(避免重复检查;states 保持 REFERENCED)。 */
+    digestedIdxs = new Set();
+    /** 摘要不比原文短而保留原文的 idx；仅抑制当前 run 内的重复计算。 */
+    digestRetainedIdxs = new Set();
     /** 当前步序号(用于 age 老化:每次 pushTool 自增,对比 age 阈值)。 */
     step = 0;
     /** 最后 user 索引缓存(pushTool 时重算;pushMutation 时也重算,因为 mutation 可能跟 user 同行)。 */
     lastUser = -1;
-    constructor(ageThreshold = DEFAULT_AGE_THRESHOLD) {
+    constructor(ageThreshold = DEFAULT_AGE_THRESHOLD, history) {
         this.ageThreshold = ageThreshold;
+        if (history)
+            this.rehydrate(history);
+    }
+    /**
+     * 从会话历史恢复生命周期状态。
+     *
+     * 旧轮只恢复 observer，使检索结果能跨轮继续老化；最后一个 user 之后则恢复全部成功、
+     * 未归档的工具结果，保证同一 runAgentCore 内 compact 重建 history 后不丢当前轮状态。
+     */
+    rehydrate(history) {
+        try {
+            const currentTurnStart = lastUserIndex(history);
+            let replayLastUser = -1;
+            const pendingDigests = new Set();
+            for (let idx = 1; idx < history.length; idx++) {
+                const m = history[idx];
+                if (m.role === 'user') {
+                    replayLastUser = idx;
+                    continue;
+                }
+                if (m.role !== 'tool')
+                    continue;
+                const toolName = toolNameOf(history, idx);
+                if (!toolName)
+                    continue;
+                const content = toText(m.content);
+                const isObserver = OBSERVER_TOOLS.has(toolName);
+                const isDigest = content.startsWith(DIGEST_PREFIX);
+                const isCurrentTurnTool = currentTurnStart >= 0 && idx > currentTurnStart;
+                const shouldRestoreLive = isToolResultSuccess(content) &&
+                    !content.startsWith('⌦[') &&
+                    (isObserver || isCurrentTurnTool);
+                if (shouldRestoreLive) {
+                    this.states.set(idx, 'LIVE');
+                    this.consumerCount.set(idx, 0);
+                    this.age.set(idx, 0);
+                    // 只有 observer 是 producer；当前轮普通工具只恢复自身状态。
+                    if (isObserver) {
+                        for (const path of extractProducerPaths(toolName, content)) {
+                            const producers = this.producersByPath.get(path) ?? [];
+                            producers.push(idx);
+                            this.producersByPath.set(path, producers);
+                        }
+                    }
+                }
+                else if (isObserver && isDigest) {
+                    this.states.set(idx, 'REFERENCED');
+                    this.consumerCount.set(idx, 0);
+                    this.age.set(idx, 0);
+                    this.digestedIdxs.add(idx);
+                }
+                if (isToolResultSuccess(content) && CONSUMER_TOOLS.has(toolName)) {
+                    const path = canonicalizePath(extractPath(this.findToolArgs(history, idx)));
+                    if (path) {
+                        for (const producerIdx of this.producersByPath.get(path) ?? []) {
+                            if (this.states.get(producerIdx) === 'LIVE') {
+                                this.states.set(producerIdx, 'REFERENCED');
+                            }
+                            this.consumerCount.set(producerIdx, (this.consumerCount.get(producerIdx) ?? 0) + 1);
+                        }
+                    }
+                }
+                for (const key of this.states.keys())
+                    this.age.set(key, (this.age.get(key) ?? 0) + 1);
+                this.step++;
+                // 和 pushTool 一致：本轮 user 及之后的结果不处理；旧轮结果可以推进。
+                for (const [observerIdx, state] of this.states) {
+                    if (observerIdx >= replayLastUser || this.isDigestFinalized(observerIdx))
+                        continue;
+                    const observerName = toolNameOf(history, observerIdx);
+                    if (!observerName || !OBSERVER_TOOLS.has(observerName))
+                        continue;
+                    const age = this.age.get(observerIdx) ?? 0;
+                    if (state === 'LIVE' && age >= OBSERVER_REFERENCED_AGE) {
+                        this.states.set(observerIdx, 'REFERENCED');
+                    }
+                    else if (state === 'REFERENCED'
+                        && age >= OBSERVER_REFERENCED_AGE + OBSERVER_DIGEST_AGE) {
+                        pendingDigests.add(observerIdx);
+                    }
+                }
+            }
+            this.lastUser = lastUserIndex(history);
+            // 回放期间只计算状态；最后统一落盘，避免迭代时破坏 path 提取。
+            for (const idx of pendingDigests) {
+                const toolName = toolNameOf(history, idx);
+                if (toolName && idx < Math.max(0, this.lastUser))
+                    this.digestOne(history, idx, toolName);
+            }
+        }
+        catch {
+            // 历史中出现非标准消息时降级为本轮行为，不能影响 agent 主循环。
+        }
     }
     /** 新工具结果 push 进 history 时调;idx = history.length - 1。
      *  mutation 工具(edit_file/write_file)的 push 跳过本轮的 autoStubOrphans(由调用方在
      *  pushMutation 标完 read REFERENCED 之后再触发),避免刚被 mutation 消费的 read 被提前 STUB。 */
-    pushTool(history, idx) {
+    pushTool(history, idx, succeeded = true) {
         try {
             const m = history[idx];
             if (!m || m.role !== 'tool')
@@ -131,6 +248,9 @@ export class LifecycleEngine {
             const toolName = toolNameOf(history, idx);
             if (!toolName)
                 return;
+            // 失败工具结果只保留给模型诊断，不登记为 observation、不会推动老化或污染统计。
+            if (!succeeded)
+                return;
             // 已 stub 的不重复登记(幂等)。
             const c = toText(m.content);
             if (c.startsWith('⌦['))
@@ -139,8 +259,8 @@ export class LifecycleEngine {
             this.states.set(idx, 'LIVE');
             this.consumerCount.set(idx, 0);
             this.age.set(idx, 0);
-            // 如果是 producer 类工具(grep/glob/codegraph),登记其命中的路径。
-            if (OBSERVER_TOOLS.has(toolName)) {
+            // 成功的 producer 才建立路径索引；失败结果仍可进入生命周期，但不能成为证据来源。
+            if (succeeded && OBSERVER_TOOLS.has(toolName)) {
                 const paths = extractProducerPaths(toolName, c);
                 for (const p of paths) {
                     const arr = this.producersByPath.get(p) ?? [];
@@ -149,8 +269,8 @@ export class LifecycleEngine {
                     this.producersByPath.set(p, arr);
                 }
             }
-            // 如果是 consumer 类工具(read/edit/write),找出上游「被消费的 producer」,标 REFERENCED。
-            if (CONSUMER_TOOLS.has(toolName)) {
+            // 只有成功 consumer 才能消费上游；失败 read/edit/write 不改变旧数据状态。
+            if (succeeded && CONSUMER_TOOLS.has(toolName)) {
                 const argsRaw = (() => {
                     // tool 消息本身没有 args;args 在前导 assistant.tool_calls 里;直接走同 idx 前的 assistant。
                     const tcId = m.tool_call_id;
@@ -165,7 +285,7 @@ export class LifecycleEngine {
                     }
                     return '';
                 })();
-                const path = extractPath(argsRaw);
+                const path = canonicalizePath(extractPath(argsRaw));
                 if (path) {
                     // 1) 找该 path 的所有上游 producer(grep/glob/codegraph)→ 标 REFERENCED。
                     const producers = this.producersByPath.get(path);
@@ -187,8 +307,7 @@ export class LifecycleEngine {
             }
             this.step++;
             this.lastUser = lastUserIndex(history);
-            // mutation 工具跳过本轮 autoStubOrphans:调用方会调 pushMutation 标完 read REFERENCED 后,
-            // 再调 flushAutoStub 触发老化检查,避免 read 在被标 REFERENCED 之前被提前 STUB。
+            // 成功 mutation 跳过本轮 autoStubOrphans；调用方会在 pushMutation 标完旧 read 后统一检查。
             if (MUTATION_TOOLS.has(toolName))
                 return;
             // 老化检查:本次 push 完,扫描 LIVE(且非观察类)的工具消息,age ≥ 阈值 → 标 OBSOLETE → STUB。
@@ -203,6 +322,11 @@ export class LifecycleEngine {
      *  注意:puhToolResult 出口已经登记过 mutation 本身,这里不再调 pushTool(避免 age 翻倍)。 */
     pushMutation(history, mutationIdx, path) {
         try {
+            const mutationPath = canonicalizePath(path);
+            if (!mutationPath) {
+                this.autoStubOrphans(history);
+                return;
+            }
             // mutation 自身已在 pushToolResult 出口登记(若 lifecycle 存在);此处仅做「mutation 是
             // path 的消费者」语义:把该 path 在 mutation 之前的所有 read_file(未被 stub 的 LIVE/REFERENCED)
             // 标 REFERENCED。
@@ -220,7 +344,7 @@ export class LifecycleEngine {
                 if (c.startsWith('⌦['))
                     continue;
                 const argsRaw = this.findToolArgs(history, i);
-                if (extractPath(argsRaw) === path) {
+                if (canonicalizePath(extractPath(argsRaw)) === mutationPath) {
                     if (this.states.get(i) === 'LIVE')
                         this.states.set(i, 'REFERENCED');
                     this.consumerCount.set(i, (this.consumerCount.get(i) ?? 0) + 1);
@@ -233,27 +357,44 @@ export class LifecycleEngine {
             // 永不抛错。
         }
     }
-    /** 老化自动 STUB:扫描所有 LIVE(且非观察类)且 age ≥ 阈值且不在保护区的工具消息 → OBSOLETE → STUB。 */
+    /** 老化自动处理:
+     *  - 非观察类 LIVE 且 age ≥ 阈值 → OBSOLETE → STUB(完全丢弃)。
+     *  - 观察类工具两阶段衰减:
+     *    Phase 1: LIVE → REFERENCED(age ≥ OBSERVER_REFERENCED_AGE,保留完整内容)。
+     *    Phase 2: REFERENCED → DIGEST(增量 age ≥ OBSERVER_DIGEST_AGE,替换为摘要存根)。
+     *  - 当前轮保护区(最后一个 user 之后)完全不动。
+     */
     autoStubOrphans(history) {
         try {
             const protectedFrom = Math.max(0, this.lastUser);
             for (const [idx, state] of this.states) {
-                if (state !== 'LIVE')
-                    continue;
                 if (idx >= protectedFrom)
                     continue; // 当前轮保护区
                 const age = this.age.get(idx) ?? 0;
-                if (age < this.ageThreshold)
-                    continue;
                 const tn = toolNameOf(history, idx);
                 if (!tn)
                     continue;
-                // 观察类工具永远只到 REFERENCED,不自动 STUB(用户拍板)。
                 if (OBSERVER_TOOLS.has(tn)) {
-                    this.states.set(idx, 'REFERENCED');
+                    // Phase 1: LIVE → REFERENCED(保留完整内容)。
+                    if (state === 'LIVE' && age >= OBSERVER_REFERENCED_AGE) {
+                        this.states.set(idx, 'REFERENCED');
+                        continue;
+                    }
+                    // Phase 2: REFERENCED → DIGEST(替换为摘要存根,状态不变)。
+                    if (state === 'REFERENCED' && !this.isDigestFinalized(idx)) {
+                        // read_file 可能在很早时就把 producer 标成 REFERENCED；不能因此跳过
+                        // Phase 1 的保留窗口。摘要始终以 observer 自身的总 age 为准。
+                        if (age >= OBSERVER_REFERENCED_AGE + OBSERVER_DIGEST_AGE) {
+                            this.digestOne(history, idx, tn);
+                        }
+                    }
                     continue;
                 }
-                // 执行 STUB。
+                // 非观察类:只在 LIVE 状态下老化 STUB。
+                if (state !== 'LIVE')
+                    continue;
+                if (age < this.ageThreshold)
+                    continue;
                 this.stubOne(history, idx, tn);
             }
         }
@@ -279,6 +420,115 @@ export class LifecycleEngine {
             // 永不抛错。
         }
     }
+    /** 观察类工具 Phase 2:替换为摘要存根,保留文件列表+命中数+参数,丢弃详情。
+     *  幂等:已是 ⌦[ 前缀的跳过。states 保持 REFERENCED,只替换 content。 */
+    digestOne(history, idx, toolName) {
+        try {
+            const m = history[idx];
+            if (!m)
+                return;
+            const c = toText(m.content);
+            if (c.startsWith('⌦['))
+                return; // 幂等(已 STUB/DIGEST)
+            const origLen = c.length;
+            const argsRaw = this.findToolArgs(history, idx);
+            const summary = this.buildDigestSummary(toolName, c, argsRaw, origLen, extractProducerPaths(toolName, c));
+            // 摘要的唯一目标是降低上下文成本。短结果（如“未命中”）不能被固定文案放大。
+            if (summary.length >= origLen) {
+                this.digestRetainedIdxs.add(idx);
+                return;
+            }
+            m.content = summary;
+            // states 保持 REFERENCED;digestedIdxs 由 stats() 扣除显示。
+            this.digestedIdxs.add(idx);
+        }
+        catch {
+            // 永不抛错。
+        }
+    }
+    /** 为各观察类工具生成摘要字符串。只保留统计 + 参数,不保留详情(文件列表/URL/正文),
+     *  明确标注"这是历史摘要,需要最新信息请重新调用"。 */
+    buildDigestSummary(toolName, content, argsRaw, origLen, paths) {
+        const files = this.formatDigestPaths(paths);
+        switch (toolName) {
+            case 'grep': {
+                // 命中行数:content 里形如 `file:line:` 的行数
+                let lineCount = 0;
+                const re = /^[^\s:][^:]*?\.[A-Za-z0-9]+:\d+:/gm;
+                while (re.exec(content))
+                    lineCount++;
+                const args = (() => { try {
+                    const a = JSON.parse(argsRaw);
+                    let s = `"${a.pattern ?? ''}"`;
+                    if (a.glob)
+                        s += `, glob="${a.glob}"`;
+                    return s;
+                }
+                catch {
+                    return '...';
+                } })();
+                return `${DIGEST_PREFIX}grep(${args}) — 历史结果 ${lineCount} 行命中，文件 ${files}，${origLen}→摘要]\n如需完整详情或最新信息请重新调用 grep`;
+            }
+            case 'glob': {
+                const args = (() => { try {
+                    return `"${JSON.parse(argsRaw).pattern ?? ''}"`;
+                }
+                catch {
+                    return '...';
+                } })();
+                return `${DIGEST_PREFIX}glob(${args}) — 历史结果文件 ${files}，${origLen}→摘要]\n如需完整列表或最新信息请重新调用 glob`;
+            }
+            case 'codegraph': {
+                const args = (() => { try {
+                    const a = JSON.parse(argsRaw);
+                    return `"${a.query ?? ''}"`;
+                }
+                catch {
+                    return '...';
+                } })();
+                return `${DIGEST_PREFIX}codegraph(${args}) — 历史结果文件 ${files}，${origLen}→摘要]\n如需完整详情或最新信息请重新调用 codegraph`;
+            }
+            case 'web_search': {
+                // 统计结果数
+                let resultCount = 0;
+                const lines = content.split(/\r?\n/);
+                for (const line of lines) {
+                    if (/^\[\d+\]\s*.+/.test(line))
+                        resultCount++;
+                }
+                const query = (() => { try {
+                    return JSON.parse(argsRaw).query ?? '';
+                }
+                catch {
+                    return '';
+                } })();
+                return `${DIGEST_PREFIX}web_search("${query}") — 历史结果 ${resultCount} 条, ${origLen}→摘要]\n如需最新信息请重新调用 web_search`;
+            }
+            case 'web_fetch': {
+                const url = (() => { try {
+                    return JSON.parse(argsRaw).url ?? '';
+                }
+                catch {
+                    return '';
+                } })();
+                return `${DIGEST_PREFIX}web_fetch(${url}) — 历史结果已归档, ${origLen}→摘要]\n如需最新信息请重新调用 web_fetch`;
+            }
+            default:
+                return `${DIGEST_PREFIX}${toolName} — 历史结果已归档, ${origLen}→摘要]\n如需最新信息请重新调用 ${toolName}`;
+        }
+    }
+    isDigestFinalized(idx) {
+        return this.digestedIdxs.has(idx) || this.digestRetainedIdxs.has(idx);
+    }
+    /** 文件候选是摘要的关键可用信息；限量且去重，避免摘要本身重新膨胀。 */
+    formatDigestPaths(paths) {
+        const unique = [...new Set(paths)];
+        if (unique.length === 0)
+            return '0 个（未能从输出解析路径）';
+        const limit = 12;
+        const shown = unique.slice(0, limit).join(', ');
+        return unique.length > limit ? `${unique.length} 个 [${shown}, …]` : `${unique.length} 个 [${shown}]`;
+    }
     /** 找某条 tool 消息对应的 assistant.tool_calls.arguments。 */
     findToolArgs(history, idx) {
         try {
@@ -305,7 +555,8 @@ export class LifecycleEngine {
     getState(idx) {
         return this.states.get(idx) ?? null;
     }
-    /** 拿当前各状态计数。供 /context 显示「live=N, referenced=M, obsolete=K, stubbed=S」。 */
+    /** 拿当前各状态计数。供 /context 显示「live=N, referenced=M, digest=K, obsolete=J, stubbed=S」。
+     *  digested:已被摘要的观察类工具(states 仍为 REFERENCED,但 content 已替换为摘要)。 */
     stats() {
         let live = 0;
         let referenced = 0;
@@ -321,10 +572,12 @@ export class LifecycleEngine {
             else if (s === 'STUB')
                 stubbed++;
         }
-        return { live, referenced, obsolete, stubbed };
+        // digested 的 states 仍为 REFERENCED,从总 referenced 中扣除得到纯 REFERENCED 数。
+        return { live, referenced: referenced - this.digestedIdxs.size, digested: this.digestedIdxs.size, obsolete, stubbed };
     }
 }
-/** 默认单例工厂。runAgentCore 入口 new 一个,后续 pushTool / pushMutation 共享。 */
-export function createLifecycleEngine(ageThreshold) {
-    return new LifecycleEngine(ageThreshold);
+export function createLifecycleEngine(historyOrThreshold, ageThreshold) {
+    const history = Array.isArray(historyOrThreshold) ? historyOrThreshold : undefined;
+    const threshold = typeof historyOrThreshold === 'number' ? historyOrThreshold : ageThreshold;
+    return new LifecycleEngine(threshold, history);
 }

package/dist/context/relevance.js

@@ -22,7 +22,7 @@
 //   - TUI 渲染(hooks.onToolResult)用原始 output,与本层解耦——屏上看全量,LLM 看裁剪后版。
 //
 // 零行为变化兜底:开关 `config.contextRelprune` 关闭时,pipeline 路径完全不调本模块。
-import { extractPath, lastUserIndex, toText, toolNameOf } from './utils.js';
+import { canonicalizePath, extractPath, lastUserIndex, toText, toolNameOf } from './utils.js';
 /** stub 标记前缀(供幂等判定)。drop_context 用的是「⌦[已剔除:与当前任务无关]」,
  *  本层用「⌦[已过时:同 path 已有新 read / 已被 mutation 覆写]」,区分两类剔除来源。 */
 const STUB_PREFIX = '⌦[已过时:同 path 已有新 read / 已被 mutation 覆写]';
@@ -40,50 +40,27 @@ export class RelevancePruner {
     /** path → [history index, ...]  按插入序;最新在末尾。 */
     readByPath = new Map();
     /** 把刚 push 的消息通知 pruner。
-     *  - 只处理 tool 消息(role==='tool')。
-     *  - 只关心 read_file:登记 + 反向 stub 同 path 旧 read。
-     *  - 非 read_file 的 tool 消息:无操作(本层只管 read_file)。
-     *  - 非 tool 消息(assistant / user / system):无操作。
+     *  - 只处理成功的 read_file tool 消息；失败读取不能淘汰旧的有效结果。
+     *  - 登记当前 canonical path，并反向 stub 同 path 旧 read。
      */
-    observePush(history, msg) {
+    observePush(history, msg, succeeded = true) {
         try {
-            if (msg.role !== 'tool')
+            if (!succeeded || msg.role !== 'tool')
                 return;
             const m = msg;
-            const tcId = m.tool_call_id;
-            if (!tcId)
-                return;
             const idx = history.length - 1;
             if (idx < 1 || history[idx] !== msg)
                 return; // 防御:必须刚 push 到末尾
-            const name = toolNameOf(history, idx);
-            if (name !== 'read_file')
+            if (toolNameOf(history, idx) !== 'read_file')
                 return;
             const content = toText(msg.content);
             if (content.startsWith(STUB_PREFIX))
                 return; // 已是存根(防御)
-            // 从前导 assistant.tool_calls 找对应 tc.arguments(精确 path 来源)。
-            // 退化方案:从消息内容首行解析路径(read_file 输出形如 `\n     1\t...`,无 path;
-            // 故必须从 args 取)。找不到则保守不动。
-            let path = null;
-            for (let j = idx - 1; j >= 1; j--) {
-                const mm = history[j];
-                if (mm.role !== 'assistant')
-                    continue;
-                const tcs = mm.tool_calls;
-                if (!tcs)
-                    continue;
-                const hit = tcs.find((tc) => tc?.id === tcId);
-                if (hit) {
-                    path = extractPath(hit.function?.arguments);
-                    break;
-                }
-            }
+            const path = this.pathAt(history, idx);
             if (!path)
                 return;
-            // 先 stub 旧 read(同 path,idx 之前),再登记新 idx。
+            // 先 stub 旧 read(同 canonical path,idx 之前),再登记新 idx。
             this.stubPriorReads(history, path, idx);
-            // 登记新 idx
             const list = this.readByPath.get(path);
             if (list)
                 list.push(idx);
@@ -94,47 +71,47 @@ export class RelevancePruner {
             /* 永不抛错 */
         }
     }
-    /**
-     * 把该 mutation path 的"在 mutation 之前的" read 全部 stub。
-     * 通常用于 edit_file / write_file 工具:mutation 之后,之前的 read_file(p) 内容
-     * 已失效(已不再是文件当前状态),模型后续若依赖旧 read 来 edit_file 会失败,但 edit_file
-     * 的 old_string 来自模型记忆/后读,不依赖旧 read 结果文本。
-     *
-     * 调用时机:agent/core.ts 在 mutation 工具调用的 pushToolResult 之后立即调;
-     * 此时 history 末尾就是 mutation 的 tool 消息,prior reads 指 < idx。
-     */
+    /** 从 tool_call arguments 取得并规范化某条 read_file 的路径。 */
+    pathAt(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')
+                continue;
+            const tcs = mm.tool_calls;
+            const hit = tcs?.find((tc) => tc?.id === tcId);
+            if (hit)
+                return canonicalizePath(extractPath(hit.function?.arguments));
+        }
+        return null;
+    }
+    /** 成功 mutation 后，把该 canonical path 在 mutation 之前的 read 全部 stub。 */
     observeMutation(history, path) {
         try {
-            if (!path)
+            const canonicalPath = canonicalizePath(path);
+            if (!canonicalPath)
                 return;
             const idx = history.length - 1;
             if (idx < 1)
                 return;
-            // mutation 之前的所有同 path read → stub
-            this.stubPriorReads(history, path, idx);
-            // 该 path 的 read 索引全部作废(mutation 之后再 read 会重新登记)
-            this.readByPath.delete(path);
+            this.stubPriorReads(history, canonicalPath, idx);
+            this.readByPath.delete(canonicalPath);
         }
         catch {
             /* 永不抛错 */
         }
     }
     /**
-     * 把 history 里 "path 同 + index < beforeIdx + 不在当前轮保护区" 的所有 read_file
-     * tool 消息替换为存根(只改 .content,不动 id / 数组结构)。
-     *
-     * 实现:
-     *  - 用 readByPath[path] 直接拿到所有 index(已登记过),筛 < beforeIdx 的 stub。
-     *  - 同时扫一遍 [1, beforeIdx) 区间找未登记的(防御:索引可能漏登;不依赖索引也能 stub,
-     *    保证正确性。索引只用于"避免重复扫全表"的优化)。
-     *  - protectedFrom = lastUserIndex(history):user 之后一律不动。
-     *  - 幂等:已是 STUB_PREFIX 的跳过。
+     * 把 history 里 "canonical path 同 + index < beforeIdx + 不在当前轮保护区" 的 read_file
+     * tool 消息替换为存根。索引是快路径，全表扫描用于恢复 resume 历史；两条路径都重新校验 path。
      */
     stubPriorReads(history, path, beforeIdx) {
-        const STUB_PREFIX_LOCAL = STUB_PREFIX;
+        const targetPath = canonicalizePath(path);
+        if (!targetPath)
+            return;
         const guard = lastUserIndex(history);
-        // protectedFrom = 最后一个 user index(若 >0);user 之后(>= guard)的 read 永不动。
-        // protectedFrom=0 表示无 user(history 只有 system),整段都可 stub。
         const protectedFrom = guard > 0 ? guard : 0;
         const stubOne = (i) => {
             if (i >= beforeIdx)
@@ -145,30 +122,26 @@ export class RelevancePruner {
             if (!m || m.role !== 'tool')
                 return;
             const content = toText(m.content);
-            if (content.startsWith(STUB_PREFIX_LOCAL))
+            if (content.startsWith(STUB_PREFIX))
                 return; // 幂等
-            const name = toolNameOf(history, i);
-            if (name !== 'read_file')
+            if (toolNameOf(history, i) !== 'read_file')
                 return;
-            // 校验 tool_call_id 配对(防御:孤儿子消息不动)
+            if (this.pathAt(history, i) !== targetPath)
+                return; // 防止 fallback 扫描误裁其他文件
             const tcId = m.tool_call_id;
             if (!tcId)
                 return;
-            const stub = `${STUB_PREFIX_LOCAL} read_file(${path}) ${content.length} 字符 → 已被新 read / mutation 替代 · id …${tcId.slice(-6)}⌫`;
+            const stub = `${STUB_PREFIX} read_file(${targetPath}) ${content.length} 字符 → 已被新 read / mutation 替代 · id …${tcId.slice(-6)}⌫`;
             m.content = stub;
         };
-        // 1) 用 Map 索引(快路径)
-        const indexed = this.readByPath.get(path);
+        const indexed = this.readByPath.get(targetPath);
         if (indexed) {
             for (const i of indexed)
                 stubOne(i);
         }
-        // 2) 全表扫一遍(防御:索引可能漏登 / 历史来自 resume)
-        //    仅扫 [1, beforeIdx) 且不在保护区内的 range,成本可控。
         const scanEnd = Math.min(beforeIdx, protectedFrom > 0 ? protectedFrom : beforeIdx);
-        for (let i = 1; i < scanEnd; i++) {
+        for (let i = 1; i < scanEnd; i++)
             stubOne(i);
-        }
     }
 }
 /** 默认单例:每个 agent 循环一个。runAgentCore 入口 new 一个,后续 observe 共享。 */
@@ -200,7 +173,10 @@ export function computePruneStats(history) {
         if (m.role !== 'tool')
             continue;
         const c = toText(m.content);
-        if (!c.startsWith(STUB_PREFIX))
+        // Relevance Pruner 的 stub(⌦[已过时:...) 和 Lifecycle Engine 的 DIGEST(⌦[摘要:...) 都统计。
+        const isPruneStub = c.startsWith(STUB_PREFIX);
+        const isDigest = c.startsWith('⌦[摘要:');
+        if (!isPruneStub && !isDigest)
             continue;
         stubbed++;
         stubChars += c.length;

package/dist/context/utils.js

@@ -6,6 +6,24 @@
 // 不变量:
 //  - 永不抛错(对齐「调度器永不抛错」契约)。
 //  - 仅依赖 `ChatMessage` 的最小形状,不反向 import agent / session / tools。
+import path from 'node:path';
+/** 将文件路径统一成可用于跨工具关联的绝对 key。
+ * Windows 路径不区分大小写，并统一使用 `/`，避免相对/绝对路径及分隔符差异导致漏配。 */
+export function canonicalizePath(input) {
+    if (!input?.trim())
+        return null;
+    try {
+        const normalized = path.resolve(input.trim()).replace(/\\/g, '/');
+        return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+    }
+    catch {
+        return null;
+    }
+}
+/** 工具层以 `错误:` 作为统一失败前缀；失败结果不得消费或淘汰已有观察数据。 */
+export function isToolResultSuccess(output) {
+    return !output.trimStart().startsWith('错误:');
+}
 /** 把消息 content 拍平成字符串(OpenAI 可能 string / null / 多模态数组)。
  *  用于估算 token、内容匹配、stub 拼接等场景。 */
 export function toText(content) {

package/dist/repl/index.js

@@ -19,6 +19,7 @@ import { tools } from '../tools/registry.js';
 import { estimateMessagesTokens, reconfigureClient, } from '../llm/index.js';
 import { loadImageAttachment, renderChip, MAX_INLINE_BYTES_DEFAULT, } from '../attachments/image.js';
 import { modelSupportsVision } from '../llm/capabilities.js';
+import { computePruneStats } from '../context/relevance.js';
 import { manualCompact, contextState, newSessionId, saveSession, loadSession, listSessions, } from '../session/index.js';
 import { listTurns, planRollback, applyRollback, persistSnapshots, loadSnapshots, rebuildFromHistory, resetState, } from '../rollback/index.js';
 import { listSkills, effectiveSystemPrompt, } from '../skills/index.js';
@@ -148,7 +149,13 @@ function renderContextBar(history) {
     const src = contextState.lastUsage ? '实测' : '估算';
     const k = (n) => `${Math.round(n / 1000)}k`;
     const pctCol = pct >= config.compactThreshold ? ui.yellow : ui.accent;
-    return `${ui.gray}[${pctCol}${bar}${ui.reset}] ${Math.round(pct * 100)}%  ${k(est)}/${k(win)} tokens · ${history.length} 条消息 (${src})${ui.reset}`;
+    const lifecycle = contextState.lifecycleStats;
+    const archived = computePruneStats(history);
+    const lifecycleLine = lifecycle
+        ? `\n  lifecycle · live ${lifecycle.live} · referenced ${lifecycle.referenced} · digested ${lifecycle.digested} · stubbed ${lifecycle.stubbed}`
+        : '\n  lifecycle · no active snapshot (run a tool-enabled turn first)';
+    const archiveLine = `\n  archived tool results · ${archived.stubbed}`;
+    return `${ui.gray}[${pctCol}${bar}${ui.reset}] ${Math.round(pct * 100)}%  ${k(est)}/${k(win)} tokens · ${history.length} 条消息 (${src})${ui.reset}${lifecycleLine}${archiveLine}`;
 }
 /** 状态行用量条(精简版,进底栏):[bar] pct% k/k。
  * 只计算对话内容(不含 system prompt),让用户感知"我发了多少、agent 回复了多少"占用 context。 */
@@ -882,6 +889,7 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             rebuildFromHistory(history);
         contextState.lastUsage = undefined;
         contextState.correction = 1;
+        contextState.lifecycleStats = undefined;
         lastTurnUsage = undefined; // 续接:旧会话的 token 累计已无意义,清空等下轮覆写
         layout.clearContent();
         renderHistory(history);
@@ -1017,6 +1025,7 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             turnCount = 0; // 反思 cadence 重新计数
             contextState.lastUsage = undefined;
             contextState.correction = 1;
+            contextState.lifecycleStats = undefined;
             lastTurnUsage = undefined; // 清空旧轮的 token 累计
             pendingAttachments = []; // 一并清空待发图片
             layout.clearContent();

package/dist/session/compact.js

@@ -320,6 +320,7 @@ export async function compactHistory(history, opts) {
             return {
                 compacted: true,
                 summarized: false,
+                historyRebuilt: true,
                 estimateBefore,
                 estimateAfter,
                 reason: microcompactDone2 ? 'microcompact' : 'summarize',
@@ -411,6 +412,7 @@ export async function compactHistory(history, opts) {
         return {
             compacted: true,
             summarized: true,
+            historyRebuilt: true,
             estimateBefore,
             estimateAfter,
             reason: 'summarize',
@@ -487,6 +489,5 @@ export async function maybeCompact(history, report, manualOpts, state = contextS
         force: manualOpts?.force,
         contextState: state,
     });
-    if (isManual)
-        return r;
+    return r;
 }

package/dist/session/scheduler.js

@@ -48,15 +48,17 @@ export function createBudgetScheduler(state = contextState) {
             const report = evaluateBudget(history, config.contextWindowTokens, step, state.correction);
             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`);
                 }
                 else if (a.kind === 'compact_history') {
-                    // 路由到 maybeCompact(history, report)——按 ROI 调度(只有 history 超 / totalOver 才真压)
-                    await maybeCompact(history, report, undefined, state);
+                    // 路由到 maybeCompact；把结构重建信号传回 core，使 lifecycle 按新 index 恢复。
+                    const result = await maybeCompact(history, report, undefined, state);
                     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)。
@@ -72,6 +74,7 @@ export function createBudgetScheduler(state = contextState) {
             obs.lastRunLog = log;
             // 暴露给 /context 共享读(repl / context 命令)
             state.schedulerLog = log;
+            return historyRebuilt;
         },
     };
     return obs;
@@ -79,7 +82,7 @@ export function createBudgetScheduler(state = contextState) {
 /** 便捷:agent/core.ts 不需要每次 createBudgetScheduler,直接 runScheduler(history, step)。 */
 export async function runScheduler(history, step, state = contextState) {
     const s = createBudgetScheduler(state);
-    await s.runStep(history, step);
+    return s.runStep(history, step);
 }
 /** 手动 /compact 入口(repl):与自动路径完全一致——五区 ROI 调度,但 history 摘要强制执行。
  *  即便 layers.history.overBudget=false 或 totalOver=false,manual 仍产 compact_history action

package/package.json

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