mocode-ai 1.6.3 → 1.6.5

package/README.zh-CN.md

@@ -25,6 +25,15 @@ mocode 自己探索代码、读写改文件、执行命令、联网查资料,以
 
 <p align="center"><img src="./assets/demo-build-pomodoro.gif" alt="mocode 从零搭建番茄钟并通过浏览器截图自检" width="100%"></p>
 
+## 效率:更快、更省 token
+
+- **两级模型面板** — 裸 `/model` 先列厂商、Enter 进入后再选模型;搜索是作用域内过滤——顶层只匹配**厂商名**,厂商内只匹配**模型名**,不再把厂商和模型混在一个结果里。
+- **思考强度 `/effort`** — `off / low / medium / high / auto` 五档归一,按目标模型自动翻译成各家方言(Anthropic / OpenAI o·gpt-5 / Qwen3 / GLM / DeepSeek-R1 / 豆包);不认识的模型或第三方网关**不下发**未知字段,避免 400。
+- **用量统计 `/stats`** — 本会话缓存命中率、分层 token 用量与压缩次数,基于后端真实上报,不靠估算。
+- **缓存安全的压缩分叉** — 能整段复用旧对话时优先走 fork,保住 prompt-cache 前缀、减少重复计费;不满足条件再回落摘要(`MOCODE_COMPACT_FORK=false` 关闭)。
+- **重复读取去重** — 同一轮对同一文件的重复读取命中缓存,不再为相同内容重复付费(`MOCODE_READ_DEDUP=false` 关闭)。
+- **子 Agent 深度闸** — 递归派生默认最多 3 层(`SUB_AGENT_MAX_DEPTH` 可调),防止子 agent 无限膨胀。
+
 ## 架构
 
 MoCode 是一个分层的自治运行时：终端交互层驱动 Agent 内核，内核通过受控能力平面执行真实操作，持久化认知层则让长任务和跨会话工作保持连贯。
@@ -109,7 +118,7 @@ mocode 不是一个套壳聊天框,而是一个能真正动手干活的 agent:
 - **会话持久化** — 每轮自动落盘,`--resume` / `/resume` 续接历史会话
 - **Skills 系统** — 自动扫描 `~/.mocode/skills/` 等目录,description 注入系统提示,模型按需调 `use_skill` 加载完整指令(渐进式披露:先看简介,任务相关才加载正文)
 - **可选桌宠** — 独立悬浮窗(`/pet`)显示一个小角色,镜像 agent 活动(空闲 / 思考 / 跑工具 / 等人工),独立进程走 WebSocket,`/pet quit` 完全关闭。挂在终端外,绝不挡终端。
-- **斜杠命令** — `/exit` `/clear` `/cd` `/context` `/skills` `/compact` `/resume` `/rollback` `/memory` `/reflect` `/init` `/theme` `/model` `/plan` `/auto` `/pet`,输入时下拉过滤
+- **斜杠命令** — `/exit` `/clear` `/cd` `/context` `/skills` `/compact` `/resume` `/rollback` `/memory` `/reflect` `/init` `/theme` `/model` `/effort` `/stats` `/plan` `/auto` `/pet`,输入时下拉过滤
 
 ## 使用文档
 
