mocode-ai 1.6.3 → 1.6.4

package/README.md

@@ -201,8 +201,8 @@ Common backend `base_url` values:
 | `ANYSEARCH_API_KEY`             | Web search API key (falls back to anonymous free quota if unset)                              | none                        |
 | `ANYSEARCH_BASE_URL`            | Search API endpoint                                                                           | `https://api.anysearch.com` |
 | `SKILLS_DIRS`                   | Override the default skill scan directories (platform path separator)                         | three default directories   |
-| `MOCODE_CONTEXT_OPTIMIZE`       | Opt-in typed encoding of Cold logs/searches, only under real pressure                         | `false`                     |
-| `MOCODE_CONTEXT_RELPRUNE`       | Opt-in exact superseded-evidence pruning, only under real pressure                            | `false`                     |
+| `MOCODE_CONTEXT_OPTIMIZE`       | Typed encoding of Cold logs/searches, only under real pressure (set `false` to disable)       | `true`                      |
+| `MOCODE_CONTEXT_RELPRUNE`       | Exact superseded-evidence pruning, only under real pressure (set `false` to disable)          | `true`                      |
 | `MOCODE_LIFECYCLE`              | Provenance metadata tracking; never ages or rewrites content                                  | `true`                      |
 | `MAX_STEPS`                     | Max agent loop steps per turn (infinite-loop safety only)                                     | `1000`                      |
 | `SUB_AGENT_MAX_STEPS`           | Sub-agent loop safety ceiling; defaults to the main-agent value                               | `1000`                      |

package/README.zh-CN.md

@@ -188,8 +188,8 @@ LLM_MODEL=glm-4.6                              # 换成你的模型名
 | `ANYSEARCH_API_KEY`             | 联网搜索 API key(不配走匿名免费额度)                                         | 无                          |
 | `ANYSEARCH_BASE_URL`            | 搜索 API 端点                                                                | `https://api.anysearch.com` |
 | `SKILLS_DIRS`                   | 覆盖默认 skill 扫描目录(平台分隔符)                                          | 三目录自动扫描              |
-| `MOCODE_CONTEXT_OPTIMIZE`       | 仅在真实 pressure 下编码 Cold 日志/搜索（显式开启）                          | `false`                     |
-| `MOCODE_CONTEXT_RELPRUNE`       | 仅在真实 pressure 下裁剪精确 superseded 证据（显式开启）                     | `false`                     |
+| `MOCODE_CONTEXT_OPTIMIZE`       | 仅在真实 pressure 下编码 Cold 日志/搜索（设 `false` 关闭）                          | `true`                     |
+| `MOCODE_CONTEXT_RELPRUNE`       | 仅在真实 pressure 下裁剪精确 superseded 证据（设 `false` 关闭）                     | `true`                     |
 | `MOCODE_LIFECYCLE`              | 只维护 provenance 元数据，不按次数改写正文                                   | `true`                      |
 | `MAX_STEPS`                     | 每轮 Agent 循环最大步数（仅防无限循环）                                      | `1000`                      |
 | `SUB_AGENT_MAX_STEPS`           | 子 Agent 循环安全上限，默认与主 Agent 一致                                   | `1000`                      |

package/dist/agent/run-coordinator.js

@@ -367,100 +367,140 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                         ...(tc.id ? { providerToolCallId: tc.id } : {}),
                                     });
                                 };
