aws-runtime-bridge 1.9.40 → 1.9.45

package/package/acode/dist/runtime.js

@@ -17,7 +17,7 @@ import { ACodeCommandRegistry } from "./commands/commandRegistry.js";
 import { calculateCompactionThreshold, COMPACTION_LLM_PROMPT_TEMPLATE, conversationSizeKB, estimateConversationTokens, performCompaction, pruneToolOutputs, summarizeConversation, } from "./compaction.js";
 import { loadAcodeConfig, loadAcodeSkillGroup } from "./config.js";
 import { ACodeHookBus, findDeniedHookResult } from "./hooks/hookBus.js";
-import { isMcpPollingToolName } from "./mcpToolNames.js";
+import { isMcpPollingToolName, getSemanticToolName } from "./mcpToolNames.js";
 function cloneChatContentPart(part) {
     if (part.type === "text") {
         return { type: "text", text: part.text };
@@ -66,13 +66,60 @@ function normalizeText(value) {
     return text || undefined;
 }
 const DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS = 60_000;
+/**
+ * 单次 provider 请求的总时长上限（毫秒）。默认 10 分钟。
+ * 超过该总预算即终止整个请求（含流式读取），不论是否仍在持续接收 chunk。
+ * 与 requestTimeoutMs（流式空闲超时 / 非流式分段超时）配合：只要每个 chunk 间隔不超过 60s，
+ * 但整体跑满 10min 仍会断开，避免长流式请求无限挂起。
+ * 0 = 不设总时长上限（仅靠 requestTimeoutMs 保护）。
+ */
+const DEFAULT_PROVIDER_REQUEST_TOTAL_TIMEOUT_MS = 10 * 60_000;
 const DEFAULT_PROVIDER_REQUEST_RETRY_COUNT = 2;
+/**
+ * 无限重试哨兵值：配置 requestRetryCount 为 -1 时，
+ * provider 请求在遇到可重试错误（超时/网络错误等）时无限重试，
+ * 直到请求成功、用户中止或会话终止。
+ * 启用后同时禁用总时长上限（requestTotalTimeoutMs 无效），
+ * 仅依靠单次请求超时（requestTimeoutMs）保护。
+ */
+const INFINITE_RETRY_SENTINEL = -1;
 const DEFAULT_PROVIDER_REQUEST_RETRY_DELAY_MS = 1000;
 const DEFAULT_MCP_TOOL_CALL_TIMEOUT_MS = 60_000;
 const DEFAULT_MCP_POLLING_TOOL_CALL_TIMEOUT_MS = 0;
 const MCP_SDK_MAX_SAFE_TIMEOUT_MS = 2_147_483_647;
+/**
+ * 子 agent 通过共享 MCP 连接允许调用的工具白名单。
+ * 与 aws-client-agent-mcp 的 MEMORY_TOOL_NAMES 保持一致，
+ * 防止子 agent 调用 poll_message/send_group 等与父 agent 冲突的工具。
+ */
+const SUB_AGENT_ALLOWED_MCP_TOOLS = new Set([
+    "create_memory",
+    "read_memory",
+    "update_memory",
+    "delete_memory",
+    "search_memory",
+    "list_memories",
+    "get_memory_stats",
+    "list_memories_by_file",
+    // Memory 过期回忆工具：memory_expiration 委托子 agent 需调用以整理过期记忆
+    "memory_recurrence",
+    "memory_recurrence_complete",
+]);
 const DEFAULT_BASH_BUILT_IN_TOOL_TIMEOUT_MS = 10 * 60_000 + 2000;
 const DEFAULT_RUNTIME_SHUTDOWN_TIMEOUT_MS = 10_000;
+/**
+ * 当 poll_message 返回的全部消息被 memory 自动委托处理后，重新 poll 前的等待间隔。
+ * 防止紧密循环：MCP doPollMessage 对 updating memory 每次都返回通知，
+ * 而 processMemoryAutoDelegates 因 URI 已在处理中而返回 null，
+ * 导致 while(true) 无延迟重 poll，引发状态快速跳动（思考→MCP→跳过）最终连接丢失。
+ */
+const DELEGATE_REPOLL_DELAY_MS = 5_000;
+/**
+ * 子 agent 完成（completed/failed/cancelled）后，对应 memory URI 的委托冷却窗口。
+ * 在此期间即使 memory 仍处 updating / 过期 / 容量超限，运行层也不会再次 spawn 子任务，
+ * 仅保留巡检。用于切断「委托完成（但 memory 未真正处理）→ 下一轮 poll 又 spawn 相同子任务」的循环。
+ */
+const MEMORY_DELEGATE_COOLDOWN_MS = 10 * 60 * 1000;
 const MAX_INLINE_IMAGE_BYTES = 10 * 1024 * 1024;
 const MAX_REQUEST_BODY_BYTES = 800 * 1024;
 /**
@@ -95,6 +142,24 @@ function runtimeDebugLog(...args) {
 }
 /** 当 provider 未配置 contextLimit 时使用的默认值 */
 const FALLBACK_CONTEXT_LIMIT = 64_000;
+/**
+ * 解析 provider 的压缩配置，返回实际用于触发压缩的 contextLimit/maxOutput/inputLimit/threshold。
+ * 供 session_started 事件、startCompactionDebugLog、requestChatCompletion 共用，
+ * 确保前端显示的压缩点与后端实际触发阈值完全一致（消除前端自算公式的脱节）。
+ */
+function resolveCompactionConfig(provider) {
+    const contextLimit = (provider.contextLimit && provider.contextLimit > 0)
+        ? provider.contextLimit
+        : FALLBACK_CONTEXT_LIMIT;
+    const maxOutput = (provider.maxOutput && provider.maxOutput > 0)
+        ? provider.maxOutput
+        : 8_192;
+    const inputLimit = (provider.inputLimit && provider.inputLimit > 0)
+        ? provider.inputLimit
+        : undefined;
+    const threshold = calculateCompactionThreshold(contextLimit, maxOutput, inputLimit);
+    return { contextLimit, maxOutput, inputLimit, threshold };
+}
 async function withTimeout(operation, timeoutMs, label, onTimeout) {
     if (timeoutMs <= 0) {
         return await operation;
@@ -128,6 +193,10 @@ function normalizeNonNegativeInteger(value, fallback) {
         return 0;
     }
     const numeric = typeof value === "number" ? value : Number(value);
+    // -1 是无限重试哨兵值，直接透传
+    if (numeric === INFINITE_RETRY_SENTINEL) {
+        return INFINITE_RETRY_SENTINEL;
+    }
     return Number.isFinite(numeric) && numeric > 0
         ? Math.floor(numeric)
         : fallback;
@@ -169,6 +238,18 @@ function estimateContextTokens(systemPrompt, exposedTools) {
     }
     return Math.ceil(charCount / ESTIMATED_CHARS_PER_TOKEN);
 }
+/**
+ * 估算 exposedTools 定义的 token 开销。
+ * tools 的 JSON schema（函数名、描述、参数定义）会被序列化进请求体，
+ * 占用可观 token 数（十几个工具可达数千 tokens），必须计入上下文估算。
+ * 否则 estimateConversationTokens 系统性偏低，导致主动压缩阈值无法触达。
+ */
+function estimateToolsTokens(exposedTools) {
+    if (exposedTools.length === 0)
+        return 0;
+    const toolsJson = JSON.stringify(toOpenAiTools(exposedTools));
+    return estimateTokensFromText(toolsJson);
+}
 async function delay(ms) {
     await new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -196,6 +277,36 @@ function modelSupportsImageInput(model, defaultProvider, providerOptions) {
  * 解析 ACode 当前会话模型：优先显式启动参数，其次兼容 cc-switch 写入的
  * OpenCode-style `provider.default.model`，最后回落到旧版 top-level model。
  */
+/**
+ * 按优先级从 provider 配置中查找字段值：
+ *   1. options.*（通用配置）
+ *   2. models.<currentModel>.*（当前模型专属配置，面板初始化写入的位置）
+ *   3. provider.*（provider 级别兜底）
+ *
+ * @param optionsValue  providerOptions 上的值（已取出）
+ * @param defaultProvider  provider.default 对象
+ * @param currentModel  当前使用的模型名
+ * @param fieldName     要查找的字段名（如 "contextLimit"）
+ */
+function resolveProviderConfigValue(optionsValue, defaultProvider, currentModel, fieldName) {
+    // 1. options 级别优先
+    if (optionsValue !== undefined)
+        return optionsValue;
+    if (!defaultProvider)
+        return undefined;
+    // 2. models.<modelName>.<fieldName>
+    const models = defaultProvider.models;
+    if (isRecord(models)) {
+        const modelConfig = models[currentModel];
+        if (isRecord(modelConfig)) {
+            const modelValue = modelConfig[fieldName];
+            if (modelValue !== undefined)
+                return modelValue;
+        }
+    }
+    // 3. provider 级别兜底
+    return defaultProvider[fieldName];
+}
 function resolveProviderConfig(config, acodeConfig) {
     const defaultProvider = acodeConfig.provider?.default;
     const providerOptions = defaultProvider?.options;
@@ -203,17 +314,36 @@ function resolveProviderConfig(config, acodeConfig) {
         defaultProvider?.model ||
         acodeConfig.model ||
         "acode-default";
+    // effort 优先级：runtime config (per-session/per-instance) > provider options (acode.json) > provider default
+    const effort = normalizeText(config.effort) ||
+        normalizeText(providerOptions?.effort) ||
+        normalizeText(defaultProvider?.effort) ||
+        undefined;
     return {
         model,
         baseURL: normalizeText(providerOptions?.baseURL || providerOptions?.baseUrl),
         apiKey: normalizeText(providerOptions?.apiKey),
+        effort,
         systemPrompt: config.systemPrompt || acodeConfig.systemPrompt,
         stream: providerOptions?.stream !== false,
-        requestTimeoutMs: normalizeNonNegativeInteger(providerOptions?.requestTimeoutMs ?? providerOptions?.timeoutMs, DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS),
+        // ★ 安全修复：使用 normalizePositiveInteger 禁止设为 0，
+        //   0 会导致 withTimeout 直接返回 operation（禁用超时），
+        //   fetch 挂起时请求永久不返回，agent 死锁。
+        requestTimeoutMs: normalizePositiveInteger(providerOptions?.requestTimeoutMs ?? providerOptions?.timeoutMs, DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS),
+        requestTotalTimeoutMs: normalizePositiveInteger(providerOptions?.requestTotalTimeoutMs, DEFAULT_PROVIDER_REQUEST_TOTAL_TIMEOUT_MS),
         requestRetryCount: normalizeNonNegativeInteger(providerOptions?.requestRetryCount, DEFAULT_PROVIDER_REQUEST_RETRY_COUNT),
         mcpToolTimeoutMs: normalizePositiveInteger(providerOptions?.mcpToolTimeoutMs, DEFAULT_MCP_TOOL_CALL_TIMEOUT_MS),
         mcpPollingToolTimeoutMs: normalizeNonNegativeInteger(providerOptions?.mcpPollingToolTimeoutMs, DEFAULT_MCP_POLLING_TOOL_CALL_TIMEOUT_MS),
         supportsImageInput: modelSupportsImageInput(model, defaultProvider, providerOptions),
+        // ★ 从 provider 配置中读取 contextLimit/inputLimit/maxOutput，
+        //    requestChatCompletion 和 startCompactionDebugLog 使用这些值计算压缩触发阈值。
+        //    按优先级查找三个位置：
+        //      1. provider.default.options.*（options 级别，通用配置）
+        //      2. provider.default.models.<modelName>.*（模型级别，面板初始化写入的位置）
+        //      3. provider.default.*（provider 级别兜底）
+        contextLimit: normalizeNonNegativeInteger(resolveProviderConfigValue(providerOptions?.contextLimit, defaultProvider, model, "contextLimit"), 0) || undefined,
+        inputLimit: normalizeNonNegativeInteger(resolveProviderConfigValue(providerOptions?.inputLimit, defaultProvider, model, "inputLimit"), 0) || undefined,
+        maxOutput: normalizeNonNegativeInteger(resolveProviderConfigValue(providerOptions?.maxOutput, defaultProvider, model, "maxOutput"), 0) || undefined,
     };
 }
 function appendTextPart(parts, text) {
@@ -522,8 +652,14 @@ function coerceArguments(rawArguments) {
     }
 }
 function getBuiltInToolTimeoutMs(tool, args, fallbackTimeoutMs) {
-    // ask_user_question 工具阻塞等待用户回答，不受超时限制
-    if (tool.toolName === ASK_USER_QUESTION_TOOL_NAME) {
+    // 阻塞等待型工具不受超时限制：
+    // - ask_user_question: 阻塞等待用户回答
+    // - await_sub_agents: 永久阻塞等待指定子 agent 数组到达终态
+    const BLOCKING_BUILT_IN_TOOL_NAMES = new Set([
+        ASK_USER_QUESTION_TOOL_NAME,
+        "await_sub_agents",
+    ]);
+    if (BLOCKING_BUILT_IN_TOOL_NAMES.has(tool.toolName)) {
         return 0;
     }
     if (tool.toolName !== "Bash") {
@@ -848,6 +984,7 @@ export class ACodeRuntime extends EventEmitter {
                 model: "acode-default",
                 stream: false,
                 requestTimeoutMs: DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS,
+                requestTotalTimeoutMs: DEFAULT_PROVIDER_REQUEST_TOTAL_TIMEOUT_MS,
                 requestRetryCount: DEFAULT_PROVIDER_REQUEST_RETRY_COUNT,
                 mcpToolTimeoutMs: DEFAULT_MCP_TOOL_CALL_TIMEOUT_MS,
                 mcpPollingToolTimeoutMs: DEFAULT_MCP_POLLING_TOOL_CALL_TIMEOUT_MS,
@@ -855,6 +992,7 @@ export class ACodeRuntime extends EventEmitter {
             },
             permissions: { mode: "default", allow: [], deny: [] },
             mcpConnections: [],
+            ownsMcpConnections: true,
             exposedTools: [],
             commands: [],
             commandRegistry: new ACodeCommandRegistry([]),
@@ -863,6 +1001,20 @@ export class ACodeRuntime extends EventEmitter {
             accumulatedOutputTokens: 0,
         };
         this.abortController = null;
+        /**
+         * 正在处理中的 memory 子 agent 跟踪表。
+         * key = memory URI，value = subId（用于防止同一 memory 被重复委托）。
+         * 子 agent 完成后通过 SubAgentManager 事件回调移除对应 URI。
+         */
+        this.pendingMemorySubAgents = new Map();
+        /**
+         * memory 委托冷却表（「已解决/已处理」守卫，区别于 pendingMemorySubAgents 的「进行中」守卫）。
+         * key = memory URI，value = 冷却到期时间戳（ms）。
+         * 子 agent 进入终态时写入；冷却期内即使 memory 仍待处理也不再 spawn 新子任务。
+         * 这是切断「委托完成→复发」循环的关键：原实现只有进行中守卫，子 agent 一结束 URI 立即释放，
+         * 导致下一轮 poll 对 sticky 的 updating memory 再次委托。
+         */
+        this.memoryDelegateCooldownUntil = new Map();
         this.submitQueue = Promise.resolve();
         this.activeTurn = false;
         this.abortRequested = false;
@@ -895,6 +1047,10 @@ export class ACodeRuntime extends EventEmitter {
             this.hookBus.register(handler);
         }
     }
+    /** 获取当前已暴露的工具名称列表（供 SubAgentManager 记录） */
+    getAvailableTools() {
+        return this.state.exposedTools.map((tool) => tool.exposedName);
+    }
     emitAcodeEvent(type, data) {
         const event = {
             type,
@@ -962,7 +1118,13 @@ export class ACodeRuntime extends EventEmitter {
             `resolvedModel=${provider.model}, baseURL=${provider.baseURL ?? "(none)"}, apiKey=${provider.apiKey ? "[set]" : "(none)"}, ` +
             `configPath=${this.config.configPath ?? "(none)"}`);
         const permissions = resolvePermissionConfig(this.config, acodeConfig);
-        const mcpConnections = await this.connectMcpServers(acodeConfig.mcpServers ?? {}, provider.mcpToolTimeoutMs);
+        // 子 agent 复用父 agent 的 MCP 连接，避免启动新 MCP server 进程后 401
+        // 共享连接时只暴露 memory 工具，防止子 agent 调用 poll_message/send_group 等
+        // 与父 agent 冲突的工具（原设计通过 AWS_SUB_AGENT=true 限制，共享连接绕过了该机制）
+        const mcpConnections = this.config.sharedMcpConnections
+            ? this.filterSharedMcpConnectionsForSubAgent(this.config.sharedMcpConnections)
+            : await this.connectMcpServers(acodeConfig.mcpServers ?? {}, provider.mcpToolTimeoutMs);
+        const ownsMcpConnections = !this.config.sharedMcpConnections;
         // 获取用户 profile 信息并拼接在 rolePrompt 下方
         const profilePrompt = await this.fetchProfilePrompt(mcpConnections);
         const agentId = this.config.agentId || "unknown";
@@ -1027,6 +1189,7 @@ export class ACodeRuntime extends EventEmitter {
             provider,
             permissions,
             mcpConnections,
+            ownsMcpConnections,
             exposedTools,
             commands,
             commandRegistry,
@@ -1039,11 +1202,22 @@ export class ACodeRuntime extends EventEmitter {
             model: provider.model,
             commandCount: commands.length,
         });
+        // ★ emit 实际用于触发压缩的配置，前端 AgentContextPanel 直接显示此阈值，
+        //   消除前端自算公式与后端实际触发阈值（min(动态比例, hardLimit-reserved)）的脱节。
+        //   注意：此处的 contextLimit/maxOutput/inputLimit 来自 resolveProviderConfig（读 provider.default.* 三级），
+        //   与 adapter 的 totalUsage.contextLimit（读顶层+查表）可能不同源——前端应以这里 emit 的值为准。
+        const compactionConfig = resolveCompactionConfig(provider);
         this.emitAcodeEvent("session_started", {
             workingDirectory: this.config.workingDirectory,
             model: provider.model,
             commandCount: commands.length,
             estimatedContextTokens: estimateContextTokens(systemMessagesPlainText, exposedTools),
+            contextLimit: compactionConfig.contextLimit,
+            maxOutput: compactionConfig.maxOutput,
+            ...(compactionConfig.inputLimit !== undefined
+                ? { inputLimit: compactionConfig.inputLimit }
+                : {}),
+            compactionThreshold: compactionConfig.threshold,
         });
         this.emitAcodeEvent("mcp_status", {
             configPath: this.config.configPath,
@@ -1266,20 +1440,12 @@ export class ACodeRuntime extends EventEmitter {
         if (this.compactionDebugTimer)
             return;
         const provider = this.state.provider;
-        const contextLimit = (provider.contextLimit && provider.contextLimit > 0)
-            ? provider.contextLimit
-            : FALLBACK_CONTEXT_LIMIT;
-        const maxOutput = (provider.maxOutput && provider.maxOutput > 0)
-            ? provider.maxOutput
-            : 8_192;
-        const inputLimit = (provider.inputLimit && provider.inputLimit > 0)
-            ? provider.inputLimit
-            : undefined;
-        const triggerThreshold = calculateCompactionThreshold(contextLimit, maxOutput, inputLimit);
+        const { contextLimit, maxOutput, inputLimit, threshold: triggerThreshold } = resolveCompactionConfig(provider);
         this.compactionDebugTimer = setInterval(() => {
             try {
                 const actualUsed = this.state.accumulatedInputTokens + this.state.accumulatedOutputTokens;
-                const estimatedUsed = estimateConversationTokens(this.state.conversation);
+                const estimatedUsed = estimateConversationTokens(this.state.conversation)
+                    + estimateToolsTokens(this.state.exposedTools);
                 const effectiveUsed = Math.max(actualUsed, estimatedUsed);
                 const sizeKB = conversationSizeKB(this.state.conversation);
                 const isRunning = this.state.started && !this.state.terminated;
@@ -1329,8 +1495,17 @@ export class ACodeRuntime extends EventEmitter {
      */
     async submit(message) {
         const contextVersion = this.contextVersion;
-        const queued = this.submitQueue.then(() => this.executeSubmit(message, contextVersion));
-        this.submitQueue = queued.catch(() => undefined);
+        runtimeDebugLog(`[ACodeRuntime] 📬 submit() queued: contextVersion=${contextVersion}, ` +
+            `activeTurn=${this.activeTurn}, abortRequested=${this.abortRequested}, ` +
+            `terminated=${this.state.terminated}, message.length=${message.length}`);
+        const queued = this.submitQueue.then(() => {
+            runtimeDebugLog(`[ACodeRuntime] ▶️ executeSubmit dequeued: contextVersion=${contextVersion}`);
+            return this.executeSubmit(message, contextVersion);
+        });
+        this.submitQueue = queued.catch(() => {
+            runtimeDebugLog(`[ACodeRuntime] 📬 submit() queued item rejected (catch swallowed)`);
+        });
+        runtimeDebugLog(`[ACodeRuntime] 📬 submit() returning queued promise`);
         return queued;
     }
     /**
@@ -1456,7 +1631,7 @@ export class ACodeRuntime extends EventEmitter {
             });
             // ★ token 用量已在 runModelTurn 中按迭代更新到 state（非累加），
             //    此处不再累加，避免 actualUsed 跨轮只增不减导致 shouldCompact 永远为 true。
-            //    finalUsage 仍用于 turn_complete 事件的 usage 上报（多轮迭代的总和）。
+            //    finalUsage 用于 turn_complete 事件的 usage 上报（当前迭代的上下文用量，覆盖式）。
             runtimeDebugLog(`[ACodeRuntime] 💰 Current context usage: ` +
                 `input=${this.state.accumulatedInputTokens}, ` +
                 `output=${this.state.accumulatedOutputTokens}` +
@@ -1492,15 +1667,17 @@ export class ACodeRuntime extends EventEmitter {
             const finallyDuration = Date.now() - turnStartTime;
             runtimeDebugLog(`[ACodeRuntime] 🔚 executeSubmit finally block entered after ${finallyDuration}ms`);
             runtimeDebugLog(`[ACodeRuntime] 🔍 turnCompleted=${turnCompleted}, activeTurn=${this.activeTurn}, ` +
-                `abortRequested=${this.abortRequested}`);
+                `abortRequested=${this.abortRequested}, contextVersion=${contextVersion}, ` +
+                `currentContextVersion=${this.contextVersion}`);
             this.activeTurn = false;
             this.abortRequested = false;
             // 关键修复：如果异常路径没有发射 turn_complete，强制发射一个
             // 这确保 adapter 层的 recoverResolvedTurnWithoutTerminalEvent 能够正确触发
             if (!turnCompleted && !this.isTurnSuperseded(contextVersion)) {
-                console.error(`[ACodeRuntime] 🚨 CRITICAL: executeSubmit finally block reached without turn_complete event!`);
-                console.error(`[ACodeRuntime] 🚨 This indicates a code path that should have emitted turn_complete but didn't.`);
-                console.error(`[ACodeRuntime]  Forcing failed turn_complete to prevent state stuck.`);
+                console.error(`[ACodeRuntime] 🚨 CRITICAL: executeSubmit finally block reached without turn_complete event! ` +
+                    `Duration: ${finallyDuration}ms. ` +
+                    `This indicates a code path that should have emitted turn_complete but didn't. ` +
+                    `Forcing failed turn_complete to prevent state stuck.`);
                 this.emitAcodeEvent("error", {
                     message: "ACode turn completed without proper completion event (internal error)",
                 });
@@ -1511,8 +1688,19 @@ export class ACodeRuntime extends EventEmitter {
     }
     /** 中止当前轮次；由执行轮次统一发出一个终态事件，避免 aborted/failed 双终态。 */
     async abort() {
+        const hadController = this.abortController !== null;
+        const wasActiveTurn = this.activeTurn;
         this.abortRequested = this.activeTurn;
-        this.abortController?.abort();
+        if (this.abortController) {
+            runtimeDebugLog(`[ACodeRuntime] ⛔ abort() calling abortController.abort() (activeTurn=${wasActiveTurn})`);
+            this.abortController.abort();
+        }
+        else {
+            console.warn(`[ACodeRuntime] ⛔ abort() called but abortController is null! ` +
+                `activeTurn=${wasActiveTurn}, abortRequested will be set to ${wasActiveTurn}. ` +
+                `This means abort() CANNOT cancel any running fetch/stream — ` +
+                `if a built-in tool is executing, it will NOT be interrupted.`);
+        }
         this.abortController = null;
         // ask_user_question 等待用户回答期间被 abort，需 reject 所有 waiter
         this.rejectAllQuestionWaiters("aborted");
@@ -1566,7 +1754,12 @@ export class ACodeRuntime extends EventEmitter {
                     description: opts.description,
                     prompt: opts.prompt,
                     workingDirectory,
-                    parentConfig,
+                    parentConfig: {
+                        ...parentConfig,
+                        // 注入父 agent 的 MCP 连接，子 agent 复用而非启动新 MCP server 进程
+                        // 避免 launch binding 已被父 agent 消费后子 agent 401
+                        sharedMcpConnections: this.state?.mcpConnections,
+                    },
                 });
                 // 自动 start（非阻塞，立即返回）
                 await manager.start(subId);
@@ -1753,16 +1946,16 @@ export class ACodeRuntime extends EventEmitter {
                 const rtOutputTokens = response.usage.completion_tokens ?? response.usage.output_tokens;
                 if (typeof rtInputTokens === "number" &&
                     typeof rtOutputTokens === "number") {
-                    if (finalUsage) {
-                        finalUsage.inputTokens += rtInputTokens;
-                        finalUsage.outputTokens += rtOutputTokens;
-                    }
-                    else {
-                        finalUsage = {
-                            inputTokens: rtInputTokens,
-                            outputTokens: rtOutputTokens,
-                        };
-                    }
+                    // ★ finalUsage 记录当前迭代的实际 token 用量（覆盖式，非累加）。
+                    //    prompt_tokens 代表本次请求时 provider 看到的完整上下文大小，
+                    //    若跨迭代累加会得到 N × 上下文大小 的无意义总和，导致 turn_complete
+                    //    上报的 usage 远超真实上下文，前端"上下文"标签会瞬间跳到几 M 再跳回。
+                    //    改为覆盖式，与 state.accumulatedInputTokens 及 AcodeSdkAdapter 的
+                    //    "当前上下文"语义保持一致。
+                    finalUsage = {
+                        inputTokens: rtInputTokens,
+                        outputTokens: rtOutputTokens,
+                    };
                     accumulatedPromptTokens += rtInputTokens;
                     // ★ 更新 state 为当前迭代的实际 token 用量（非累加）
                     //    prompt_tokens 代表本次请求时 provider 看到的完整上下文大小，
@@ -1771,7 +1964,7 @@ export class ACodeRuntime extends EventEmitter {
                     this.state.accumulatedInputTokens = rtInputTokens;
                     this.state.accumulatedOutputTokens = rtOutputTokens;
                     runtimeDebugLog(`[ACodeRuntime] 💰 Token usage: input=${rtInputTokens}, output=${rtOutputTokens} ` +
-                        `(turn accumulated: input=${accumulatedPromptTokens}, output=${finalUsage.outputTokens})`);
+                        `(turn accumulated cost: input=${accumulatedPromptTokens})`);
                 }
             }
             this.state.conversation.push({
@@ -1881,7 +2074,14 @@ export class ACodeRuntime extends EventEmitter {
             abortController.abort();
         });
         if (!response.ok) {
-            throw new Error(`ACode LLM summarization request failed: ${response.status} ${await response.text()}`);
+            // ★ 防御修复：用 withTimeout 包裹 response.text()，防止错误响应 body stream 挂起
+            const errorBody = await withTimeout(response.text(), provider.requestTimeoutMs, "ACode LLM summarization error response body", () => {
+                abortController.abort();
+            });
+            const truncatedBody = errorBody.length > 500
+                ? `${errorBody.slice(0, 500)}...(truncated, total ${errorBody.length} chars)`
+                : errorBody;
+            throw new Error(`ACode LLM summarization request failed: ${response.status} ${truncatedBody}`);
         }
         const payload = (await response.json());
         const content = payload.choices?.[0]?.message?.content;
@@ -1896,28 +2096,17 @@ export class ACodeRuntime extends EventEmitter {
         if (!baseURL) {
             throw new Error("ACode provider baseURL is not configured");
         }
-        // 主动上下文压缩：在发送 AI 请求前检测 token 是否溢出
-        // 使用 provider 配置中的 contextLimit/inputLimit/maxOutput（来自模板配置）。
-        // 不依赖 MODEL_CONTEXT_LIMITS 硬编码查找表，若未配置则使用 FALLBACK_CONTEXT_LIMIT（64K）。
-        const contextLimit = (provider.contextLimit && provider.contextLimit > 0)
-            ? provider.contextLimit
-            : FALLBACK_CONTEXT_LIMIT;
-        const maxOutput = (provider.maxOutput && provider.maxOutput > 0)
-            ? provider.maxOutput
-            : 8_192;
-        // ★ 融合 OpenCode 预算思路：优先用 inputLimit（部分 Provider input+output 总额 ≠ context 上限）
-        //   未配置 inputLimit 时降级到 contextLimit，行为与改进前一致。
-        const inputLimit = (provider.inputLimit && provider.inputLimit > 0)
-            ? provider.inputLimit
-            : undefined;
-        // ★ 阈值 = min(contextLimit × 55%, hardLimit - reserved)
-        //   hardLimit = inputLimit ?? contextLimit
-        //   reserved = min(COMPACTION_BUFFER, maxOutput)  // buffer 不超过输出上限
-        const compactionThreshold = calculateCompactionThreshold(contextLimit, maxOutput, inputLimit);
+        // 主动上下文压缩：在发送 AI 请求前检测 token 是否溢出。
+        // ★ 与 session_started 事件 emit 的阈值同源（resolveCompactionConfig），保证前端显示 = 实际触发。
+        const { contextLimit, maxOutput, inputLimit, threshold: compactionThreshold } = resolveCompactionConfig(provider);
         // 使用 effectiveUsed = max(actualUsed, estimatedUsed)
         // 因为部分 provider 不返回 usage 数据（actualUsed=0），此时降级到文本估算
         const actualUsed = this.state.accumulatedInputTokens + this.state.accumulatedOutputTokens;
-        const estimatedUsed = estimateConversationTokens(this.state.conversation);
+        // ★ 估算时加入 tools 定义开销，使估算更接近实际请求 token 数。
+        //   之前只估算 conversation 消息，遗漏了 tools 的 JSON schema（可达数千 tokens），
+        //   导致估算系统性偏低、主动压缩阈值无法触达。
+        const estimatedUsed = estimateConversationTokens(this.state.conversation)
+            + estimateToolsTokens(this.state.exposedTools);
         const effectiveUsed = Math.max(actualUsed, estimatedUsed);
         const shouldCompact = effectiveUsed >= compactionThreshold;
         runtimeDebugLog(`[ACodeRuntime] 🔍 Compaction check: ` +
@@ -1944,6 +2133,9 @@ export class ACodeRuntime extends EventEmitter {
             const result = await performCompaction(this.state.conversation, contextLimit, maxOutput, {
                 llmSummarizer: (input) => this.summarizeConversationWithLLM(input),
                 onPhase: (phaseEvent) => this.handleCompactionPhase(compactionId, phaseEvent),
+                // 传入 effectiveUsed 修复文本估算低于实际 token 数时
+                // post-prune isOverflow 误判导致 summarize 被跳过的问题
+                actualUsedTokens: effectiveUsed,
             });
             const sizeAfterKB = conversationSizeKB(this.state.conversation);
             this.emitAcodeEvent("context_compaction", {
@@ -1954,6 +2146,8 @@ export class ACodeRuntime extends EventEmitter {
                 freedKB: Math.round((sizeBeforeKB - sizeAfterKB) * 10) / 10,
                 strategy: result.strategy,
                 freedTokens: result.freedTokens,
+                tokensBefore: result.tokensBefore,
+                tokensAfter: result.tokensAfter,
                 prunedToolMessages: result.prunedToolMessages,
                 summarizedMessages: result.summarizedMessages,
                 messageCountBefore: result.messageCountBefore,
@@ -1981,6 +2175,16 @@ export class ACodeRuntime extends EventEmitter {
                 messages: this.state.conversation,
                 stream: provider.stream,
             };
+            // ★ 思考强度：写入 reasoning_effort 字段，兼容 OpenAI o-series 及兼容 API。
+            //   未配置 effort 时不写入，由 provider 使用默认值。
+            if (provider.effort) {
+                body.reasoning_effort = provider.effort;
+            }
+            // ★ 流式请求必须设置 stream_options.include_usage，否则 provider 不返回 usage，
+            //   导致 accumulatedInputTokens 永远为 0，主动压缩无法基于实际用量触发。
+            if (provider.stream) {
+                body.stream_options = { include_usage: true };
+            }
             if (allowedTools.length > 0) {
                 body.tools = toOpenAiTools(allowedTools);
                 body.tool_choice = "auto";
@@ -2011,9 +2215,10 @@ export class ACodeRuntime extends EventEmitter {
         };
         let body = buildBody();
         emitAiRequest(body);
-        const maxAttempts = provider.requestRetryCount + 1;
+        const infiniteRetries = provider.requestRetryCount === INFINITE_RETRY_SENTINEL;
+        const maxAttempts = infiniteRetries ? Infinity : provider.requestRetryCount + 1;
         let contextOverflowCompacted = false;
-        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        for (let attempt = 1; infiniteRetries || attempt <= maxAttempts; attempt += 1) {
             const requestAbortController = new AbortController();
             this.abortController = requestAbortController;
             let timedOut = false;
@@ -2029,7 +2234,20 @@ export class ACodeRuntime extends EventEmitter {
                         requestAbortController.abort();
                     });
                     if (!response.ok) {
-                        throw new Error(`ACode provider request failed: ${response.status} ${await response.text()}`);
+                        // ★ 防御修复：用 withTimeout 包裹 response.text()，
+                        //   防止 502/503 等错误响应的 body stream 挂起导致永久阻塞。
+                        //   外层 withTimeout(requestTotalTimeoutMs, 10min) 兜底太晚，
+                        //   且看门狗可能已被重试 error 事件禁用。
+                        const errorBody = await withTimeout(response.text(), provider.requestTimeoutMs, "ACode provider error response body", () => {
+                            timedOut = true;
+                            requestAbortController.abort();
+                        });
+                        // ★ 截断过长的错误响应体（如 Cloudflare 502 HTML 页面可达数 KB），
+                        //   避免错误消息通过事件链路传播时造成 HTTP POST body 过大或日志膨胀
+                        const truncatedBody = errorBody.length > 500
+                            ? `${errorBody.slice(0, 500)}...(truncated, total ${errorBody.length} chars)`
+                            : errorBody;
+                        throw new Error(`ACode provider request failed: ${response.status} ${truncatedBody}`);
                     }
                     const contentType = response.headers?.get?.("content-type") || "";
                     if (provider.stream &&
@@ -2049,7 +2267,14 @@ export class ACodeRuntime extends EventEmitter {
                         return {};
                     }
                     return payload;
-                })(), 0, "ACode provider request");
+                })(), 
+                // ★ 安全修复：即使无限重试也保留总预算超时兜底，
+                //   防止 provider 持续发送 SSE keep-alive 导致 idle timeout 永不触发、
+                //   请求永久挂起。用户可通过配置更大的 requestTotalTimeoutMs 值来放宽限制。
+                provider.requestTotalTimeoutMs, "ACode provider request total", () => {
+                    // 总预算超时：abort 底层 fetch / stream reader，避免泄漏
+                    requestAbortController.abort();
+                });
             }
             catch (error) {
                 let requestError;
@@ -2070,12 +2295,14 @@ export class ACodeRuntime extends EventEmitter {
                     // 这里不通过 performCompaction（它会先检查 isOverflow），
                     // 而是直接调用 summarizeConversation 进行强制摘要化
                     const sizeBeforeKB = conversationSizeKB(this.state.conversation);
+                    const tokensBeforeOC = estimateConversationTokens(this.state.conversation); // tokensBefore 命名冲突，加 OC 后缀
                     const msgCountBefore = this.state.conversation.length;
                     const compactionId = `compaction-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
                     this.emitAcodeEvent("context_compaction", {
                         action: "start",
                         compactionId,
                         sizeKB: sizeBeforeKB,
+                        estimatedTokens: tokensBeforeOC,
                         messageCount: msgCountBefore,
                         model: provider.model,
                         trigger: "provider_overflow_error",
@@ -2094,6 +2321,7 @@ export class ACodeRuntime extends EventEmitter {
                     });
                     this.emitCompactionPhase(compactionId, "summarize_done", "阶段2: 摘要化对话", `摘要化了 ${summarizedCount} 条消息`);
                     const sizeAfterKB = conversationSizeKB(this.state.conversation);
+                    const tokensAfterOC = estimateConversationTokens(this.state.conversation);
                     const msgCountAfter = this.state.conversation.length;
                     contextOverflowCompacted = true;
                     const compactedCount = pruneResult.prunedCount + summarizedCount;
@@ -2103,6 +2331,8 @@ export class ACodeRuntime extends EventEmitter {
                         sizeBeforeKB,
                         sizeAfterKB,
                         freedKB: Math.round((sizeBeforeKB - sizeAfterKB) * 10) / 10,
+                        tokensBefore: tokensBeforeOC,
+                        tokensAfter: tokensAfterOC,
                         messageCountBefore: msgCountBefore,
                         messageCountAfter: msgCountAfter,
                         strategy: summarizedCount > 0 ? "summarize" : "prune",
@@ -2125,7 +2355,7 @@ export class ACodeRuntime extends EventEmitter {
                     attempt -= 1;
                     continue;
                 }
-                const shouldRetry = attempt < maxAttempts &&
+                const shouldRetry = (infiniteRetries || attempt < maxAttempts) &&
                     !this.abortRequested &&
                     !this.state.terminated &&
                     isRetryableProviderRequestError(requestError);
@@ -2133,7 +2363,11 @@ export class ACodeRuntime extends EventEmitter {
                     throw requestError;
                 }
                 this.emitAcodeEvent("error", {
-                    message: `ACode provider request attempt ${attempt}/${maxAttempts} failed; retrying: ${requestError.message}`,
+                    message: `ACode provider request attempt ${attempt}${infiniteRetries ? '' : `/${maxAttempts}`} failed; retrying: ${requestError.message}`,
+                    // ★ 关键修复：重试中的错误是瞬态的，不是致命错误。
+                    //   如果不标记 nonFatal，适配器会把 status 设为 "error" 并取消看门狗，
+                    //   导致后续重试尝试挂起时看门狗无法检测，agent 永久卡死。
+                    nonFatal: true,
                 });
                 await delay(DEFAULT_PROVIDER_REQUEST_RETRY_DELAY_MS * attempt);
             }
@@ -2226,14 +2460,20 @@ export class ACodeRuntime extends EventEmitter {
             }
             const toolName = toolCall.function.name;
             runtimeDebugLog(`[ACodeRuntime] 🔍 Looking up tool: ${toolName}`);
-            const tool = this.state.exposedTools.find((item) => item.exposedName === toolCall.function.name);
+            let tool = this.state.exposedTools.find((item) => item.exposedName === toolName);
             if (!tool) {
-                console.error(`[ACodeRuntime] ❌ Tool not found: ${toolCall.function.name}, ` +
+                tool = this.state.exposedTools.find((item) => item.toolName === toolName);
+                if (tool) {
+                    runtimeDebugLog(`[ACodeRuntime] ↩️ 裸名回退匹配: ${toolName} -> ${tool.exposedName}`);
+                }
+            }
+            if (!tool) {
+                console.error(`[ACodeRuntime] ❌ Tool not found: ${toolName}, ` +
                     `available tools: ${this.state.exposedTools.map(t => t.exposedName).join(", ")}`);
                 this.state.conversation.push({
                     role: "tool",
                     tool_call_id: toolCall.id,
-                    content: `ACode MCP tool not found: ${toolCall.function.name}`,
+                    content: `ACode MCP tool not found: ${toolName}`,
                 });
                 continue;
             }
@@ -2269,7 +2509,13 @@ export class ACodeRuntime extends EventEmitter {
                         argumentsPreview: summarizeToolArguments(toolArguments),
                     });
                     const toolStart = Date.now();
-                    runtimeDebugLog(`[ACodeRuntime] ▶️ Executing built-in tool: ${tool.exposedName}`);
+                    const toolTimeoutMs = getBuiltInToolTimeoutMs(tool, toolArguments, this.state.provider.mcpToolTimeoutMs);
+                    runtimeDebugLog(`[ACodeRuntime] ▶️ Executing built-in tool: ${tool.exposedName} ` +
+                        `(timeout: ${toolTimeoutMs}ms, abortRequested: ${this.abortRequested})`);
+                    if (toolTimeoutMs <= 0) {
+                        console.warn(`[ACodeRuntime] ⚠️ Built-in tool ${tool.exposedName} has NO timeout (timeoutMs=${toolTimeoutMs})! ` +
+                            `If this tool hangs, executeSubmit will NEVER resolve, blocking the submit queue permanently.`);
+                    }
                     const result = await withTimeout(tool.execute(toolArguments, {
                         onOutput: (outputEvent) => {
                             this.emitAcodeEvent("command_output", {
@@ -2288,7 +2534,7 @@ export class ACodeRuntime extends EventEmitter {
                             });
                         },
                         toolCallId: toolCall.id,
-                    }), getBuiltInToolTimeoutMs(tool, toolArguments, this.state.provider.mcpToolTimeoutMs), `ACode built-in tool ${tool.toolName}`);
+                    }), toolTimeoutMs, `ACode built-in tool ${tool.toolName}`);
                     const toolDuration = Date.now() - toolStart;
                     runtimeDebugLog(`[ACodeRuntime] ✅ Built-in tool ${tool.exposedName} completed in ${toolDuration}ms`);
                     if (this.isTurnSuperseded(contextVersion)) {
@@ -2367,7 +2613,11 @@ export class ACodeRuntime extends EventEmitter {
                 const toolStart = Date.now();
                 runtimeDebugLog(`[ACodeRuntime] ▶️ Executing MCP tool: ${tool.exposedName} ` +
                     `(timeout: ${toolTimeoutMs}ms, polling: ${isPollingTool})`);
-                const result = await this.callMcpToolWithTimeout(connection, tool, toolArguments, toolTimeoutMs, isPollingTool);
+                // poll_message 工具需要同时检测子 agent 完成事件（有就返回类型），
+                // 使用 sub-agent race 包装器替代直接 MCP 调用。
+                const result = isPollingTool && getSemanticToolName(tool.toolName) === "poll_message"
+                    ? await this.callPollMessageWithSubAgentRace(connection, tool, toolArguments, toolTimeoutMs)
+                    : await this.callMcpToolWithTimeout(connection, tool, toolArguments, toolTimeoutMs, isPollingTool);
                 const toolDuration = Date.now() - toolStart;
                 runtimeDebugLog(`[ACodeRuntime] ✅ MCP tool ${tool.exposedName} completed in ${toolDuration}ms`);
                 if (this.isTurnSuperseded(contextVersion)) {
@@ -2400,14 +2650,37 @@ export class ACodeRuntime extends EventEmitter {
                 await this.appendSyntheticMultimodalUserMessage(resultText, toolCall.id, contextVersion);
             }
             catch (error) {
-                console.error(`[ACodeRuntime] ❌ Tool execution failed: ${toolCall.function.name}`, error instanceof Error ? error.message : String(error));
+                const isTimeout = error instanceof Error &&
+                    error.message.includes("timed out after");
+                const isAbortError = error instanceof Error &&
+                    error.name === "AbortError";
+                console.error(`[ACodeRuntime] ❌ Tool execution failed: ${toolCall.function.name}`, `isTimeout=${isTimeout}, isAbortError=${isAbortError}`, error instanceof Error ? error.message : String(error));
                 if (this.isTurnSuperseded(contextVersion)) {
+                    runtimeDebugLog(`[ACodeRuntime] ️ Turn superseded after tool error, skipping`);
                     return;
                 }
                 if (this.abortRequested || this.state.terminated) {
-                    runtimeDebugLog(`[ACodeRuntime] ⚠️ Rethrowing error due to abort/termination`);
+                    // ★ 修复 BUG（时间线永久卡在"编辑文件"）：
+                    //   abort/termination 时原实现直接 rethrow，跳过 appendToolFailureResult
+                    //   (3752 行的 mcp_status tool_result 发射)，导致 adapter 永远收不到 tool_result，
+                    //   tool_use_end 永不发射，前端时间线永久卡在 tool_use_start 创建的工具条目。
+                    //   修复：在 rethrow 前补发一个带 failed=true 的 tool_result，关闭时间线条目。
+                    runtimeDebugLog(`[ACodeRuntime] ⚠️ Rethrowing error due to abort/termination ` +
+                        `(abortRequested=${this.abortRequested}, terminated=${this.state.terminated})`);
+                    runtimeDebugLog(`[ACodeRuntime] 📤 Emitting mcp_status tool_result (failed, aborted) ` +
+                        `for ${tool.exposedName} before rethrow to close timeline entry`);
+                    this.emitAcodeEvent("mcp_status", {
+                        action: "tool_result",
+                        server: tool.kind === "mcp" ? tool.serverName : "builtin",
+                        tool: tool.toolName,
+                        result: `[aborted] ${error instanceof Error ? error.message : String(error)}`,
+                        failed: true,
+                        aborted: true,
+                    });
                     throw error instanceof Error ? error : new Error(String(error));
                 }
+                runtimeDebugLog(`[ACodeRuntime]  Calling appendToolFailureResult for ${tool.exposedName} ` +
+                    `(isTimeout=${isTimeout})`);
                 this.appendToolFailureResult(toolCall, tool, error);
             }
         }
@@ -2415,13 +2688,19 @@ export class ACodeRuntime extends EventEmitter {
     }
     async callMcpToolWithTimeout(connection, tool, toolArguments, timeoutMs, retrySdkTimeout) {
         const sdkTimeout = timeoutMs > 0 ? timeoutMs : MCP_SDK_MAX_SAFE_TIMEOUT_MS;
+        // 子 agent 共享父 agent 的 MCP 连接时，注入标记让 MCP server 跳过状态上报
+        // （StatusReporter 绑定父 agentId，子 agent 的事件不应出现在父 agent 时间线上）
+        const isSubAgent = Boolean(this.config.sharedMcpConnections);
+        const finalArguments = isSubAgent
+            ? { ...toolArguments, _aws_sub_agent: true }
+            : toolArguments;
         while (true) {
             const stopWaiter = this.createRuntimeStopWaiter(`ACode MCP tool ${tool.serverName}/${tool.toolName}`);
             try {
                 return await withTimeout(Promise.race([
                     connection.client.callTool({
                         name: tool.toolName,
-                        arguments: toolArguments,
+                        arguments: finalArguments,
                     }, undefined, { timeout: sdkTimeout }),
                     stopWaiter.promise,
                 ]), timeoutMs, `ACode MCP tool ${tool.serverName}/${tool.toolName}`);
@@ -2441,6 +2720,605 @@ export class ACodeRuntime extends EventEmitter {
             }
         }
     }
+    /**
+     * 将子 agent 终态通知转为 poll_message 格式的合成 DirectMessage。
+     * 主流程：构建符合 MCP poll_message 返回格式的 JSON 字符串。
+     */
+    static formatSubAgentCompletionAsPollResult(notifications) {
+        const directMessages = notifications.map((n) => {
+            const summary = n.error
+                ? `Sub-agent ${n.subId} [${n.status}]: ${n.description}\nError: ${n.error}`
+                : `Sub-agent ${n.subId} [${n.status}]: ${n.description}\nOutput: ${n.output.length > 500 ? n.output.slice(0, 500) + "... (truncated)" : n.output}`;
+            return {
+                msgId: `subagent-completion-${n.subId}-${Date.now()}`,
+                senderId: "ACode-Runtime",
+                senderName: "系统",
+                content: summary,
+                requireReply: false,
+                prompt: `Sub-agent ${n.subId} (${n.description}) has reached terminal state: ${n.status}. Review its output and decide next steps.`,
+                timestamp: new Date().toISOString(),
+            };
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        directMessages,
+                        groupMessages: [],
+                        fromBuffer: false,
+                        systemMessages: [],
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    /**
+     * 将子 agent 终态通知合并到已有的 MCP poll_message 返回结果中。
+     * 主流程：解析 MCP 返回的 JSON -> 将通知转为 DirectMessage 插入到 directMessages 前面 -> 重新序列化。
+     */
+    static mergeSubAgentCompletionsIntoMcpResult(mcpResult, notifications) {
+        if (notifications.length === 0)
+            return mcpResult;
+        // 提取 MCP 结果中的文本
+        const resultText = toToolResultText(mcpResult);
+        let parsed;
+        try {
+            parsed = JSON.parse(resultText);
+        }
+        catch {
+            // 如果 MCP 结果不是 JSON（异常情况），直接返回原结果
+            return mcpResult;
+        }
+        const subAgentMessages = notifications.map((n) => {
+            const summary = n.error
+                ? `Sub-agent ${n.subId} [${n.status}]: ${n.description}\nError: ${n.error}`
+                : `Sub-agent ${n.subId} [${n.status}]: ${n.description}\nOutput: ${n.output.length > 500 ? n.output.slice(0, 500) + "... (truncated)" : n.output}`;
+            return {
+                msgId: `subagent-completion-${n.subId}-${Date.now()}`,
+                senderId: "ACode-Runtime",
+                senderName: "系统",
+                content: summary,
+                requireReply: false,
+                prompt: `Sub-agent ${n.subId} (${n.description}) has reached terminal state: ${n.status}. Review its output and decide next steps.`,
+                timestamp: new Date().toISOString(),
+            };
+        });
+        const mergedDirectMessages = [
+            ...subAgentMessages,
+            ...(parsed.directMessages ?? []),
+        ];
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        ...parsed,
+                        directMessages: mergedDirectMessages,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    /**
+     * Memory 自动委托 sub-agent 完成一轮后的外部重新检查。
+     *
+     * 查询服务端 memory 真实状态（通过 MCP 工具直接调用，非 LLM 自报），
+     * 判断 sub-agent 是否真正完成了处理：
+     * - memory_file_change：检查每条 memory 的 memory_status 是否已回到 normal
+     * - memory_expiration：检查每条 memory 是否已续期（expiresAt 在未来）或已清理（read 返回 null）
+     * - memory_cleanup：检查 get_memory_stats 中对应类型/域是否仍 exceeded
+     *
+     * 若仍有未完成项，返回 { done: false, continueMessage } 包含 "经检查，未完成对xxx的处理，请继续"
+     * 及具体未完成列表，由 SubAgentManager 注入同一 sub-agent 的下一轮 submit。
+     *
+     * recheck 自身出错（MCP 连接不可用、工具调用超时等）时返回 { done: true }，不阻塞 sub-agent 结束。
+     */
+    async recheckMemoryDelegate(type, uris, output, turn) {
+        const connection = this.state.mcpConnections.find((c) => c.serverName === 'aws-client-agent-mcp');
+        if (!connection) {
+            runtimeDebugLog(`[ACodeRuntime] recheckMemoryDelegate: aws-client-agent-mcp connection not found, treating as done`);
+            return { done: true };
+        }
+        try {
+            if (type === 'memory_file_change') {
+                return await this.recheckMemoryFileChange(connection, uris);
+            }
+            if (type === 'memory_expiration') {
+                return await this.recheckMemoryExpiration(connection, uris);
+            }
+            return await this.recheckMemoryCleanup(connection, uris);
+        }
+        catch (err) {
+            runtimeDebugLog(`[ACodeRuntime] recheckMemoryDelegate failed (type=${type}, turn=${turn}): ` +
+                `${err instanceof Error ? err.message : String(err)}, treating as NOT done (retry via recheck loop)`);
+            // 校验异常（读取失败/超时/服务端错误）一律判「未完成」，由 startWithRecheck 的
+            // 重试循环（最多 3 次）兜底；既不提前释放 URI，也不会因一次抖动就把子 agent 判为完成。
+            return {
+                done: false,
+                continueMessage: `经检查，无法确认以下 memory 是否已处理（校验异常：${err instanceof Error ? err.message : String(err)}）。` +
+                    `请重新执行验证步骤（read_memory / get_memory_stats）确认真实状态后再继续。`,
+            };
+        }
+    }
+    /**
+     * 通过 MCP read_memory 工具读取单条 memory 记录。
+     * 注入 _aws_sub_agent=true 避免状态上报污染父 agent 时间线。
+     * 返回 null 表示 memory 明确不存在（服务端返回 null/undefined 或非对象）。
+     * 读取/解析异常（网络抖动、超时、服务端错误）会向上抛出，交由 recheckMemoryDelegate
+     * 统一判定为「未完成」，避免被误当作「已处理」。
+     */
+    async readMemoryViaMcp(connection, uri) {
+        try {
+            const result = await withTimeout(connection.client.callTool({
+                name: 'read_memory',
+                arguments: { uri, _aws_sub_agent: true },
+            }, undefined, { timeout: 30_000 }), 30_000, `recheck read_memory ${uri}`);
+            const text = toToolResultText(result);
+            const parsed = JSON.parse(text);
+            if (parsed === null || parsed === undefined)
+                return null;
+            if (typeof parsed !== 'object' || Array.isArray(parsed))
+                return null;
+            return parsed;
+        }
+        catch (err) {
+            // 读取/解析异常（网络抖动、超时、服务端错误）应向上传播，交由 recheckMemoryDelegate
+            // 统一判定为「未完成」（done:false），而非被误当作「memory 不存在 = 已处理」。
+            // 仅当服务端正返回明确的 null/undefined 时才表示 memory 不存在。
+            throw err;
+        }
+    }
+    /** recheck memory_file_change：检查 memory_status 是否仍为 updating */
+    async recheckMemoryFileChange(connection, uris) {
+        const stillUpdating = [];
+        await Promise.all(uris.map(async (uri) => {
+            const mem = await this.readMemoryViaMcp(connection, uri);
+            if (mem && mem.memory_status === 'updating') {
+                stillUpdating.push(uri);
+            }
+        }));
+        if (stillUpdating.length === 0) {
+            runtimeDebugLog(`[ACodeRuntime] recheck memory_file_change: all ${uris.length} URIs done (memory_status=normal or deleted)`);
+            return { done: true };
+        }
+        const list = stillUpdating.map((u) => `- ${u}`).join('\n');
+        runtimeDebugLog(`[ACodeRuntime] recheck memory_file_change: ${stillUpdating.length}/${uris.length} URIs still updating`);
+        return {
+            done: false,
+            continueMessage: `经检查，未完成对以下 memory 的更新，请继续：\n${list}\n\n` +
+                `这些 memory 的 memory_status 仍为 "updating"。请重新 read_memory 查看内容，` +
+                `查看绑定文件最新内容，并调用 update_memory 完成更新。`,
+        };
+    }
+    /** recheck memory_expiration：检查 expiresAt 是否仍过期 或 memory_status 是否仍为 recalling */
+    async recheckMemoryExpiration(connection, uris) {
+        const stillExpired = [];
+        const now = Date.now();
+        await Promise.all(uris.map(async (uri) => {
+            const mem = await this.readMemoryViaMcp(connection, uri);
+            if (!mem)
+                return; // memory 已删除/不存在 → 视为已处理
+            const expiresAt = mem.expiresAt ?? mem.expires_at;
+            const isRecalling = mem.memory_status === 'recalling';
+            const isExpired = typeof expiresAt === 'string' && new Date(expiresAt).getTime() < now;
+            if (isRecalling || isExpired) {
+                stillExpired.push(uri);
+            }
+        }));
+        if (stillExpired.length === 0) {
+            runtimeDebugLog(`[ACodeRuntime] recheck memory_expiration: all ${uris.length} URIs done (renewed, cleaned, or no longer expired)`);
+            return { done: true };
+        }
+        const list = stillExpired.map((u) => `- ${u}`).join('\n');
+        runtimeDebugLog(`[ACodeRuntime] recheck memory_expiration: ${stillExpired.length}/${uris.length} URIs still expired or recalling`);
+        return {
+            done: false,
+            continueMessage: `经检查，未完成对以下 memory 的处理，请继续：\n${list}\n\n` +
+                `这些 memory 仍处于过期或回忆中状态。请调用 memory_recurrence 获取内容，` +
+                `对需要保留的调用 update_memory 续期，对无价值的调用 memory_recurrence_complete 清理。`,
+        };
+    }
+    /** recheck memory_cleanup：检查 get_memory_stats 中对应类型/域是否仍 exceeded */
+    async recheckMemoryCleanup(connection, uris) {
+        // delegate URIs 格式为 "${memoryType}/${domain}"
+        let stats;
+        try {
+            const result = await withTimeout(connection.client.callTool({
+                name: 'get_memory_stats',
+                arguments: { _aws_sub_agent: true },
+            }, undefined, { timeout: 30_000 }), 30_000, 'recheck get_memory_stats');
+            const text = toToolResultText(result);
+            stats = JSON.parse(text);
+        }
+        catch {
+            // stats 查询失败 → 保守判为「未完成」，避免一次抖动就把清理判为完成并释放 URI。
+            // 交由 startWithRecheck 的重试循环兜底；与 recheckMemoryDelegate 中央 catch 行为一致。
+            return {
+                done: false,
+                continueMessage: 'get_memory_stats 查询失败，无法确认容量是否已达标，请重新验证后再继续。',
+            };
+        }
+        const byType = (stats.by_type ?? {});
+        const stillExceeded = [];
+        for (const uri of uris) {
+            const sepIdx = uri.indexOf('/');
+            if (sepIdx < 0)
+                continue;
+            const memoryType = uri.slice(0, sepIdx);
+            const domain = uri.slice(sepIdx + 1);
+            const typeStats = byType[memoryType];
+            const domainStats = typeStats?.by_domain?.[domain];
+            if (domainStats?.exceeded) {
+                stillExceeded.push(`${memoryType}/${domain} (当前 ${domainStats.count ?? '?'} 条，建议上限 ${domainStats.limit ?? '?'})`);
+            }
+        }
+        if (stillExceeded.length === 0) {
+            runtimeDebugLog(`[ACodeRuntime] recheck memory_cleanup: all ${uris.length} type/domain pairs within limits`);
+            return { done: true };
+        }
+        const list = stillExceeded.map((u) => `- ${u}`).join('\n');
+        runtimeDebugLog(`[ACodeRuntime] recheck memory_cleanup: ${stillExceeded.length}/${uris.length} type/domain pairs still exceeded`);
+        return {
+            done: false,
+            continueMessage: `经检查，以下类型/域尚未整理完成，请继续：\n${list}\n\n` +
+                `请调用 list_memories 查看超限记忆，删除不再需要的 recently_memory 或对 agent_memory 调用 update_memory 续期。`,
+        };
+    }
+    /**
+     * 构造 memory 自动委托子 agent 的 prompt。
+     * 主流程：根据 delegate 类型（过期整理/文件变更更新）生成自包含指令。
+     */
+    buildMemoryDelegatePrompt(delegate) {
+        const urisText = delegate.uris.map(u => `- ${u}`).join('\n');
+        if (delegate.type === 'memory_expiration') {
+            return `你是一条专门处理 memory 过期整理的子 agent。
+
+当前有以下 ${delegate.uris.length} 条即将遗忘的记忆需要整理：
+${urisText}
+
+请执行以下步骤（核心逻辑：处理 → 验证 → 未完成则继续）：
+
+=== 处理阶段 ===
+1. 调用 memory_recurrence(limit=10) 分批获取这些过期记忆的完整内容（最早过期优先）
+2. 逐条分析：这些内容是否仍然有价值？是否需要保留、更新、归档或删除？
+3. 对于需要保留的，调用 update_memory 续期；对于无价值的，调用 memory_recurrence_complete 将其清理到永久记忆或删除
+
+=== 验证阶段（关键，不可跳过） ===
+4. 再次调用 memory_recurrence(limit=5) 检查是否还有未处理的过期记忆
+   - 如果返回结果中有之前处理过的 URI，说明更新/清理未生效
+   - 如果仍有待处理条目，说明部分操作未完成
+5. 仔细检查返回结果：
+   - ❌ 若仍有过期记忆未处理（或处理未成功）：输出 "经检查，未完成对以下 memory 的处理，请继续：" 列出还记忆，然后回到步骤 1 继续处理
+   - ✅ 若全部处理完毕（返回空或无过期条目）：静默结束
+
+注意：你运行在独立的上下文窗口中，不影响主 agent 的主线任务。请高效完成，不要询问用户。
+完成后系统会通过查询服务端真实状态进行二次验证（不依赖你的自报结果）。若验证发现仍有 memory 未处理，会发送 "经检查，未完成对以下 memory 的处理，请继续" 消息让你继续处理。`;
+        }
+        if (delegate.type === 'memory_cleanup') {
+            return `你是一条专门处理 memory 容量整理的子 agent。
+
+以下 memory 类型/域已超过建议容量，需要整理：
+${urisText}
+
+请执行以下步骤（核心逻辑：处理 → 验证 → 未完成则继续）：
+
+=== 处理阶段 ===
+1. 调用 get_memory_stats 查看容量详情
+2. 调用 list_memories 按类型查看超限记忆
+3. 删除不再需要的 recently_memory，或更新 agent_memory 续期
+
+=== 验证阶段（关键，不可跳过） ===
+4. 再次调用 get_memory_stats 检查各类型/域的 count 是否已降到建议上限以下
+5. 仔细检查返回结果：
+   - ❌ 若仍有类型/域超过容量上限：输出 "经检查，以下类型/域尚未整理完成，请继续：" 列出具体类型/域和当前容量，然后回到步骤 1 继续处理
+   - ✅ 若全部在建议上限内：静默结束
+
+注意：你运行在独立的上下文窗口中，不影响主 agent 的主线任务。请高效完成，不要询问用户。
+完成后系统会通过查询服务端真实状态进行二次验证（不依赖你的自报结果）。若验证发现仍有类型/域超过容量上限，会发送 "经检查，以下类型/域尚未整理完成，请继续" 消息让你继续处理。`;
+        }
+        return `你是一条专门处理永久记忆文件变更更新的子 agent。
+
+以下 ${delegate.uris.length} 个永久记忆绑定的文件已发生变更：
+${urisText}
+
+请执行以下步骤（核心逻辑：更新 → 验证 → 未完成则继续）：
+
+=== 更新阶段 ===
+1. 调用 read_memory 读取这些 memory 的当前内容
+2. 查看相关绑定文件的最新内容（bound_files 中列出），理解变更点
+3. 调用 update_memory 更新 memory 内容，确保与文件最新状态同步
+
+=== 验证阶段（关键，不可跳过） ===
+4. 调用 read_memory 重新读取这些 memory，检查 memory_status 字段：
+   - 正常情况：Java 服务端会在 update_memory 后自动将 memory_status 恢复为 normal
+5. 仔细检查每个 memory 的状态：
+   - ❌ 若仍有 memory 的 memory_status 为 "updating"：说明更新未生效，输出 "经检查，未完成对以下 memory 的更新，请继续：" 列出具体 memory URI 和当前状态，然后回到步骤 1 继续处理
+   - ✅ 若全部 memory_status 为 "normal"：静默结束
+
+注意：你运行在独立的上下文窗口中，不影响主 agent 的主线任务。请高效完成，不要询问用户。
+完成后系统会通过查询服务端真实状态进行二次验证（不依赖你的自报结果）。若验证发现仍有 memory 的 memory_status 为 "updating"，会发送 "经检查，未完成对以下 memory 的更新，请继续" 消息让你继续处理。`;
+    }
+    /**
+     * 处理 poll_message 结果中的 memory 自动委托标记 (_acodeAutoDelegate)。
+     * 主流程：解析 MCP 返回 -> 识别标记 -> spawn 子 agent -> 返回简化结果。
+     * 非 ACode 运行时（无 subAgentManager）直接透传原结果，不受影响。
+     * 返回 null 表示全部消息已被委托，调用方应重新 poll_message 继续等待真正的消息。
+     */
+    async processMemoryAutoDelegates(mcpResult) {
+        const manager = this.config.subAgentManager;
+        if (!manager) {
+            return mcpResult;
+        }
+        // 提取 MCP 结果中的 JSON 文本
+        let resultText;
+        try {
+            resultText = toToolResultText(mcpResult);
+        }
+        catch {
+            return mcpResult;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(resultText);
+        }
+        catch {
+            return mcpResult;
+        }
+        const directMessages = parsed.directMessages;
+        if (!Array.isArray(directMessages) || directMessages.length === 0) {
+            return mcpResult;
+        }
+        const remainingMessages = [];
+        let delegateEncountered = 0;
+        for (const msg of directMessages) {
+            const delegate = msg._acodeAutoDelegate;
+            if (delegate && (delegate.type === 'memory_expiration' || delegate.type === 'memory_file_change' || delegate.type === 'memory_cleanup')) {
+                delegateEncountered++;
+                // 过滤掉：① 正在处理中的 URI；② 处于冷却期内的 URI（子 agent 刚结束，尚未到重新委托时机）
+                const nowForFilter = Date.now();
+                const inProgressCount = delegate.uris.filter(uri => this.pendingMemorySubAgents.has(uri)).length;
+                const cooledCount = delegate.uris.filter(uri => {
+                    const until = this.memoryDelegateCooldownUntil.get(uri);
+                    return until !== undefined && nowForFilter < until;
+                }).length;
+                const newUris = delegate.uris.filter(uri => {
+                    if (this.pendingMemorySubAgents.has(uri))
+                        return false;
+                    const until = this.memoryDelegateCooldownUntil.get(uri);
+                    return !(until !== undefined && nowForFilter < until);
+                });
+                if (newUris.length === 0) {
+                    // 所有 URI 都在处理中或冷却中，跳过此通知（不委托也不返回给主 agent）
+                    runtimeDebugLog(`[ACodeRuntime] Memory ${delegate.type} skipped: ${inProgressCount} in-progress, ${cooledCount} in cooldown (total ${delegate.uris.length} URIs)`);
+                    continue;
+                }
+                // 用过滤后的 URI 构造 prompt
+                const prompt = this.buildMemoryDelegatePrompt({
+                    type: delegate.type,
+                    uris: newUris,
+                });
+                try {
+                    const subId = await manager.spawn({
+                        parentAgentId: this.config.agentId || 'unknown',
+                        parentSessionId: this.config.sessionId,
+                        subagentType: 'general',
+                        description: `Memory ${delegate.type} auto-delegate (${newUris.length} items)`,
+                        prompt,
+                        workingDirectory: this.config.workingDirectory,
+                        parentConfig: {
+                            ...this.config,
+                            // 注入父 agent 的 MCP 连接，子 agent 复用而非启动新 MCP server 进程
+                            sharedMcpConnections: this.state?.mcpConnections,
+                        },
+                        silent: true,
+                    });
+                    // 注册完成回调：子 agent 终态时从跟踪表中移除对应 URI
+                    for (const uri of newUris) {
+                        this.pendingMemorySubAgents.set(uri, subId);
+                    }
+                    const uriSet = new Set(newUris);
+                    manager.subscribe(subId, () => {
+                        const entry = manager.getSubAgent(subId);
+                        if (entry && (entry.status === 'completed' || entry.status === 'failed' || entry.status === 'cancelled')) {
+                            const finishTs = Date.now();
+                            for (const uri of uriSet) {
+                                if (this.pendingMemorySubAgents.get(uri) === subId) {
+                                    this.pendingMemorySubAgents.delete(uri);
+                                }
+                                // 写入冷却窗口：子 agent 终态后一段时间内不再重新委托，切断「完成→复发」循环。
+                                // 即使 memory 仍处 updating/过期/超限，冷却期内也仅保留巡检，不 spawn 新子任务。
+                                this.memoryDelegateCooldownUntil.set(uri, finishTs + MEMORY_DELEGATE_COOLDOWN_MS);
+                            }
+                            // 惰性清理过期的冷却条目，避免内存堆积
+                            for (const [uri, until] of this.memoryDelegateCooldownUntil) {
+                                if (until <= finishTs) {
+                                    this.memoryDelegateCooldownUntil.delete(uri);
+                                }
+                            }
+                            runtimeDebugLog(`[ACodeRuntime] Memory delegate sub-agent ${subId} finished (${entry.status}), ${uriSet.size} URI(s) entered ${MEMORY_DELEGATE_COOLDOWN_MS}ms cooldown`);
+                        }
+                    });
+                    // 使用带 recheck 循环的启动方式：
+                    // 每轮 submit 完成后，通过 recheckMemoryDelegate 查询服务端真实状态，
+                    // 若 memory 仍未处理好（memory_status=updating / 仍过期 / 容量仍超限），
+                    // 则将 "经检查，未完成对xxx的处理，请继续" 注入同一 sub-agent 的下一轮 submit。
+                    // 最多重试 3 次，提供系统级硬保证（不依赖 LLM 自报结果）。
+                    const delegateType = delegate.type;
+                    const recheckFn = async (output, turn) => {
+                        return this.recheckMemoryDelegate(delegateType, newUris, output, turn);
+                    };
+                    await manager.startWithRecheck(subId, recheckFn, 3);
+                    runtimeDebugLog(`[ACodeRuntime] Auto-delegated memory ${delegate.type} to sub-agent ${subId} (${newUris.length} URIs, ${delegate.uris.length - newUris.length} already in progress)`);
+                }
+                catch (e) {
+                    // 委托失败时不返回给主 agent：memory 通知不应打断主 agent 的主线任务，
+                    // 下次 poll_message 会重新检测并重试委托
+                    runtimeDebugLog(`[ACodeRuntime] Failed to auto-delegate memory ${delegate.type} (suppressed, will retry next poll): ${e instanceof Error ? e.message : String(e)}`);
+                }
+            }
+            else {
+                remainingMessages.push(msg);
+            }
+        }
+        // 未遇到任何 delegate 消息，原样返回（保留原始格式，避免不必要的对象创建）
+        if (delegateEncountered === 0) {
+            return mcpResult;
+        }
+        // 全部 delegate 消息已处理（spawned/skipped/failed），不返回给主 agent
+        if (remainingMessages.length === 0) {
+            return null;
+        }
+        // 有非 delegate 类型的剩余消息，返回简化后的结果
+        const simplified = {
+            ...parsed,
+            directMessages: remainingMessages,
+        };
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(simplified, null, 2),
+                },
+            ],
+        };
+    }
+    /**
+     * poll_message MCP 工具调用的子 agent 完成事件 race 包装器。
+     *
+     * 主流程：
+     * 1. 先检查 completionQueue 中是否有已完成的子 agent -> 有则直接返回合成结果（不调 MCP）
+     * 2. 启动 MCP poll_message 调用与 waitForAnyCompletion 的 race
+     * 3. 子 agent 先完成 -> 返回合成结果（MCP 调用被放弃但仍在运行，下次 poll_message 会复用 pendingPollMessage）
+     * 4. MCP 先返回 -> 合并新完成的子 agent 事件后返回
+     *
+     * 设计说明：
+     * - MCP server 的 poll_message 内部有 while(true) 永久阻塞，只在有消息时返回
+     * - 子 agent 完成事件由 SubAgentManager 在同进程内产生，通过 completionQueue 传递
+      * - 当子 agent 先完成时，MCP 调用被放弃（Promise 不再被 await），MCP server 侧的
+      *   pendingPollMessage 仍在运行，下次 poll_message 调用会通过 pendingPollMessage 复用
+      */
+    async callPollMessageWithSubAgentRace(connection, tool, toolArguments, timeoutMs) {
+        const manager = this.config.subAgentManager;
+        // 没有 SubAgentManager 时，直接走普通 MCP 调用
+        if (!manager) {
+            return await this.callMcpToolWithTimeout(connection, tool, toolArguments, timeoutMs, true);
+        }
+        // 步骤1: 先检查是否有已完成的子 agent -> 有则直接返回合成结果（不调 MCP）
+        const completedBefore = manager.takeCompletedSubAgents();
+        if (completedBefore.length > 0) {
+            runtimeDebugLog(`[ACodeRuntime] poll_message: ${completedBefore.length} sub-agent(s) already completed, returning synthetic result`);
+            return ACodeRuntime.formatSubAgentCompletionAsPollResult(completedBefore);
+        }
+        // 循环：MCP 返回的 memory 通知被全部委托时，重新 poll 继续等待真正的消息
+        let isDelegateRepoll = false; // 首次正常上报，后续委托循环中抑制状态跳动
+        while (true) {
+            // 步骤2: 启动 MCP poll_message 调用与 waitForAnyCompletion 的 race
+            const subAgentWaiter = manager.waitForAnyCompletion();
+            // 委托等待循环中的后续 poll 注入标记：MCP server 跳过 reportToolUse/reportToolResult，
+            // 只调用 reportThinking 保持"思考中"状态，避免"调用MCP↔思考中"反复跳动
+            const pollArgs = isDelegateRepoll
+                ? { ...toolArguments, _aws_silent_poll: true }
+                : toolArguments;
+            const mcpCallPromise = this.callMcpToolWithTimeout(connection, tool, pollArgs, timeoutMs, true);
+            try {
+                const raceWinner = await Promise.race([
+                    mcpCallPromise.then((result) => ({ type: "mcp", result })),
+                    subAgentWaiter.promise.then((notif) => ({ type: "subagent", notif })),
+                ]);
+                if (raceWinner.type === "subagent") {
+                    // 步骤3: 子 agent 先完成 -> 返回合成结果
+                    // 收集所有已完成的子 agent（race 中 resolve 的 + 队列中可能已积累的）
+                    const notifications = manager.takeCompletedSubAgents();
+                    // raceWinner.notif 可能已从队列中取出（waitForAnyCompletion 内部处理），
+                    // 也可能仍在队列中（如果 takeCompletedSubAgents 先执行）
+                    if (notifications.length === 0) {
+                        notifications.push(raceWinner.notif);
+                    }
+                    runtimeDebugLog(`[ACodeRuntime] poll_message: sub-agent ${raceWinner.notif.subId} completed during race, returning synthetic result (${notifications.length} notification(s))`);
+                    return ACodeRuntime.formatSubAgentCompletionAsPollResult(notifications);
+                }
+                // 步骤4: MCP 先返回 -> 合并新完成的子 agent 事件
+                const completedAfter = manager.takeCompletedSubAgents();
+                if (completedAfter.length > 0) {
+                    runtimeDebugLog(`[ACodeRuntime] poll_message: MCP returned, merging ${completedAfter.length} sub-agent completion(s)`);
+                    const merged = ACodeRuntime.mergeSubAgentCompletionsIntoMcpResult(raceWinner.result, completedAfter);
+                    // 合并后仍需检查 memory 自动委托
+                    const processedMerged = await this.processMemoryAutoDelegates(merged);
+                    if (processedMerged !== null) {
+                        // 校验：结果必须包含实际消息才返回，否则继续 poll
+                        if (this.pollResultHasMessages(processedMerged)) {
+                            return processedMerged;
+                        }
+                    }
+                    // 全部被委托或结果为空，等待后再重新 poll（防止紧密循环）
+                    await this.waitForDelegateRepoll();
+                    isDelegateRepoll = true;
+                    continue;
+                }
+                // 自动委托：识别 memory 过期/更新通知，spawn 子 agent 处理，避免打断主 agent 主线
+                const processedResult = await this.processMemoryAutoDelegates(raceWinner.result);
+                if (processedResult !== null) {
+                    // 校验：结果必须包含实际消息才返回，否则继续 poll
+                    if (this.pollResultHasMessages(processedResult)) {
+                        return processedResult;
+                    }
+                }
+                // 全部被委托或结果为空，等待后再重新 poll（防止紧密循环）
+                await this.waitForDelegateRepoll();
+                isDelegateRepoll = true;
+            }
+            finally {
+                subAgentWaiter.cancel();
+            }
+        }
+    }
+    /**
+     * 检查 poll_message 结果是否包含实际消息（directMessages 或 groupMessages 非空）。
+     * 用于循环中过滤空结果，确保 poll_message 只在有消息时返回。
+     */
+    pollResultHasMessages(result) {
+        try {
+            const text = toToolResultText(result);
+            const parsed = JSON.parse(text);
+            const dm = Array.isArray(parsed.directMessages) ? parsed.directMessages.length : 0;
+            const gm = Array.isArray(parsed.groupMessages) ? parsed.groupMessages.length : 0;
+            return dm > 0 || gm > 0;
+        }
+        catch {
+            return true; // 无法解析时保守返回 true，避免无限循环
+        }
+    }
+    /**
+     * 在 memory 委托消息被全部处理后，等待一段时间再重新 poll_message。
+     *
+     * 背景：MCP doPollMessage 对 updating memory 每次都返回通知（无去重），
+     * 而 processMemoryAutoDelegates 因 URI 已在 pendingMemorySubAgents 中而返回 null，
+     * 导致 while(true) 无延迟重 poll，每轮触发 handleToolCall 的 reportToolUse/reportThinking
+     * 状态上报，引发"思考→MCP→跳过"快速循环，最终连接丢失。
+     *
+     * 等待策略：
+     * 1. 固定延迟 DELEGATE_REPOLL_DELAY_MS（5s），给子 agent 时间完成 memory 更新
+     * 2. 可被 runtime stop 中断（通过 createRuntimeStopWaiter）
+     * 3. 不消费 completionQueue（下一轮 takeCompletedSubAgents 会取到）
+     */
+    async waitForDelegateRepoll() {
+        runtimeDebugLog(`[ACodeRuntime] poll_message: all messages delegated, waiting ${DELEGATE_REPOLL_DELAY_MS}ms before re-poll`);
+        const stopWaiter = this.createRuntimeStopWaiter("delegate re-poll delay");
+        try {
+            await Promise.race([
+                new Promise((resolve) => {
+                    const timer = setTimeout(resolve, DELEGATE_REPOLL_DELAY_MS);
+                    if (timer.unref)
+                        timer.unref();
+                }),
+                stopWaiter.promise,
+            ]);
+        }
+        finally {
+            stopWaiter.cancel();
+        }
+    }
     /**
      * Build a one-shot waiter that rejects long-running MCP calls when the runtime stops.
      * Main flow: register a stop callback -> race it with the SDK call -> remove it after either side settles.
@@ -2535,6 +3413,8 @@ export class ACodeRuntime extends EventEmitter {
     }
     appendToolFailureResult(toolCall, tool, error) {
         const resultText = toToolErrorResultText(tool, error);
+        runtimeDebugLog(`[ACodeRuntime] 📤 appendToolFailureResult: emitting mcp_status tool_result ` +
+            `(failed: true) for ${tool.exposedName}, result length: ${resultText.length} chars`);
         // 工具执行失败是正常运行过程的一部分（Agent 会继续处理失败结果）。
         // 标记 nonFatal=true 让 adapter 不变更运行态为 "error"，避免面板按钮异常。
         this.emitAcodeEvent("error", {
@@ -2554,6 +3434,21 @@ export class ACodeRuntime extends EventEmitter {
             content: resultText,
         });
     }
+    /**
+     * 为子 agent 过滤共享 MCP 连接：只保留 memory 工具。
+     *
+     * 原 MCP server 进程通过 AWS_SUB_AGENT=true 限制子 agent 只能调用 memory 工具，
+     * 共享连接后绕过了该机制。此方法在 ACode runtime 层重新施加限制：
+     *   - 复用同一 client/transport（不创建新连接）
+     *   - 仅暴露 MEMORY_TOOL_NAMES 中的工具
+     *   - 防止子 agent 调用 poll_message（与父 agent 冲突）、send_group 等
+     */
+    filterSharedMcpConnectionsForSubAgent(connections) {
+        return connections.map((conn) => ({
+            ...conn,
+            tools: conn.tools.filter((tool) => SUB_AGENT_ALLOWED_MCP_TOOLS.has(tool.toolName)),
+        }));
+    }
     async connectMcpServers(servers, timeoutMs) {
         const connections = [];
         for (const [serverName, serverSpec] of Object.entries(servers)) {
@@ -2670,6 +3565,12 @@ export class ACodeRuntime extends EventEmitter {
         return null;
     }
     async disconnectMcpServers() {
+        // 共享连接（子 agent）不关闭，由所有者（父 agent）管理生命周期
+        if (!this.state.ownsMcpConnections) {
+            this.state.mcpConnections = [];
+            this.state.exposedTools = [];
+            return;
+        }
         const connections = this.state.mcpConnections;
         this.state.mcpConnections = [];
         this.state.exposedTools = [];