mocode-ai 0.6.3 → 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 核心循环(纯逻辑):
@@ -188,7 +188,10 @@ export async function runAgentCore(opts) {
     // 开关关闭时为 null,所有 pushToolResult / mutation 调用走无 lifecycle 路径(零行为变化)。
     // 引擎需要从已有会话 history 恢复观察结果的年龄和 path 索引；不能只追踪本次
     // runAgentCore，否则跨用户轮次的 grep/glob 永远不会衰减。
-    const lifecycle = config.contextLifecycle ? createLifecycleEngine(history) : null;
+    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
@@ -236,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';
@@ -440,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

@@ -11,7 +11,7 @@
 //
 // 观察类工具两阶段衰减(避免误伤):
 //   - grep/glob/codegraph/web_search/web_fetch 等「观察/检索类」工具两阶段衰减:
-//     Phase 1(8 步):LIVE → REFERENCED,保留完整内容(返回多个候选,剩余候选可能后续被消费)。
+//     Phase 1(10 步):LIVE → REFERENCED,保留完整内容(返回多个候选,剩余候选可能后续被消费)。
 //     Phase 2(+5 步):REFERENCED → DIGEST,替换为摘要存根(保留文件列表+命中数+参数,丢弃详情),
 //     释放 ~90% token。states 仍为 REFERENCED,不引入新状态。
 //   - 当前轮保护区(最后一个 user 之后的工具结果)完全不动。
@@ -21,14 +21,15 @@
 //
 // 与 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';
+import { canonicalizePath, extractPath, isToolResultSuccess, lastUserIndex, toText, toolNameOf, } from './utils.js';
 /** 观察类工具(LIVE → REFERENCED → DIGEST 两阶段衰减,永不自动 STUB)。 */
 const OBSERVER_TOOLS = new Set([
     'grep',
@@ -69,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:」+ 换行 + 多路径;每行一个绝对或相对路径。
@@ -87,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') {
@@ -95,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') {
@@ -138,15 +147,14 @@ export class LifecycleEngine {
             this.rehydrate(history);
     }
     /**
-     * 从会话历史恢复观察者状态。
+     * 从会话历史恢复生命周期状态。
      *
-     * LifecycleEngine 是每次 runAgentCore 新建的，但 history 是会话级的；若不回放，
-     * 跨轮的 observer 不在 states 中，后续工具调用也就无法使它老化。这里按原始
-     * pushTool 的顺序重放登记、消费关系和 age，并使用当时的 user 保护边界推进阶段。
-     * 只纳入 observer：非 observer 的短期 orphan 处理刻意保持原有「本轮」语义。
+     * 旧轮只恢复 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++) {
@@ -161,25 +169,33 @@ export class LifecycleEngine {
                 if (!toolName)
                     continue;
                 const content = toText(m.content);
+                const isObserver = OBSERVER_TOOLS.has(toolName);
                 const isDigest = content.startsWith(DIGEST_PREFIX);
-                if (OBSERVER_TOOLS.has(toolName) && !content.startsWith('⌦[')) {
+                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);
-                    for (const path of extractProducerPaths(toolName, content)) {
-                        const producers = this.producersByPath.get(path) ?? [];
-                        producers.push(idx);
-                        this.producersByPath.set(path, producers);
+                    // 只有 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 (OBSERVER_TOOLS.has(toolName) && isDigest) {
+                else if (isObserver && isDigest) {
                     this.states.set(idx, 'REFERENCED');
                     this.consumerCount.set(idx, 0);
                     this.age.set(idx, 0);
                     this.digestedIdxs.add(idx);
                 }
-                if (CONSUMER_TOOLS.has(toolName)) {
-                    const path = extractPath(this.findToolArgs(history, 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') {
@@ -224,7 +240,7 @@ export class LifecycleEngine {
     /** 新工具结果 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')
@@ -232,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('⌦['))
@@ -240,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) ?? [];
@@ -250,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;
@@ -266,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);
@@ -288,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。
@@ -304,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。
@@ -321,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);

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 共享。 */

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.3",
+  "version": "0.6.4",
   "description": "终端编码 agent:LLM + tool-call 循环 + 流式输出(含思考)+ 16 个工具,接任意 OpenAI 兼容后端。",
   "type": "module",
   "bin": {