-                                const hasToolRouteBarrier = calls.some((tc) => tc.name === ADD_TOOL_GROUPS_TOOL_NAME);
+                                const controlIndexes = [];
+                                const otherIndexes = [];
+                                calls.forEach((tc, index) => (tc.name === ADD_TOOL_GROUPS_TOOL_NAME ? controlIndexes : otherIndexes).push(index));
+                                const hasToolRouteBarrier = controlIndexes.length > 0;
                                 if (hasToolRouteBarrier) {
-                                    const mixedCall = calls.length !== 1;
-                                    for (let index = 0; index < calls.length; index++) {
-                                        const tc = calls[index];
-                                        hooks.onToolHeader?.(tc);
-                                        const parsed = parseArgs(tc.arguments);
-                                        let outcome;
-                                        if (mixedCall) {
+                                    // 同批非控制调用全部为「未被禁用的并行安全(只读)工具」时(纯 solo 空集也满足),
+                                    // 先并发执行只读、再应用扩容;混有写/执行等非并行工具则整批保守拒绝。
+                                    const safeReadonlyBatch = otherIndexes.every((index) => isParallelTool(calls[index].name, ctx.toolRuntime) && !isToolDeniedForStep(calls[index].name));
+                                    if (safeReadonlyBatch) {
+                                        for (let index = 0; index < calls.length; index++) {
+                                            hooks.onToolHeader?.(calls[index]);
+                                        }
+                                        if (otherIndexes.length > 0) {
+                                            hooks.onToolStart?.(calls[otherIndexes[0]].name);
+                                            const startedReadonly = otherIndexes.map((index) => ctx.toolRuntime.executeToolOutcome(calls[index].name, calls[index].arguments, signal, {
+                                                callId: calls[index].id,
+                                                allowedToolNames: currentAllowedToolNames(),
+                                                delegation: delegationForOrchestrator(),
+                                            }));
+                                            for (let k = 0; k < otherIndexes.length; k++) {
+                                                const index = otherIndexes[k];
+                                                const tc = calls[index];
+                                                const outcome = await startedReadonly[k];
+                                                usageMeter.add(outcome.usage);
+                                                opts.onToolOutcome?.(tc.name, parseArgs(tc.arguments) ?? {}, outcome);
+                                                traceToolEnd(tc, index, outcome);
+                                                hooks.onToolResult?.(tc, outcome.output, null, null, 1);
+                                                pushToolResult(history, tc, outcome.output, relprune, lifecycle, scheduler, runtimeContextState, outcome.status === 'success');
+                                            }
+                                            hooks.onToolDone?.();
+                                        }
+                                        for (const index of controlIndexes) {
+                                            const tc = calls[index];
+                                            const parsed = parseArgs(tc.arguments);
+                                            let outcome;
+                                            if (isToolDeniedForStep(tc.name)) {
+                                                outcome = {
+                                                    status: 'denied',
+                                                    code: 'TOOL_DISABLED',
+                                                    retryable: false,
+                                                    output: `错误:当前 tool policy snapshot 不允许调用 ${tc.name}。`,
+                                                    changedFiles: [],
+                                                    durationMs: 0,
+                                                };
+                                            }
+                                            else if (!opts.toolPolicy) {
+                                                outcome = {
+                                                    status: 'denied',
+                                                    code: 'TOOL_DISABLED',
+                                                    retryable: false,
+                                                    output: '错误:当前 Agent 未启用动态工具策略，无法调用 add_tool_groups。',
+                                                    changedFiles: [],
+                                                    durationMs: 0,
+                                                };
+                                            }
+                                            else if (!parsed ||
+                                                !Array.isArray(parsed.groups) ||
+                                                parsed.groups.length === 0 ||
+                                                typeof parsed.reason !== 'string' ||
+                                                !parsed.reason.trim()) {
+                                                outcome = {
+                                                    status: 'error',
+                                                    code: 'INVALID_ARGUMENTS',
+                                                    retryable: false,
+                                                    output: '错误:add_tool_groups 需要非空 groups 数组和非空 reason。',
+                                                    changedFiles: [],
+                                                    durationMs: 0,
+                                                };
+                                            }
+                                            else {
+                                                const expansion = opts.toolPolicy.expand(parsed.groups, parsed.reason);
+                                                const succeeded = expansion.added.length > 0;
+                                                const details = [
+                                                    succeeded
+                                                        ? `Tool policy expanded to v${expansion.snapshot.version}; added groups: ${expansion.added.join(', ')}.`
+                                                        : `Tool policy was not expanded (still v${expansion.snapshot.version}).`,
+                                                    expansion.implied.length > 0
+                                                        ? `Implied groups also activated: ${expansion.implied.join(', ')}.`
+                                                        : '',
+                                                    expansion.rejected.length > 0 ? `Rejected: ${expansion.rejected.join('; ')}.` : '',
+                                                    succeeded ? 'The added tool schemas become available on the next model step.' : '',
+                                                ]
+                                                    .filter(Boolean)
+                                                    .join('\n');
+                                                outcome = {
+                                                    status: succeeded ? 'success' : 'error',
+                                                    code: succeeded ? 'OK' : 'INVALID_ARGUMENTS',
+                                                    retryable: false,
+                                                    output: details,
+                                                    changedFiles: [],
+                                                    durationMs: 0,
+                                                };
+                                                emitTrace('tool_route_expand', {
+                                                    policyId: expansion.snapshot.id,
+                                                    fromVersion: policySnapshot?.version,
+                                                    toVersion: expansion.snapshot.version,
+                                                    requestedGroups: parsed.groups.map(String),
+                                                    addedGroups: expansion.added,
+                                                    impliedGroups: expansion.implied,
+                                                    rejected: expansion.rejected,
+                                                    reason: parsed.reason,
+                                                    status: outcome.status,
+                                                });
+                                            }
+                                            opts.onToolOutcome?.(tc.name, parsed ?? {}, outcome);
+                                            hooks.onToolResult?.(tc, outcome.output, null, null, 1);
+                                            pushToolResult(history, tc, outcome.output, relprune, lifecycle, scheduler, runtimeContextState, outcome.status === 'success');
+                                            traceToolEnd(tc, index, outcome);
+                                        }
+                                    }
+                                    else {
+                                        // 不安全批:不扩容、不执行普通工具,逐 call 按原序配对拒绝结果。
+                                        for (let index = 0; index < calls.length; index++) {
+                                            const tc = calls[index];
+                                            hooks.onToolHeader?.(tc);
                                             const isControl = tc.name === ADD_TOOL_GROUPS_TOOL_NAME;
-                                            outcome = {
+                                            const isReadonly = isParallelTool(tc.name, ctx.toolRuntime);
+                                            const outcome = {
                                                 status: 'denied',
                                                 code: isControl ? 'INVALID_ARGUMENTS' : 'TOOL_DISABLED',
                                                 retryable: false,
                                                 output: isControl
-                                                    ? '错误:add_tool_groups 必须在一个独立的 model step 中单独调用；本次没有扩容。'
-                                                    : `错误:同一响应包含 add_tool_groups，工具 ${tc.name} 未执行。请等待扩容结果后在下一 step 重试。`,
-                                                changedFiles: [],
-                                                durationMs: 0,
-                                            };
-                                        }
-                                        else if (isToolDeniedForStep(tc.name)) {
-                                            outcome = {
-                                                status: 'denied',
-                                                code: 'TOOL_DISABLED',
-                                                retryable: false,
-                                                output: `错误:当前 tool policy snapshot 不允许调用 ${tc.name}。`,
+                                                    ? '错误:add_tool_groups 只能单独调用，或与只读工具(read_file/glob/grep/web 等)同批；本次没有扩容。'
+                                                    : isReadonly
+                                                        ? `错误:同一响应包含 add_tool_groups，工具 ${tc.name} 未执行。请在下一 step 重试。`
+                                                        : `错误:add_tool_groups 不能与写/执行工具 ${tc.name} 同批；请先完成扩容，再在下一 step 调用 ${tc.name}。`,
                                                 changedFiles: [],
                                                 durationMs: 0,
                                             };
+                                            opts.onToolOutcome?.(tc.name, parseArgs(tc.arguments) ?? {}, outcome);
+                                            hooks.onToolResult?.(tc, outcome.output, null, null, 1);
+                                            pushToolResult(history, tc, outcome.output, relprune, lifecycle, scheduler, runtimeContextState, false);
+                                            traceToolEnd(tc, index, outcome);
                                         }
-                                        else if (!opts.toolPolicy) {
-                                            outcome = {
-                                                status: 'denied',
-                                                code: 'TOOL_DISABLED',
-                                                retryable: false,
-                                                output: '错误:当前 Agent 未启用动态工具策略，无法调用 add_tool_groups。',
-                                                changedFiles: [],
-                                                durationMs: 0,
-                                            };
-                                        }
-                                        else if (!parsed ||
-                                            !Array.isArray(parsed.groups) ||
-                                            parsed.groups.length === 0 ||
-                                            typeof parsed.reason !== 'string' ||
-                                            !parsed.reason.trim()) {
-                                            outcome = {
-                                                status: 'error',
-                                                code: 'INVALID_ARGUMENTS',
-                                                retryable: false,
-                                                output: '错误:add_tool_groups 需要非空 groups 数组和非空 reason。',
-                                                changedFiles: [],
-                                                durationMs: 0,
-                                            };
-                                        }
-                                        else {
-                                            const expansion = opts.toolPolicy.expand(parsed.groups, parsed.reason);
-                                            const succeeded = expansion.added.length > 0;
-                                            const details = [
-                                                succeeded
-                                                    ? `Tool policy expanded to v${expansion.snapshot.version}; added groups: ${expansion.added.join(', ')}.`
-                                                    : `Tool policy was not expanded (still v${expansion.snapshot.version}).`,
-                                                expansion.implied.length > 0
-                                                    ? `Implied groups also activated: ${expansion.implied.join(', ')}.`
-                                                    : '',
-                                                expansion.rejected.length > 0 ? `Rejected: ${expansion.rejected.join('; ')}.` : '',
-                                                succeeded ? 'The added tool schemas become available on the next model step.' : '',
-                                            ]
-                                                .filter(Boolean)
-                                                .join('\n');
-                                            outcome = {
-                                                status: succeeded ? 'success' : 'error',
-                                                code: succeeded ? 'OK' : 'INVALID_ARGUMENTS',
-                                                retryable: false,
-                                                output: details,
-                                                changedFiles: [],
-                                                durationMs: 0,
-                                            };
-                                            emitTrace('tool_route_expand', {
-                                                policyId: expansion.snapshot.id,
-                                                fromVersion: policySnapshot?.version,
-                                                toVersion: expansion.snapshot.version,
-                                                requestedGroups: parsed.groups.map(String),
-                                                addedGroups: expansion.added,
-                                                impliedGroups: expansion.implied,
-                                                rejected: expansion.rejected,
-                                                reason: parsed.reason,
-                                                status: outcome.status,
-                                            });
-                                        }
-                                        opts.onToolOutcome?.(tc.name, parsed ?? {}, outcome);
-                                        hooks.onToolResult?.(tc, outcome.output, null, null, 1);
-                                        pushToolResult(history, tc, outcome.output, relprune, lifecycle, scheduler, runtimeContextState, outcome.status === 'success');
-                                        traceToolEnd(tc, index, outcome);
                                     }
                                 }
                                 // add_tool_groups 是 step 屏障：只要本响应出现该控制调用，本批所有普通工具都不执行。

package/dist/agent/stages/tool-dispatcher.js

@@ -76,95 +76,132 @@ class LegacyCompatibleToolDispatcher {
                 argumentSummary: argumentSummaries[index],
             });
         }
-        const hasRouteBarrier = calls.some((call) => call.name === ADD_TOOL_GROUPS_TOOL_NAME);
+        const controlIndexes = [];
+        const otherIndexes = [];
+        calls.forEach((call, index) => (call.name === ADD_TOOL_GROUPS_TOOL_NAME ? controlIndexes : otherIndexes).push(index));
+        const hasRouteBarrier = controlIndexes.length > 0;
         if (hasRouteBarrier) {
-            const mixedCall = calls.length !== 1;
-            for (let index = 0; index < calls.length; index++) {
-                const call = calls[index];
-                request.onEvent({ type: 'header', call });
-                const parsed = parseArgs(call.arguments);
-                let outcome;
-                if (mixedCall) {
+            // 同批的非控制调用全部是「未被禁用的并行安全(只读)工具」时(纯 solo 时空集也满足),
+            // 允许它们与扩容同批:先并发执行只读调用,再应用扩容。只读结果本 step 即得,新增 schema
+            // 下一 step 生效——不必为扩容空耗一轮。只要混有写/执行等非并行工具(或某只读调用已被
+            // 当前 snapshot 拒绝),即退回整批保守拒绝。
+            const safeReadonlyBatch = otherIndexes.every((index) => isParallelTool(calls[index].name, toolRuntime) && !request.isDenied(calls[index].name));
+            if (safeReadonlyBatch) {
+                // 所有 header 按调用原序先发(渲染侧据此建组容器),只读批的 header 必须先于 execute。
+                for (let index = 0; index < calls.length; index++) {
+                    request.onEvent({ type: 'header', call: calls[index] });
+                }
+                if (otherIndexes.length > 0) {
+                    request.onEvent({ type: 'start', tool: calls[otherIndexes[0]].name });
+                    const startedReadonly = otherIndexes.map((index) => execute(calls[index]));
+                    for (let offset = 0; offset < otherIndexes.length; offset++) {
+                        const index = otherIndexes[offset];
+                        const outcome = await startedReadonly[offset];
+                        record(index, outcome);
+                        executionEvents(index, parseArgs(calls[index].arguments), outcome);
+                        resultEvent(index, outcome, null);
+                    }
+                    request.onEvent({ type: 'done' });
+                }
+                // 控制调用(header 已发):逐个校验并应用扩容;solo 与同批语义一致。
+                for (const index of controlIndexes) {
+                    const call = calls[index];
+                    const parsed = parseArgs(call.arguments);
+                    let outcome;
+                    if (request.isDenied(call.name)) {
+                        outcome = {
+                            status: 'denied',
+                            code: 'TOOL_DISABLED',
+                            retryable: false,
+                            output: `错误:当前 tool policy snapshot 不允许调用 ${call.name}。`,
+                            changedFiles: [],
+                            durationMs: 0,
+                        };
+                    }
+                    else if (!request.expandToolGroups) {
+                        outcome = {
+                            status: 'denied',
+                            code: 'TOOL_DISABLED',
+                            retryable: false,
+                            output: '错误:当前 Agent 未启用动态工具策略，无法调用 add_tool_groups。',
+                            changedFiles: [],
+                            durationMs: 0,
+                        };
+                    }
+                    else if (!parsed ||
+                        !Array.isArray(parsed.groups) ||
+                        parsed.groups.length === 0 ||
+                        typeof parsed.reason !== 'string' ||
+                        !parsed.reason.trim()) {
+                        outcome = {
+                            status: 'error',
+                            code: 'INVALID_ARGUMENTS',
+                            retryable: false,
+                            output: '错误:add_tool_groups 需要非空 groups 数组和非空 reason。',
+                            changedFiles: [],
+                            durationMs: 0,
+                        };
+                    }
+                    else {
+                        const expansion = request.expandToolGroups(parsed.groups, parsed.reason);
+                        const succeeded = expansion.added.length > 0;
+                        const details = [
+                            succeeded
+                                ? `Tool policy expanded to v${expansion.snapshot.version}; added groups: ${expansion.added.join(', ')}.`
+                                : `Tool policy was not expanded (still v${expansion.snapshot.version}).`,
+                            expansion.implied.length > 0 ? `Implied groups also activated: ${expansion.implied.join(', ')}.` : '',
+                            expansion.rejected.length > 0 ? `Rejected: ${expansion.rejected.join('; ')}.` : '',
+                            succeeded ? 'The added tool schemas become available on the next model step.' : '',
+                        ]
+                            .filter(Boolean)
+                            .join('\n');
+                        outcome = {
+                            status: succeeded ? 'success' : 'error',
+                            code: succeeded ? 'OK' : 'INVALID_ARGUMENTS',
+                            retryable: false,
+                            output: details,
+                            changedFiles: [],
+                            durationMs: 0,
+                        };
+                        request.onEvent({
+                            type: 'route_expand',
+                            fromVersion: request.policy.toolPolicy?.version,
+                            expansion,
+                            requestedGroups: parsed.groups,
+                            reason: parsed.reason,
+                            status: outcome.status,
+                        });
+                    }
+                    record(index, outcome);
+                    request.onEvent({ type: 'host_outcome', call, parsed: parsed ?? {}, outcome });
+                    resultEvent(index, outcome, null);
+                    traceEnd(index, outcome);
+                }
+            }
+            else {
+                // 不安全批(混有写/执行等非并行工具):不扩容、不执行任何普通工具,逐 call 按原序配对拒绝结果。
+                for (let index = 0; index < calls.length; index++) {
+                    const call = calls[index];
+                    request.onEvent({ type: 'header', call });
                     const isControl = call.name === ADD_TOOL_GROUPS_TOOL_NAME;
-                    outcome = {
+                    const isReadonly = isParallelTool(call.name, toolRuntime);
+                    const outcome = {
                         status: 'denied',
                         code: isControl ? 'INVALID_ARGUMENTS' : 'TOOL_DISABLED',
                         retryable: false,
                         output: isControl
-                            ? '错误:add_tool_groups 必须在一个独立的 model step 中单独调用；本次没有扩容。'
-                            : `错误:同一响应包含 add_tool_groups，工具 ${call.name} 未执行。请等待扩容结果后在下一 step 重试。`,
-                        changedFiles: [],
-                        durationMs: 0,
-                    };
-                }
-                else if (request.isDenied(call.name)) {
-                    outcome = {
-                        status: 'denied',
-                        code: 'TOOL_DISABLED',
-                        retryable: false,
-                        output: `错误:当前 tool policy snapshot 不允许调用 ${call.name}。`,
+                            ? '错误:add_tool_groups 只能单独调用，或与只读工具(read_file/glob/grep/web 等)同批；本次没有扩容。'
+                            : isReadonly
+                                ? `错误:同一响应包含 add_tool_groups，工具 ${call.name} 未执行。请在下一 step 重试。`
+                                : `错误:add_tool_groups 不能与写/执行工具 ${call.name} 同批；请先完成扩容，再在下一 step 调用 ${call.name}。`,
                         changedFiles: [],
                         durationMs: 0,
                     };
+                    record(index, outcome);
+                    request.onEvent({ type: 'host_outcome', call, parsed: parseArgs(call.arguments) ?? {}, outcome });
+                    resultEvent(index, outcome, null);
+                    traceEnd(index, outcome);
                 }
-                else if (!request.expandToolGroups) {
-                    outcome = {
-                        status: 'denied',
-                        code: 'TOOL_DISABLED',
-                        retryable: false,
-                        output: '错误:当前 Agent 未启用动态工具策略，无法调用 add_tool_groups。',
-                        changedFiles: [],
-                        durationMs: 0,
-                    };
-                }
-                else if (!parsed ||
-                    !Array.isArray(parsed.groups) ||
-                    parsed.groups.length === 0 ||
-                    typeof parsed.reason !== 'string' ||
-                    !parsed.reason.trim()) {
-                    outcome = {
-                        status: 'error',
-                        code: 'INVALID_ARGUMENTS',
-                        retryable: false,
-                        output: '错误:add_tool_groups 需要非空 groups 数组和非空 reason。',
-                        changedFiles: [],
-                        durationMs: 0,
-                    };
-                }
-                else {
-                    const expansion = request.expandToolGroups(parsed.groups, parsed.reason);
-                    const succeeded = expansion.added.length > 0;
-                    const details = [
-                        succeeded
-                            ? `Tool policy expanded to v${expansion.snapshot.version}; added groups: ${expansion.added.join(', ')}.`
-                            : `Tool policy was not expanded (still v${expansion.snapshot.version}).`,
-                        expansion.implied.length > 0 ? `Implied groups also activated: ${expansion.implied.join(', ')}.` : '',
-                        expansion.rejected.length > 0 ? `Rejected: ${expansion.rejected.join('; ')}.` : '',
-                        succeeded ? 'The added tool schemas become available on the next model step.' : '',
-                    ]
-                        .filter(Boolean)
-                        .join('\n');
-                    outcome = {
-                        status: succeeded ? 'success' : 'error',
-                        code: succeeded ? 'OK' : 'INVALID_ARGUMENTS',
-                        retryable: false,
-                        output: details,
-                        changedFiles: [],
-                        durationMs: 0,
-                    };
-                    request.onEvent({
-                        type: 'route_expand',
-                        fromVersion: request.policy.toolPolicy?.version,
-                        expansion,
-                        requestedGroups: parsed.groups,
-                        reason: parsed.reason,
-                        status: outcome.status,
-                    });
-                }
-                record(index, outcome);
-                request.onEvent({ type: 'host_outcome', call, parsed: parsed ?? {}, outcome });
-                resultEvent(index, outcome, null);
-                traceEnd(index, outcome);
             }
         }
         let index = hasRouteBarrier ? calls.length : 0;

package/dist/config/index.js

@@ -497,24 +497,14 @@ ${buildVoiceSection()}
     // ToolPolicyController.reminder() 按当前 turn 的 route 注入，避免旧全局 profile 与真实 schema 分裂。
     // 按需注入(#13):有内容的索引才拼对应标题,避免空标题噪声。
     const dynamicParts = [];
-    // 会话级私有尾段(子 agent 切片会丢弃):Session state 说明无条件注入在前,Project context 按需在后。
+    // 会话级私有尾段(子 agent 切片会丢弃)。只放一句指针:plan/note 的完整规则由
+    // plan_update / note_append 的 description 承载(两工具在常驻面,调用时一定可见),
+    // 避免把规则在系统提示里每请求预付第三遍。**标题 '## Session state' 必须保留**:
+    // buildMocodeCorePrompt 靠 MARKER_DROPPABLE_SECTION 给子 agent 切片。
     dynamicParts.push(`## Session state (\`.mocode/sessions/${sessionId ?? '<id>'}/notes.md\`)\n` +
-        'Persistent working surface for tasks with 3+ steps or context-loss risk; skip it for simple work. It survives compaction.\n\n' +
-        'Record and update the execution plan with the `plan_update` tool (not by hand-editing checkboxes); it keeps at most one active plan:\n' +
-        '```\n' +
-        '## Plan: <title>\n' +
-        'Goal: <outcome>\n' +
-        '### Steps\n' +
-        '- [ ] 1. **<short label, ≤20 chars>** — <self-contained step: target file/symbol, the change, and how to verify>\n' +
-        '### Progress\n' +
-        '- <completed/total>\n' +
-        '```\n' +
-        'Each step: short `title` (≤20 chars, e.g. "编写测试" / "修 status bar", shown in the status bar) + self-contained `content` (target file/symbol, exact change, verification — readable cold, without this conversation). ' +
-        'Keep at most one step in_progress; mark a step completed as soon as its work is done, not batched to the end of the turn. ' +
-        'plan_update creates notes.md on demand and settles the plan to `## Done:` when all steps complete; run read_file on the full notes.md to recover context after compaction. ' +
-        'Keep other notes concise and session-specific; use memory for stable cross-session facts.\n' +
-        '## Session notes (resident memory)\n' +
-        'For lasting-value discoveries — subtle constraints, decisions with downstream impact, open questions, or risks — call `note_append` IMMEDIATELY when you make the discovery. Notes land in the same notes.md and are re-injected into the prompt automatically (5k-token budget), surviving compaction. Do NOT use for routine progress (that is the plan) or stable cross-session facts (that is memory_save). Each call appends one item.');
+        'For tasks with 3+ steps or context-loss risk, keep an execution plan with `plan_update`; record non-obvious findings/decisions/open questions/risks with `note_append`. ' +
+        'Both write notes.md, which survives compaction — run read_file on it to recover context after compaction. ' +
+        'Their formats and rules live in each tool\u2019s description; do not hand-edit the files.');
     // 日期段:模型需要知道今天才能判断 freshness(web 搜索、版本时效)。只随天变化,
     // 不破坏会话内前缀缓存;置于 '## Session state' 之前,子 agent 切片仍保留(无害且有用)。
     const todaySection = buildTodaySection();
@@ -592,8 +582,8 @@ export const config = {
         ? process.env.ANTHROPIC_PROMPT_CACHE !== 'false'
         : (__activePreset?.anthropicPromptCache ?? process.env.ANTHROPIC_PROMPT_CACHE !== 'false'),
     autoCompact: process.env.AUTO_COMPACT !== 'false',
-    contextOptimize: process.env.MOCODE_CONTEXT_OPTIMIZE === 'true',
-    contextRelprune: process.env.MOCODE_CONTEXT_RELPRUNE === 'true',
+    contextOptimize: process.env.MOCODE_CONTEXT_OPTIMIZE !== 'false',
+    contextRelprune: process.env.MOCODE_CONTEXT_RELPRUNE !== 'false',
     contextLifecycle: process.env.MOCODE_LIFECYCLE !== 'false',
     contextBudget: process.env.MOCODE_BUDGET_SCHEDULER !== 'false',
     autoReflect: process.env.AUTO_REFLECT === 'true',

package/dist/context/encoders/passthrough.js

@@ -1,8 +1,8 @@
 /**
  * 兜底 encoder:identity,原样返回。
  *  - classifier 未命中任何 kind(返回 'passthrough')时用。
- *  - pipeline 总开关关闭(MOCODE_CONTEXT_OPTIMIZE=false)时,所有 kind 都走它 → 行为与改造前逐字节一致。
- *  - Phase 1 阶段 registry 只注册它 → 全链路零行为变化。
+ *  - pipeline 总开关关闭(MOCODE_CONTEXT_OPTIMIZE=false)时,所有 kind 都走它 → 与不启用该阶段时的行为逐字节一致。
+ *  - 未注册任何 encoder(仅 passthrough)→ 全链路零改写。
  *  - 任何 encoder 报错时,pipeline catch 后回落到它(传原 output)。
  *
  * 永不抛错:output 可能是任意字符串(含 ANSI / 多行 / 非法 UTF-8 片段),identity 直接返回,无解析风险。

package/dist/context/pipeline.js

@@ -2,8 +2,9 @@
 //
 // Normal tool insertion does not call this module: agent/core stores the raw
 // result after only capToolResultForHistory(). The pressure scheduler invokes
-// this encoder for Cold logs and retrievable searches when the opt-in switch is
-// enabled. Encoder failures always fall back to the raw hard-capped result.
+// this encoder for Cold logs and retrievable searches; the switch defaults to
+// enabled and can be turned off via MOCODE_CONTEXT_OPTIMIZE=false. Encoder
+// failures always fall back to the raw hard-capped result.
 //
 // This does not alter tool schemas, execution, tool_call_id pairing, or TUI
 // rendering; it only provides a pressure-stage representation transform.
@@ -53,7 +54,7 @@ function budgetFor(name) {
  */
 export function optimizeToolResult(name, output, argsRaw, context = {}) {
     boot();
-    // Disabled by default: normal history is raw apart from the hard cap.
+    // Opt-out: defaults on; when disabled, normal history is raw apart from the hard cap.
     if (!config.contextOptimize) {
         return capToolResultForHistory(name, output);
     }

package/dist/context/relevance.js

@@ -3,7 +3,14 @@
 import { canonicalizePath, extractPath, isToolResultSuccess, toText } from './utils.js';
 /** Shared prefix lets /context count read and observation supersession together. */
 const STUB_PREFIX = '⌦[已过时:';
-const READ_STUB_REASON = '同 path 已有新 read / 已被 mutation 覆写';
+/** read→read:仅同 path 同区间(offset+limit)的更新 read 才淘汰旧页。 */
+const READ_RANGE_STUB_REASON = '同 path 同区间已有新 read';
+/** mutation→read:文件被改写,该 path 旧 read 全区间淘汰。 */
+const READ_MUTATION_STUB_REASON = '同 path 已被 mutation 覆写';
+/** read_file 默认分页(对齐 tools/builtins/read-file.ts 的 DEFAULT_READ_LIMIT)。 */
+const READ_DEFAULT_LIMIT = 300;
+/** read_file 单次硬上限(对齐 MAX_FILE_LINES),把超传 limit 归一化到真实拿到的区间。 */
+const READ_LIMIT_CAP = 2000;
 function parseArgs(raw) {
     try {
         const parsed = raw.trim() ? JSON.parse(raw) : {};
@@ -17,6 +24,16 @@ function normalizedInteger(value, fallback) {
     const n = Number(value);
     return Number.isFinite(n) ? Math.trunc(n) : fallback;
 }
+/** read_file 实际拿到的行区间:offset 默认 1;limit 默认 300 且钳到 2000(同工具 execute 的归一化)。
+ *  无法解析参数时返 null(调用方保守跳过,不做区间淘汰)。 */
+function readRange(argsRaw) {
+    const args = parseArgs(argsRaw);
+    if (!args)
+        return null;
+    const offset = Math.max(1, normalizedInteger(args.offset, 1));
+    const limit = Math.max(1, Math.min(normalizedInteger(args.limit, READ_DEFAULT_LIMIT), READ_LIMIT_CAP));
+    return { offset, limit };
+}
 /** Only complete semantic-query equality is safe for whole-message replacement. */
 function observationKey(call) {
     const args = call.args;
@@ -46,7 +63,11 @@ function observationLabel(call) {
 }
 /**
  * Cross-message relevance pruning:
- * - read_file: a newer successful read of the same canonical path supersedes old reads.
+ * - read_file: a newer successful read of the same canonical path AND the same
+ *   line range (offset+limit) supersedes old reads; different pages of one file
+ *   are distinct and never prune each other.
+ * - edit_file/write_file: a mutation of a path supersedes that path's old reads
+ *   across ALL ranges (the whole file changed).
  * - grep: a newer successful call with the exact same semantic arguments
  *   supersedes old results. Partial file overlap is intentionally not enough.
  */
@@ -114,8 +135,10 @@ export class RelevancePruner {
      */
     pruneSuperseded(history, coldBoundary) {
         try {
+            // read→read:键 = path + 区间(offset+limit),只淘汰真正重复的同区间旧 read。
             const latestRead = new Map();
             const latestObservation = new Map();
+            // mutation→read:按 path 记录,稍后淘汰该文件所有区间旧 read。
             const mutations = [];
             for (let idx = 1; idx < history.length; idx++) {
                 const message = history[idx];
@@ -127,8 +150,10 @@ export class RelevancePruner {
                     continue;
                 if (call.name === 'read_file') {
                     const path = canonicalizePath(extractPath(call.argsRaw));
-                    if (path)
-                        latestRead.set(path, idx);
+                    const range = readRange(call.argsRaw);
+                    // path 或区间无法确定 → 保守跳过,不做 read→read 淘汰。
+                    if (path && range)
+                        latestRead.set(`${path}|${range.offset}|${range.limit}`, { path, range, index: idx });
                 }
                 else if (call.name === 'edit_file' || call.name === 'write_file') {
                     const path = canonicalizePath(extractPath(call.argsRaw));
@@ -140,11 +165,11 @@ export class RelevancePruner {
                     latestObservation.set(key, { tool: call.name, index: idx });
             }
             let pruned = 0;
-            for (const [path, index] of latestRead) {
-                pruned += this.stubPriorReads(history, path, index, coldBoundary);
+            for (const entry of latestRead.values()) {
+                pruned += this.stubPriorReads(history, entry, coldBoundary, 'range');
             }
             for (const mutation of mutations) {
-                pruned += this.stubPriorReads(history, mutation.path, mutation.index, coldBoundary);
+                pruned += this.stubPriorReads(history, { path: mutation.path, index: mutation.index }, coldBoundary, 'mutation');
             }
             for (const [key, latest] of latestObservation) {
                 pruned += this.stubPriorObservations(history, latest.tool, key, latest.index, coldBoundary);
@@ -155,12 +180,16 @@ export class RelevancePruner {
             return 0;
         }
     }
-    stubPriorReads(history, path, beforeIdx, coldBoundary) {
-        const targetPath = canonicalizePath(path);
+    /**
+     * @param mode 'range'(read→read:仅同区间淘汰) | 'mutation'(文件被改:该 path 全区间淘汰)
+     */
+    stubPriorReads(history, target, coldBoundary, mode) {
+        const targetPath = canonicalizePath(target.path);
         if (!targetPath)
             return 0;
+        const reason = mode === 'range' ? READ_RANGE_STUB_REASON : READ_MUTATION_STUB_REASON;
         let pruned = 0;
-        for (let idx = 1; idx < Math.min(beforeIdx, coldBoundary); idx++) {
+        for (let idx = 1; idx < Math.min(target.index, coldBoundary); idx++) {
             const message = history[idx];
             if (!message || message.role !== 'tool')
                 continue;
@@ -168,12 +197,22 @@ export class RelevancePruner {
             if (content.startsWith('⌦['))
                 continue;
             const call = this.callAt(history, idx);
-            if (call?.name !== 'read_file')
+            if (call?.name !== 'read_file' || !message.tool_call_id)
                 continue;
-            if (canonicalizePath(extractPath(call.argsRaw)) !== targetPath || !message.tool_call_id)
+            if (canonicalizePath(extractPath(call.argsRaw)) !== targetPath)
                 continue;
+            // read→read 必须同区间;mutation→read 不看区间(整文件已变)。
+            if (mode === 'range') {
+                const priorRange = readRange(call.argsRaw);
+                if (!priorRange ||
+                    !target.range ||
+                    priorRange.offset !== target.range.offset ||
+                    priorRange.limit !== target.range.limit) {
+                    continue;
+                }
+            }
             message.content =
-                `${STUB_PREFIX}${READ_STUB_REASON}] read_file(${targetPath}) ${content.length} 字符 ` +
+                `${STUB_PREFIX}${reason}] read_file(${targetPath}) ${content.length} 字符 ` +
                     `→ 已被新 read / mutation 替代 · id …${message.tool_call_id.slice(-6)}⌫`;
             pruned++;
         }

package/dist/tools/builtins/edit-file.js

@@ -15,13 +15,11 @@ export const editFileTool = {
     name: 'edit_file',
     description: `Replace content in a file transactionally. Two modes:
 
-**String replacement (default):** old_string must occur EXACTLY once, copied verbatim from a fresh read_file output — never reconstruct from memory, summaries, or grep output (whitespace/indentation/line-ending details are lost there).
+**String replacement (default):** old_string must occur EXACTLY once; copy it verbatim from a fresh read_file output (see Tool policy — never reconstruct it from memory, summaries, or grep output).
 
 **Line-range:** line_start/line_end (1-based, inclusive) instead of old_string — for large blocks, repeated patterns, or hard-to-reproduce text.
 
-expected_hash (sha256 from read_file artifact header) is required and must match the current file; changed-since-read edits are rejected — re-read and retry with the new hash.
-
-Anti-patterns (will fail): old_string from memory/summary/stale call; multiple occurrences (add context to disambiguate); hash from another file or old read.`,
+expected_hash (sha256 from the read_file artifact header) is required and must match the current file; changed-since-read edits are rejected — re-read and retry with the new hash.`,
     risk: 'confirm',
     parameters: {
         type: 'object',

package/dist/tools/builtins/grep.js

@@ -59,10 +59,8 @@ function renderBodies(lines, lineNos, maxPerFile, context) {
 export const grepTool = {
     name: 'grep',
     description: 'Search file contents by regex (recursive, excludes node_modules/.git/dist).\n' +
-        'Output: per-file header "<path>: N matches, lines [l1, l2, ...]" + matched lines with ORIGINAL INDENTATION kept.\n' +
-        'Pass context=2..5 to get neighbouring lines inline (like ripgrep -C) — use it INSTEAD of following every hit with a read_file round-trip.\n' +
-        'Still use read_file(offset=X, limit=Y) for a whole region or exact edit text — never reconstruct an edit_file old_string from grep output (long lines are clipped). ' +
-        'For call chains across many files, prefer the codegraph skill.',
+        'Output: per-file header "<path>: N matches, lines [l1, l2, ...]" plus rendered lines with ORIGINAL INDENTATION kept.\n' +
+        'Pass context=2..5 to include neighbouring lines inline (like ripgrep -C) instead of following each hit with a read_file round-trip. Use read_file when you need a whole region or exact edit text.',
     parameters: {
         type: 'object',
         properties: {

package/dist/tools/builtins/read-file.js

@@ -36,11 +36,9 @@ function failure(code, message) {
 export const readFileTool = {
     name: 'read_file',
     description: 'Read a file: text with line numbers, images as visual model input.\n' +
-        'Text — read before editing. Files >500 lines: grep first, then read_file with offset+limit (e.g. offset=350, limit=120); never read a whole large file in one call. ' +
-        'Need several regions of the SAME file? Issue those read_file calls together in one response (they run concurrently) instead of sequential offset+=limit walks. ' +
+        'Text — read before editing. For files >500 lines, grep first to locate, then read_file with offset+limit (e.g. offset=350, limit=120); never read a whole large file in one call. ' +
         'Images — PNG/JPEG/GIF/WebP detected by MAGIC BYTES (extension ignored), attached as visual input; detail=low|high controls resolution, oversized PNGs downscale automatically. ' +
-        'Other binaries are REJECTED with an explanation — use run_command with a proper tool (`file`, `strings`, disassembler) if you need their content. ' +
-        'Architecture/call-chain questions: prefer the codegraph skill over reading files one at a time.',
+        'Other binaries are REJECTED with an explanation — use run_command with a proper tool (`file`, `strings`, disassembler) if you need their content.',
     parameters: {
         type: 'object',
         properties: {

package/dist/tools/policy.js

@@ -237,7 +237,7 @@ export class ToolPolicyController {
             '## Tool route (current turn)',
             `Policy ${snapshot.id} v${snapshot.version}; active groups: ${active}.`,
             `Router reason: ${snapshot.reason}`,
-            'Use only the exposed tools. Missing capability? Call add_tool_groups alone; dependent calls wait for the next step.',
+            'Use only the exposed tools. Missing capability? Call add_tool_groups — alone, or batched with read-only tools (read_file/glob/grep/web_search/web_fetch); the read-only calls run in that same step and the new groups take effect on the next step. Do not batch it with write/execute tools, and keep calls that depend on the newly added groups in the next step.',
         ];
         if (remaining.length)
             lines.push(`Groups still available: ${remaining.join(', ')}.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mocode-ai",
-  "version": "1.6.3",
+  "version": "1.6.4",
   "description": "终端编码 agent:LLM + tool-call 循环 + 流式输出(含思考)+ 25 个工具,接任意 OpenAI 兼容后端。",
   "type": "module",
   "bin": {
@@ -40,7 +40,8 @@
     "eval:smoke": "tsx evals/smoke.ts && tsx evals/coding/smoke.ts && tsx evals/quality-metrics.ts && tsx evals/work-discipline.ts",
     "eval:coding": "tsx evals/coding/runner.ts",
     "eval:coding:list": "tsx evals/coding/runner.ts --list",
-    "prepack": "npm run build"
+    "prepack": "npm run build",
+    "prepare": "node -e \"try{require('child_process').execFileSync('git',['config','core.hooksPath','.githooks'],{stdio:'ignore'})}catch(e){}\""
   },
   "dependencies": {
     "ajv": "8.20.0",