@@ -188,8 +197,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`                      |
@@ -295,7 +304,9 @@ dev_server stop   id=srv-xxxx
 | `/memory`        | 看记忆库:条目数 + 近期索引                                          |
 | `/memory_switch` | 允许/禁止 memory 自动路由并切换 Memory Index；下一真实用户轮生效    |
 | `/reflect`       | 手动触发一次后台记忆反思 pass                                       |
-| `/model`         | 配置大模型(baseURL / apiKey / model / 上下文窗口),即时生效 + 持久化 |
+| `/model`         | 两级面板切换模型(先选厂商再选模型;顶层按厂商名、厂商内按模型名过滤);也可配置 baseURL / apiKey / 上下文窗口,即时生效 + 持久化 |
+| `/effort`        | 设置思考强度 off/low/medium/high/auto(如 `/effort high`);未识别模型不下发参数 |
+| `/stats`         | 本会话用量:缓存命中率 / 分层 token / 压缩次数 |
 | `/init`          | 扫描项目生成 `AGENTS.md` 项目记忆(发给 agent 执行)                  |
 | `/theme`         | 切换颜色主题(↑↓ · Enter,或 `/theme <name>` 直切)                    |
 | `/plan`          | 切到 plan 模式(只读探查 + 产出计划,审批后切 auto 执行)              |

package/dist/agent/model-turn.js

@@ -1,5 +1,8 @@
 import { estimatePromptTokens, estimateTokens, isContextLengthError, } from '../llm/index.js';
 import { visionBatch, visionKeep } from '../config/index.js';
+import { getActiveSessionStore } from '../session/store.js';
+import { getCurrentSessionId } from '../session/state.js';
+import { toUsageRecord } from '../session/usage-stats.js';
 /**
  * 沿 cause 链(≤3 层)取第一个 errno,供 trace 取证。
  * undici 把底层 errno 挂在 cause 上(`TypeError: fetch failed` → cause `read ECONNRESET`),
@@ -18,7 +21,7 @@ function traceCauseCode(err) {
 }
 /** Executes context preparation plus exactly one model step, including the single overflow retry path. */
 export async function runModelTurn(input) {
-    const { opts, ctx, history, historyManager, runtimeContextState, scheduler, contextTrimmer, modelRunner, activeTools, runPolicy, step, cacheState, turnLifecycle, cancellationLifecycle, rebuildHistoryIndexes, } = input;
+    const { opts, ctx, history, historyManager, runtimeContextState, scheduler, contextTrimmer, modelRunner, activeTools, runPolicy, step, readDedup, cacheState, turnLifecycle, cancellationLifecycle, rebuildHistoryIndexes, } = input;
     const { signal, onContextUpdate, hooks } = opts;
     const { usageMeter, emitTrace } = turnLifecycle;
     const requestBaseURL = ctx.config.baseURL;
@@ -37,6 +40,8 @@ export async function runModelTurn(input) {
     // 视觉滑动窗口**必须剪在 trim 之前**:contextTrimmer.trim() 拿的是 historyManager.snapshot(),
     // 若先 trim,预算口径还是未剪的旧数组,80% 压力线照旧被图像撑爆(design-notes/vision-window.md §2.1)。
     // 只在这一个地方剪;下面的 overflow 重试路径读同一个 snapshot,会自动受益。
+    runtimeContextState.currentStep = step;
+    readDedup.beginStep(step);
     const visionKeepN = visionKeep();
     if (visionKeepN > 0 && historyManager.pruneVisionWindow({ keep: visionKeepN, batch: visionBatch(), step })) {
         rebuildHistoryIndexes();
@@ -52,6 +57,8 @@ export async function runModelTurn(input) {
         signal,
     });
     historyRebuilt = trimResult.kind === 'rebuild';
+    if (trimResult.kind === 'rebuild' || trimResult.kind === 'content')
+        readDedup.markContextChanged();
     const trimStats = trimResult.kind === 'aborted' ? {} : trimResult.stats;
     if (scheduler && trimStats.compactHistoryCalled) {
         emitTrace('compact', {
@@ -244,6 +251,12 @@ export async function runModelTurn(input) {
     });
     runtimeContextState.lastUsage = result.usage;
     usageMeter.add(result.usage);
+    // P1:per-step 用量落盘(失败静默,见 appendUsage)。estimatedTotal 用本次裸估算,
+    // 供 /stats 校验估算偏差。
+    const record = toUsageRecord(step, 'main', result.usage, stepPromptEst);
+    const sessionId = getCurrentSessionId();
+    if (record && sessionId)
+        getActiveSessionStore().appendUsage(sessionId, record);
     if (result.usage) {
         cacheState.lastStepPromptTokens = result.usage.promptTokens;
         if (result.usage.cachedTokens > 0)

package/dist/agent/run-coordinator.js

@@ -13,6 +13,7 @@ import { runToolTurn } from './tool-turn.js';
 import { createTurnLifecycle } from './turn-lifecycle.js';
 import { parseArgs, argumentErrorHint, isParallelTool, isParallelOrchestrationCall, isResourceLockedCall, deniedOutcome, readDiffContext, pushToolResult, } from './tool-helpers.js';
 import { contextState, summarizeToolArguments } from '../session/index.js';
+import { createReadDedup } from '../tools/read-dedup.js';
 import { createBudgetScheduler } from '../session/scheduler.js';
 import { invalidateArtifacts, rehydrateArtifacts } from '../context/index.js';
 import { createRelevancePruner } from '../context/relevance.js';
@@ -64,6 +65,8 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
     const { usageMeter, emitTrace, traceTurnId } = turnLifecycle;
     const toolTurnPlanState = { stepsSincePlanTouch: 0 };
     historyManager.appendUserTurn(userInput);
+    // P2:每用户 turn 一个重复读 scope,经 dispatcher → ToolContext 透传给 read_file。
+    const readDedup = createReadDedup();
     // The initial cancellation checkpoint is captured after the user turn and before any model/tool work.
     // Relevance and lifecycle collect provenance during normal work. Neither path
     // rewrites history; exact supersession is applied only by the pressure scheduler.
@@ -173,6 +176,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                     activeTools,
                     runPolicy,
                     step,
+                    readDedup,
                     cacheState: modelCacheState,
                     turnLifecycle,
                     cancellationLifecycle,
@@ -318,6 +322,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                     isDenied: isToolDeniedForStep,
                                     currentAllowedToolNames,
                                     delegation: delegationForOrchestrator,
+                                    readDedup,
                                     argumentErrorHint: (name) => argumentErrorHint(name, runtimeContextState),
                                     ...(opts.toolPolicy
                                         ? {
@@ -367,100 +372,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/spawn.js

@@ -10,6 +10,7 @@
 //  - 主屏渲染可选:TUI 激活时把子 agent 内部工具调用实时写入主内容区并复用 batch 折叠;
 //    TUI 未激活(host 嵌入 / 非 TTY)时纯静默,中间过程只缓冲进 transcript。
 //  - 独立 history 分支:子任务的工具噪声不回灌主对话,只有最终摘要回灌。
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { buildMocodeCorePrompt, isSubAgentHardDisabled } from '../config/index.js';
 import { getToolChatSchema } from '../tools/policy.js';
 import { effectiveSystemPrompt } from '../skills/index.js';
@@ -47,6 +48,11 @@ You are executing one delegated sub-task with the same engineering standards and
  * 中断:opts.signal 透传给子 runAgentCore——主 Ctrl+C 树杀子 agent(chat abort + 工具 abort)。
  * 子 agent 跑在主 signal 下,主 abort 即子 abort;子 agent 的 abortRestore 还原子 history + 模式。
  */
+/** 当前委派深度(P4 闸2):根 agent 无 store=0,每进一层 spawnAgent +1。 */
+const spawnDepthScope = new AsyncLocalStorage();
+function currentSpawnDepth() {
+    return spawnDepthScope.getStore() ?? 0;
+}
 export async function spawnAgent(opts) {
     const activeRuntime = opts.runtime ?? getActiveRuntime();
     const runtimeContext = opts.runtimeContext ?? activeRuntime?.context ?? getActiveAgentRuntimeContext() ?? defaultAgentRuntimeContext;
@@ -60,6 +66,20 @@ export async function spawnAgent(opts) {
             usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0, cachedTokens: 0, reasoningTokens: 0 },
         };
     }
+    // 深度闸:达上限直接结构化失败(模型看到后会改用直接工具完成)。执行层拦截,不裁 schema。
+    const depth = currentSpawnDepth() + 1;
+    if (depth > runtimeContext.config.subAgentMaxDepth) {
+        const msg = `Sub-agent depth limit ${runtimeContext.config.subAgentMaxDepth} reached ` +
+            '(nested delegation blocked to prevent fork-style recursion); complete the task directly with your own tools.';
+        return {
+            summary: msg,
+            completed: false,
+            transcript: msg,
+            status: 'failed',
+            usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0, cachedTokens: 0, reasoningTokens: 0 },
+            changedFiles: [],
+        };
+    }
     const maxSteps = opts.maxSteps ?? runtimeContext.config.subAgentMaxSteps;
     const requested = opts.tools === undefined ? null : new Set(opts.tools);
     const shared = opts.delegation && opts.delegation.history.length > 0 && opts.delegation.history[0]?.role === 'system'
@@ -172,8 +192,8 @@ export async function spawnAgent(opts) {
         const childIndex = parentId ? batch.getGroupChildIndex(opts.callId) : undefined;
         liveBatchId = batch.beginBatch(t('subagent.running'), {
             parentId,
-            // 子批摘要行缩进 = 两层 entry 缩进(随 ENTRY_INDENT 联动,不硬编码空格数)。
-            indent: parentId ? batch.SUB_BATCH_INDENT : undefined,
+            // 缩进由 beginBatch 按父层级自动推导:组容器批下 = 两层 entry 缩进;
+            // 普通子 agent 批下再嵌套 = 父缩进 + 两层(树状逐层加深)。
             groupChildIndex: childIndex,
             running: true,
         });
@@ -205,6 +225,8 @@ export async function spawnAgent(opts) {
             layout.contentWrite('\n');
     };
     let lastChar = '';
+    // P4 闸3:只收集本 agent 树自己产生的改动(钩子按真实执行触发),不靠整轮全局快照。
+    const nestedChangedFiles = new Set();
     const hooks = {
         onText: (s) => {
             writeBuf(s); // 缓冲流式正文(无 markdown 渲染,原始文本)
@@ -225,7 +247,10 @@ export async function spawnAgent(opts) {
             ensureQuietLine(opts.quietLabel ?? t('skill.executing', { name: opts.prompt.slice(0, 40) }));
             ensureLiveBatch();
             if (liveBatchId) {
-                batch.recordCall(liveBatchId, tc.name, summary);
+                // 登记内部调用的 tool_call id:子 agent 嵌套派生时,孙 spawnAgent 据此反查到
+                // 本子批,把孙批挂到对应的内部 sub-agent entry 下(而非游离到 buffer 末尾)。
+                batch.bindCall(tc.id, liveBatchId);
+                batch.recordCall(liveBatchId, tc.name, summary, tc.id);
                 // 默认折叠,只刷新摘要行计数(glob/read_file 数量),不展开明细列表。
                 batch.showLiveBatch(liveBatchId, liveLayout());
             }
@@ -237,7 +262,7 @@ export async function spawnAgent(opts) {
             if (liveBatchId) {
                 // 子 agent 批不展示 diff(其写入已直接落工作区,由主 agent 的当前回滚事务统一追踪);
                 // 空 preview 用占位标记 entry 已完成,避免折叠后摘要仍显示"运行中"。
-                batch.recordResult(liveBatchId, tc.name, preview || t('toolSummary.noOutput'), null, output, isToolErrorOutput(output));
+                batch.recordResult(liveBatchId, tc.name, preview || t('toolSummary.noOutput'), null, output, isToolErrorOutput(output), tc.id);
                 batch.showLiveBatch(liveBatchId, liveLayout());
             }
         },
@@ -286,7 +311,7 @@ export async function spawnAgent(opts) {
     // 与主 agent 完全同源:写操作直接落在工作区,进入主 agent 当前轮次的同一回滚事务
     // (spawn 不调 beginTurn)。没有 overlay 拷贝/ChangeSet 合并这一步——那是旧 read/write
     // 双模式的产物,子 agent 不再受限,也就不需要"先隔离再合并"。
-    const result = await runtime.run({
+    const runResult = () => runtime.run({
         turn: 'inherit',
         history,
         userInput,
@@ -296,11 +321,18 @@ export async function spawnAgent(opts) {
         toolsOverride,
         runtimeAllowedToolNames,
         contextState: localContextState,
+        // P4 闸3:run-coordinator 只消费顶层 onToolOutcome(非 hooks),在此收集本树真实改动。
+        onToolOutcome: (_tool, _args, outcome) => {
+            for (const f of outcome.changedFiles ?? [])
+                nestedChangedFiles.add(f);
+        },
         suppressOpeningAnalysis: true, // 子代理不注入「开场分析」:仅主线面对用户的首次响应用
         // 子代理不注入主会话「会话状态」(plan + 笔记):那是主 agent 的工作面,委派消息已带齐
         // 子任务所需上下文,重复注入只白付 token。
         suppressSessionState: true,
     });
+    // 深度 scope:子 agent 内再派生子 agent 时 ALS 读到此 depth。
+    const result = await spawnDepthScope.run(depth, runResult);
     const status = opts.signal?.aborted || result.terminationReason === 'aborted'
         ? 'aborted'
         : result.completed
@@ -318,5 +350,6 @@ export async function spawnAgent(opts) {
             cachedTokens: result.usage?.cachedTokens ?? 0,
             reasoningTokens: result.usage?.reasoningTokens ?? 0,
         },
+        changedFiles: [...nestedChangedFiles],
     };
 }

package/dist/agent/stages/model-runner.js

@@ -7,7 +7,7 @@ class ChatModelRunner {
         this.transport = transport;
     }
     run(request, signal) {
-        return this.transport(request.history.slice(), request.handlers, signal, request.tools.slice());
+        return this.transport(request.history.slice(), request.handlers, signal, request.tools.slice(), request.reasoningEffort ? { reasoningEffort: request.reasoningEffort } : undefined);
     }
 }
 class LegacyChatModelRunner extends ChatModelRunner {