aws-runtime-bridge 1.9.33 → 1.9.40

package/dist/adapter/AcodeSdkAdapter.js

@@ -19,10 +19,22 @@ import { getAcodeConfigFile, getAcodeSkillsDir, getRuntimeHomeDir, } from "../co
 import { getReleasedAcodeEntryPath } from "../services/acode-package.js";
 import { getInstanceAiConfigDebugLogger } from "../utils/instance-ai-config-debug-logger.js";
 import { redactForLog } from "../services/instance-ai-config-service.js";
+import { subAgentManager } from "../services/sub-agent-manager-instance.js";
 import { resolveAcodeProviderConfig, } from "./instance-ai-config-resolver.js";
 import { isMessagePollingIdleCommand, isPollMessageToolDescriptor, } from "./acode-tool-names.js";
 import { IdlePollLoop } from "./idle-poll-loop.js";
 import { getCanonicalMcpDetail, getToolActionInfo } from "./types.js";
+/**
+ * Adapter 调试日志：受 ACODE_COMPACTION_DEBUG=1 开关控制（与 runtime.ts 共用同一开关）。
+ * 默认关闭以避免生产环境噪声与潜在的 sessionId/agentId/event 信息泄漏。
+ * 文件中所有原 `console.log` 调用均改为走此 helper。
+ */
+const ACODE_DEBUG_ENABLED = process.env.ACODE_COMPACTION_DEBUG === "1";
+function adapterDebugLog(...args) {
+    if (!ACODE_DEBUG_ENABLED)
+        return;
+    console.log(...args);
+}
 const ACODE_AUTO_POLL_PROMPT = [
     "Continue the AgentsWork message loop now.",
     "You MUST call the exact MCP tool named aws-mcp__poll_message as your next action and wait for the next assigned message or task.",
@@ -37,6 +49,9 @@ const ACODE_AUTO_POLL_FAILURE_DELAY_MS = 2000;
 // 新增：submit 超时检测配置（治本修复：防止状态永久卡住）
 // 当 submit 超过此时间未返回，强制触发恢复机制
 const ACODE_SUBMIT_TIMEOUT_MS = 120000; // 120秒（2分钟）
+// 兜底超时：mcp_status 缓存能力后，等待 skill_status 的最长时间。
+// 超时后单独发出 MCP 能力清单，避免 skill_status 事件缺失导致"暂无能力清单"。
+const CAPABILITIES_FALLBACK_MS = 3000;
 const ACODE_MESSAGE_POLLING_IDLE_PROMPT = "系统提醒：当前工作已完成或运行时已进入空闲状态。请立即调用 poll_message 工具阻塞等待新消息和流程线任务提醒；收到流程任务提醒后调用 my_task 查看已由后台静默抢占的任务详情并直接处理；完成任务后调用 submit_task_result 提交结果，然后继续 poll_message。";
 function getAcodePackageEntryPath() {
     return path.resolve(getReleasedAcodeEntryPath());
@@ -249,20 +264,24 @@ export class AcodeSdkAdapter extends EventEmitter {
             session.status = "error";
             this.emitRuntimeErrorEvent(sessionId, error);
             this.emit("status-change", sessionId, "error");
+            const failedEntry = this.sessions.get(sessionId);
+            if (failedEntry?.capabilitiesFallbackTimer) {
+                clearTimeout(failedEntry.capabilitiesFallbackTimer);
+            }
             this.sessions.delete(sessionId);
             throw error;
         }
     }
     async sendMessage(sessionId, message) {
         const sendStartTime = Date.now();
-        console.log(`[ACode] ═══════════════════════════════════════════════════`);
-        console.log(`[ACode] ▶️ sendMessage STARTED`);
-        console.log(`[ACode]  Session: ${sessionId}`);
-        console.log(`[ACode]  Message: ${message.slice(0, 100)}${message.length > 100 ? '...' : ''}`);
-        console.log(`[ACode] ════════════════════════════════════════════════════`);
+        adapterDebugLog(`[ACode] ═══════════════════════════════════════════════════`);
+        adapterDebugLog(`[ACode] ▶️ sendMessage STARTED`);
+        adapterDebugLog(`[ACode]  Session: ${sessionId}`);
+        adapterDebugLog(`[ACode]  Message: ${message.slice(0, 100)}${message.length > 100 ? '...' : ''}`);
+        adapterDebugLog(`[ACode] ════════════════════════════════════════════════════`);
         const entry = this.requireSession(sessionId);
         const previousStatus = entry.adapterSession.status;
-        console.log(`[ACode]  Previous status: ${previousStatus}`);
+        adapterDebugLog(`[ACode]  Previous status: ${previousStatus}`);
         this.cancelScheduledAutoPoll(entry);
         entry.failedTurnRecoveryScheduled = false;
         entry.idlePollLoop?.stop();
@@ -275,39 +294,63 @@ export class AcodeSdkAdapter extends EventEmitter {
         };
         entry.adapterSession.messages.push(userMessage);
         this.emit("conversation-message", sessionId, userMessage);
-        console.log(`[ACode]  Changing status: ${previousStatus} → thinking`);
+        adapterDebugLog(`[ACode]  Changing status: ${previousStatus} → thinking`);
         entry.adapterSession.status = "thinking";
         this.emit("status-change", sessionId, "thinking");
         // 启动超时检测
         this.startSubmitTimeoutDetection(sessionId, entry, "sendMessage");
         try {
-            console.log(`[ACode] ▶️ Calling runtime.submit()...`);
+            adapterDebugLog(`[ACode] ▶️ Calling runtime.submit()...`);
             const submitStartTime = Date.now();
             await entry.runtime.submit(message);
             const submitDuration = Date.now() - submitStartTime;
             // submit 成功返回，取消超时检测
             this.cancelSubmitTimeoutDetection(entry);
-            console.log(`[ACode] ✅ runtime.submit() completed in ${submitDuration}ms`);
-            console.log(`[ACode]  Current status after submit: ${entry.adapterSession.status}`);
-            console.log(`[ACode] ▶️ Calling recoverResolvedTurnWithoutTerminalEvent()...`);
+            adapterDebugLog(`[ACode] ✅ runtime.submit() completed in ${submitDuration}ms`);
+            adapterDebugLog(`[ACode]  Current status after submit: ${entry.adapterSession.status}`);
+            adapterDebugLog(`[ACode] ▶️ Calling recoverResolvedTurnWithoutTerminalEvent()...`);
             this.recoverResolvedTurnWithoutTerminalEvent(sessionId);
-            console.log(`[ACode]  Status after recovery: ${entry.adapterSession.status}`);
+            adapterDebugLog(`[ACode]  Status after recovery: ${entry.adapterSession.status}`);
             const totalDuration = Date.now() - sendStartTime;
-            console.log(`[ACode] ════════════════════════════════════════════════════`);
-            console.log(`[ACode] ✅ sendMessage COMPLETED in ${totalDuration}ms`);
-            console.log(`[ACode] ═══════════════════════════════════════════════════`);
+            adapterDebugLog(`[ACode] ════════════════════════════════════════════════════`);
+            adapterDebugLog(`[ACode] ✅ sendMessage COMPLETED in ${totalDuration}ms`);
+            adapterDebugLog(`[ACode] ═══════════════════════════════════════════════════`);
         }
         catch (error) {
             const errorDuration = Date.now() - sendStartTime;
             console.error(`[ACode] ❌ sendMessage FAILED after ${errorDuration}ms:`, error instanceof Error ? error.message : String(error));
             // submit 抛出异常，取消超时检测
             this.cancelSubmitTimeoutDetection(entry);
-            console.log(`[ACode] ▶️ Calling emitRuntimeError with recover=true...`);
+            adapterDebugLog(`[ACode] ▶️ Calling emitRuntimeError with recover=true...`);
             this.emitRuntimeError(sessionId, error, { recover: true });
-            console.log(`[ACode]  Status after error recovery: ${entry.adapterSession.status}`);
+            adapterDebugLog(`[ACode]  Status after error recovery: ${entry.adapterSession.status}`);
         }
     }
     async sendConfirmation(_sessionId, _accept) { }
+    /**
+     * 接收前端对 ask_user_question 的回答（来自 terminal.ts /sdk/answer 路由）。
+     * 通过 pendingQuestionToolCallId 找到 runtime.submitQuestionAnswer 的入参 toolCallId，
+     * resolve 阻塞的工具 execute()，让 ACode 继续下一轮 LLM 请求。
+     * 重新启动 submit 超时检测（继续计费后续工具执行时间）。
+     */
+    async sendQuestionAnswer(sessionId, answers) {
+        const entry = this.sessions.get(sessionId);
+        if (!entry) {
+            return;
+        }
+        const toolCallId = entry.pendingQuestionToolCallId;
+        if (!toolCallId) {
+            adapterDebugLog(`[AcodeSdkAdapter] sendQuestionAnswer: no pending question for session ${sessionId}`);
+            return;
+        }
+        entry.pendingQuestionToolCallId = undefined;
+        entry.pendingQuestions = undefined;
+        if (entry.runtime.submitQuestionAnswer) {
+            entry.runtime.submitQuestionAnswer(toolCallId, answers);
+        }
+        // 用户回答后，重新启动 submit 超时检测（剩余工具执行时间计入）
+        this.startSubmitTimeoutDetection(sessionId, entry, "sendQuestionAnswer");
+    }
     async abortCurrentTurn(sessionId) {
         await this.requireSession(sessionId).runtime.abort();
     }
@@ -344,6 +387,10 @@ export class AcodeSdkAdapter extends EventEmitter {
         this.cancelScheduledAutoPoll(entry);
         entry.failedTurnRecoveryScheduled = false;
         entry.idlePollLoop?.stop();
+        if (entry.capabilitiesFallbackTimer) {
+            clearTimeout(entry.capabilitiesFallbackTimer);
+            entry.capabilitiesFallbackTimer = undefined;
+        }
         await entry.runtime.stop();
         entry.adapterSession.status = "terminated";
         this.sessions.delete(sessionId);
@@ -361,6 +408,29 @@ export class AcodeSdkAdapter extends EventEmitter {
     getSessionStatus(sessionId) {
         return this.sessions.get(sessionId)?.adapterSession.status;
     }
+    /**
+     * 主动查询会话的运行时能力清单（MCP 工具 + skills）。
+     * 只读 adapter 内存缓存（lastCombinedCapabilities），不触发 runtime 重新探测。
+     * 由 mcp_status / skill_status 事件维护；若尚未收到任何 runtime_capabilities 事件则返回 undefined。
+     */
+    getCapabilities(sessionId) {
+        return this.sessions.get(sessionId)?.lastCombinedCapabilities;
+    }
+    /**
+     * 主动查询会话当前挂起的 ask_user_question。
+     * 只读 adapter 内存缓存（pendingQuestionToolCallId + pendingQuestions）。
+     * 由 bridge GET /runtime/sdk/pending-questions 端点调用，用于前端刷新后重建提问 UI。
+     * 返回 undefined 表示当前无挂起提问（会话不存在或 agent 未提问）。
+     */
+    getPendingQuestion(sessionId) {
+        const entry = this.sessions.get(sessionId);
+        if (!entry?.pendingQuestionToolCallId)
+            return undefined;
+        return {
+            toolCallId: entry.pendingQuestionToolCallId,
+            questions: entry.pendingQuestions ?? [],
+        };
+    }
     cleanup() {
         for (const sessionId of this.sessions.keys()) {
             void this.terminateSession(sessionId);
@@ -548,6 +618,7 @@ export class AcodeSdkAdapter extends EventEmitter {
                 ? config.memory
                 : undefined,
             env: config.envOverrides,
+            subAgentManager,
         });
         const debugLogger = getInstanceAiConfigDebugLogger();
         void debugLogger.log({
@@ -672,10 +743,23 @@ export class AcodeSdkAdapter extends EventEmitter {
         if (event.type === "ai_request") {
             const estimatedTokens = toEstimatedContextTokens(event.data);
             if (estimatedTokens > 0) {
-                entry.adapterSession.totalUsage.inputTokens = estimatedTokens;
-                entry.adapterSession.totalUsage.outputTokens = 0;
+                // ★ 不再覆盖 totalUsage.inputTokens 和重置 outputTokens=0。
+                //    runModelTurn 的多轮迭代中每个 iter 都会发 ai_request，
+                //    重置 outputTokens=0 导致面板在整个 executeSubmit 期间看到 0。
+                //    改用 Math.max 确保 inputTokens 单调递增即可。
+                //    注意：如果上下文缩减（如释放历史），Math.max 不会反映真实缩减，
+                //    但对面板展示而言单调递增是可接受的设计取舍。
+                if (estimatedTokens > entry.adapterSession.totalUsage.inputTokens) {
+                    entry.adapterSession.totalUsage.inputTokens = estimatedTokens;
+                }
+                // ★ 使用消息历史估算实时的 output tokens，确保面板在会话期间看到非零值
+                const liveOutputEstimate = this.estimateOutputTokensFromMessages(entry.adapterSession.messages);
+                const displayUsage = {
+                    ...entry.adapterSession.totalUsage,
+                    outputTokens: Math.max(entry.adapterSession.totalUsage.outputTokens, liveOutputEstimate),
+                };
                 this.emit("status-change", event.sessionId, entry.adapterSession.status, {
-                    usage: entry.adapterSession.totalUsage,
+                    usage: displayUsage,
                 });
             }
             this.emitProviderEvent(event, "ai_request", {
@@ -711,12 +795,12 @@ export class AcodeSdkAdapter extends EventEmitter {
         if (event.type === "turn_complete") {
             const usage = toUsage(event.data.usage);
             if (usage) {
-                entry.adapterSession.totalUsage.inputTokens += usage.inputTokens;
+                // ★ 只累加 outputTokens；inputTokens 由 ai_request 的事件估算维护（Math.max 单调递增）
                 entry.adapterSession.totalUsage.outputTokens += usage.outputTokens;
             }
             // 关键日志：记录 turn_complete 事件
             const previousStatus = entry.adapterSession.status;
-            console.log(`[ACode] turn_complete event received (session: ${event.sessionId}), ` +
+            adapterDebugLog(`[ACode] turn_complete event received (session: ${event.sessionId}), ` +
                 `previous status: ${previousStatus}, failed: ${event.data.failed === true}, ` +
                 `aborted: ${event.data.aborted === true}`);
             if (isFailedAcodeTurnComplete(event.data)) {
@@ -732,7 +816,7 @@ export class AcodeSdkAdapter extends EventEmitter {
                 // initial prompt turn failed, autoPollActive was false and the
                 // session got permanently stuck in 'error'. Now we always recover
                 // for non-terminal sessions so the idle loop can retry.
-                console.log(`[ACode] Recovering from failed turn_complete (session: ${event.sessionId})`);
+                adapterDebugLog(`[ACode] Recovering from failed turn_complete (session: ${event.sessionId})`);
                 this.recoverTurnFailure(event.sessionId, entry);
                 return;
             }
@@ -749,7 +833,7 @@ export class AcodeSdkAdapter extends EventEmitter {
             this.emit("status-change", event.sessionId, "waiting_input", {
                 usage: entry.adapterSession.totalUsage,
             });
-            console.log(`[ACode] Status changed to waiting_input after turn_complete (session: ${event.sessionId})`);
+            adapterDebugLog(`[ACode] Status changed to waiting_input after turn_complete (session: ${event.sessionId})`);
             if (entry.autoPollActive &&
                 entry.autoPollObservedAssistantText &&
                 !entry.autoPollObservedPollingTool) {
@@ -771,7 +855,37 @@ export class AcodeSdkAdapter extends EventEmitter {
             this.emit("status-change", event.sessionId, "completed");
             return;
         }
+        if (event.type === "question_request") {
+            // ask_user_question 工具被调用：runtime 在 execute() 中阻塞等待答案。
+            // 取消 submit 超时检测（用户回答时间不计入 2 分钟超时），
+            // 记录 toolCallId + questions 供 sendQuestionAnswer 和 getPendingQuestion 使用，
+            // 转发事件让 terminal.ts 推到前端。
+            this.cancelSubmitTimeoutDetection(entry);
+            const toolCallId = typeof event.data.toolCallId === "string"
+                ? event.data.toolCallId
+                : "";
+            const questions = Array.isArray(event.data.questions)
+                ? event.data.questions
+                : [];
+            if (toolCallId) {
+                entry.pendingQuestionToolCallId = toolCallId;
+                entry.pendingQuestions = questions;
+            }
+            this.emit("ask-user-question", {
+                sessionId: event.sessionId,
+                questions,
+            });
+            return;
+        }
         if (event.type === "error") {
+            // nonFatal=true 表示工具执行失败等非致命错误（Agent 会继续处理），
+            // 仅推送事件到时间线，不变更运行态为 "error"，避免面板启动/停止按钮异常。
+            if (event.data.nonFatal) {
+                this.emitProviderEvent(event, "error", {
+                    text: String(event.data.message || "ACode runtime error"),
+                });
+                return;
+            }
             entry.adapterSession.status = "error";
             this.emitProviderEvent(event, "error", {
                 text: String(event.data.message || "ACode runtime error"),
@@ -812,6 +926,69 @@ export class AcodeSdkAdapter extends EventEmitter {
                         "Please configure an MCP server that provides poll_message (e.g. aws-mcp) in the dashboard panel for this runtime.";
                     console.warn(`[${this.displayName}] ${message}`);
                 }
+                // 将启动时加载的 MCP 工具清单缓存到 entry，等待 skill_status 事件到达后合并发出，
+                // 避免两个 runtime_capabilities 事件并发 HTTP POST 导致其中一个丢失
+                const mcpServers = Array.isArray(event.data.servers)
+                    ? event.data.servers
+                    : [];
+                const mcpTools = tools
+                    .map((tool) => ({
+                    name: String(tool.name ?? ""),
+                    source: String(tool.source ?? ""),
+                    description: String(tool.description ?? ""),
+                }))
+                    .filter((tool) => tool.name);
+                const mcpCapabilities = {
+                    kind: "mcp",
+                    mcpServers,
+                    mcpTools,
+                };
+                entry.cachedMcpCapabilities = mcpCapabilities;
+                // 同步保存到 lastMcpCapabilities，运行中再次发 skill_status（如 skill 目录变更）
+                // 时，会用它合并 MCP 信息，避免覆盖为空数组
+                entry.lastMcpCapabilities = mcpCapabilities;
+                // 更新 lastCombinedCapabilities 的 MCP 部分，保留已有的 skills（若 skill_status 已先到达）
+                entry.lastCombinedCapabilities = {
+                    kind: "combined",
+                    mcpServers,
+                    mcpTools,
+                    skills: entry.lastCombinedCapabilities?.skills ?? [],
+                    skillsDir: entry.lastCombinedCapabilities?.skillsDir,
+                    skillGroups: entry.lastCombinedCapabilities?.skillGroups ?? [],
+                };
+                adapterDebugLog(`[cap-diag] MCP capabilities cached: ${mcpServers.length} servers, ${mcpTools.length} tools`, {
+                    sessionId: event.sessionId,
+                    servers: mcpServers,
+                    toolNames: mcpTools.map(t => t.name),
+                });
+                // 兜底：如果 skill_status 事件在 CAPABILITIES_FALLBACK_MS 内未到达，
+                // 单独发出 MCP 能力清单，避免 skill_status 缺失导致"暂无能力清单"。
+                if (entry.capabilitiesFallbackTimer) {
+                    clearTimeout(entry.capabilitiesFallbackTimer);
+                }
+                entry.capabilitiesFallbackTimer = setTimeout(() => {
+                    const cached = entry.cachedMcpCapabilities;
+                    if (!cached)
+                        return;
+                    const fallbackCapabilities = {
+                        ...cached,
+                        skills: [],
+                        skillGroups: [],
+                    };
+                    this.emitProviderEvent(event, "runtime_capabilities", {
+                        capabilities: fallbackCapabilities,
+                        actionType: "runtime_capabilities",
+                        actionLabel: "运行时能力",
+                        actionDetail: JSON.stringify(fallbackCapabilities),
+                    });
+                    adapterDebugLog(`[cap-diag] MCP capabilities emitted via fallback (skill_status not received within ${CAPABILITIES_FALLBACK_MS}ms)`, {
+                        sessionId: event.sessionId,
+                        mcpServers: cached.mcpServers,
+                        mcpToolsCount: cached.mcpTools?.length ?? 0,
+                    });
+                    entry.cachedMcpCapabilities = undefined;
+                    entry.capabilitiesFallbackTimer = undefined;
+                }, CAPABILITIES_FALLBACK_MS);
                 return;
             }
             const server = typeof event.data.server === "string" ? event.data.server : "mcp";
@@ -843,6 +1020,8 @@ export class AcodeSdkAdapter extends EventEmitter {
                 ...(actionInput ? { actionInput } : {}),
                 ...(toolInput ? { toolInput } : {}),
                 ...(toolUseId ? { toolUseId, actionId: toolUseId } : {}),
+                // 传递 MCP 服务器名，供前端时间线展示工具来源
+                metadata: { mcpServer: server },
             };
             if (event.data.action === "tool_result") {
                 this.emitProviderEvent(event, "tool_use_end", {
@@ -856,11 +1035,12 @@ export class AcodeSdkAdapter extends EventEmitter {
                     ? "waiting_input"
                     : "thinking";
                 entry.adapterSession.status = status;
-                // tool_result 只传递 actionResult，通过 buildToolResultTimelineActionInfo 加工，
-                // status-change 中分情况处理 actionInput：
-                // - thinking 时传 undefined，清理 old action 避免前端残留之前的 tool 状态
-                // - waiting_input 时传 eventData（含 actionInput），保留输入参数供前端展示
-                this.emit("status-change", event.sessionId, status, status === "thinking" ? undefined : eventData);
+                // ★ 修复重复时间线条目：idle 类型（poll_message）的 tool_use_end status-change
+                //   始终传 undefined，避免 terminal.ts 的 restoredActionInfo 恢复出 actionType+actionLabel
+                //   导致 dashboard 创建第二个"调用MCP"条目。tool_use_start 的 status-change 已创建条目。
+                //   非 idle 类型仍按原逻辑传 eventData（waiting_input 时）以保留输入参数展示。
+                const isIdleTool = actionInfo.actionType === "idle";
+                this.emit("status-change", event.sessionId, status, isIdleTool ? undefined : (status === "thinking" ? undefined : eventData));
                 return;
             }
             const status = actionInfo.actionType === "idle" ? "waiting_input" : "tool_using";
@@ -869,6 +1049,89 @@ export class AcodeSdkAdapter extends EventEmitter {
             this.emit("status-change", event.sessionId, status, eventData);
             return;
         }
+        if (event.type === "skill_status") {
+            // skill_status 事件可能在两个时机到达：
+            //   1. ACode runtime 启动时（包含已加载的 Skill 列表）
+            //   2. 运行中 skills 目录变更触发重扫后（动态感知新 skill）
+            // 合并 MCP 能力清单后，作为单个 runtime_capabilities 事件发出，
+            // 避免与 mcp_status 的 runtime_capabilities 事件并发 HTTP POST 导致其中一个丢失。
+            // 启动时用 cachedMcpCapabilities（等待合并）；运行中 cachedMcp 已清理，
+            // 回退到 lastMcpCapabilities（保留最近一次 MCP 信息，避免覆盖为空数组）。
+            const skillsRaw = Array.isArray(event.data.skills)
+                ? event.data.skills
+                : [];
+            const skills = skillsRaw
+                .map((skill) => ({
+                name: String(skill.name ?? ""),
+                description: typeof skill.description === "string"
+                    ? skill.description
+                    : undefined,
+                directory: typeof skill.directory === "string"
+                    ? skill.directory
+                    : undefined,
+            }))
+                .filter((skill) => skill.name);
+            const skillsDir = typeof event.data.skillsDir === "string"
+                ? event.data.skillsDir
+                : undefined;
+            // 按目录分组的 skills（含空目录节点），供前端按目录展示
+            const skillGroupsRaw = Array.isArray(event.data.skillGroups)
+                ? event.data.skillGroups
+                : [];
+            const skillGroups = skillGroupsRaw
+                .map((group) => {
+                const groupSkills = Array.isArray(group.skills)
+                    ? group.skills
+                    : [];
+                return {
+                    dir: typeof group.dir === "string" ? group.dir : "",
+                    exists: group.exists === true,
+                    skills: groupSkills
+                        .map((skill) => ({
+                        name: String(skill.name ?? ""),
+                        description: typeof skill.description === "string"
+                            ? skill.description
+                            : undefined,
+                        directory: typeof skill.directory === "string"
+                            ? skill.directory
+                            : undefined,
+                    }))
+                        .filter((skill) => skill.name),
+                };
+            })
+                .filter((group) => group.dir);
+            // 优先用启动缓存（cachedMcp），运行中回退到 lastMcpCapabilities
+            const mcpSource = entry.cachedMcpCapabilities ?? entry.lastMcpCapabilities;
+            const isStartupMerge = entry.cachedMcpCapabilities !== undefined;
+            const mergedCapabilities = {
+                kind: "combined",
+                mcpServers: mcpSource?.mcpServers ?? [],
+                mcpTools: mcpSource?.mcpTools ?? [],
+                skills,
+                skillsDir,
+                skillGroups,
+            };
+            this.emitProviderEvent(event, "runtime_capabilities", {
+                capabilities: mergedCapabilities,
+                actionType: "runtime_capabilities",
+                actionLabel: "运行时能力",
+                actionDetail: JSON.stringify(mergedCapabilities),
+            });
+            // 更新 lastCombinedCapabilities，作为主动查询的单一数据源
+            entry.lastCombinedCapabilities = mergedCapabilities;
+            adapterDebugLog(`[cap-diag] Combined capabilities emitted ${isStartupMerge ? "(startup merge)" : "(runtime refresh)"}: ${(mcpSource?.mcpTools ?? []).length} MCP tools, ${skills.length} skills`, {
+                sessionId: event.sessionId,
+                mcpServers: mcpSource?.mcpServers ?? [],
+                skillsDir,
+            });
+            // 清理启动缓存与兜底定时器（仅启动合并路径需要；运行中刷新时 cachedMcp 已是 undefined）
+            if (entry.capabilitiesFallbackTimer) {
+                clearTimeout(entry.capabilitiesFallbackTimer);
+                entry.capabilitiesFallbackTimer = undefined;
+            }
+            entry.cachedMcpCapabilities = undefined;
+            return;
+        }
         if (event.type === "session_started") {
             const estimatedTokens = toEstimatedContextTokens(event.data);
             if (estimatedTokens > 0) {
@@ -898,6 +1161,90 @@ export class AcodeSdkAdapter extends EventEmitter {
             });
             return;
         }
+        if (event.type === "context_compaction") {
+            const data = event.data;
+            const action = data.action;
+            const isStart = action === "start";
+            const isEnd = action === "end";
+            const isPhase = action === "phase";
+            // parentId 用于将子事件（phase）关联到父压缩事件
+            const parentId = data.parentId;
+            // compactionId 作为父事件的 actionId，子事件通过 parentId 引用它
+            const compactionId = data.compactionId;
+            let actionLabel;
+            let actionDetail;
+            if (isStart) {
+                const sizeKB = String(data.sizeKB ?? data.sizeBeforeKB ?? "?");
+                const msgCount = String(data.messageCount ?? data.messageCountBefore ?? "?");
+                const actualInput = data.actualInputTokens ? `input=${data.actualInputTokens}` : "";
+                const actualOutput = data.actualOutputTokens ? `output=${data.actualOutputTokens}` : "";
+                const trigger = data.trigger ? `, 触发: ${data.trigger}` : "";
+                actionLabel = "上下文压缩开始";
+                actionDetail = `压缩前: ${sizeKB}KB, 消息: ${msgCount}条` +
+                    (actualInput ? `, 实际 tokens: ${actualInput} ${actualOutput}` : "") + trigger;
+            }
+            else if (isPhase) {
+                // 子事件（阶段事件）：使用 runtime 传入的 actionLabel 和 actionDetail
+                actionLabel = String(data.phaseLabel ?? "压缩阶段");
+                actionDetail = String(data.phaseDetail ?? "");
+            }
+            else {
+                // action === "end" —— 作为压缩完成子事件，嵌套在父事件下
+                const sizeBefore = String(data.sizeBeforeKB ?? "?");
+                const sizeAfter = String(data.sizeAfterKB ?? "?");
+                const freedKB = String(data.freedKB ?? "?");
+                const strategy = String(data.strategy ?? "?");
+                const pruned = Number(data.prunedToolMessages ?? 0);
+                const summarized = Number(data.summarizedMessages ?? 0);
+                actionLabel = "压缩完成";
+                actionDetail = `释放: ${freedKB}KB, ${sizeBefore}KB → ${sizeAfter}KB, 策略: ${strategy}` +
+                    (pruned ? `, 裁剪工具: ${pruned}条` : "") +
+                    (summarized ? `, 摘要化: ${summarized}条` : "");
+            }
+            // ★ 更新 adapter 内部状态为 compacting，使前端 agent 卡片显示压缩中
+            //    子事件（phase/end）不重复更新状态，仅推送到时间线
+            if (isStart) {
+                entry.adapterSession.status = "compacting";
+            }
+            const actionInfo = {
+                actionType: "context_compaction",
+                actionLabel,
+                actionDetail,
+            };
+            // ★ 事件层级：start 为父事件（root），phase 和 end 为子事件（nested）
+            //    - 父事件：actionId = compactionId
+            //    - 子事件：parentId = compactionId, actionId 唯一（避免前端 seenActionIds 去重冲突）
+            if (isStart && compactionId) {
+                actionInfo.actionId = compactionId;
+            }
+            else if ((isPhase || isEnd) && compactionId) {
+                actionInfo.parentId = compactionId;
+                if (isPhase) {
+                    const phase = String(data.phase ?? "unknown");
+                    actionInfo.actionId = `${compactionId}-phase-${phase}`;
+                }
+                else {
+                    // end 事件使用独立 actionId，避免与 start 的 compactionId 重复
+                    actionInfo.actionId = `${compactionId}-end`;
+                }
+            }
+            // 兼容旧路径：runtime 可能通过 parentId 字段传入
+            if (isPhase && parentId && !actionInfo.parentId) {
+                actionInfo.parentId = parentId;
+            }
+            // ★ 压缩结束时重置 totalUsage.inputTokens，使面板显示压缩后的真实上下文大小。
+            //    将 usage 合并到 end 事件的 actionInfo 中，避免额外的无 actionInfo status-change
+            //    触发前端 handleDeltaStatusEvent 创建无 actionId 的占位事件（会导致扁平化渲染）。
+            if (isEnd) {
+                entry.adapterSession.totalUsage.inputTokens = 0;
+                actionInfo.usage = entry.adapterSession.totalUsage;
+            }
+            this.emitProviderEvent(event, "context_compaction", actionInfo);
+            // ★ 与其他事件（tool_use_start/turn_complete 等）一致，
+            //    通过 status-change 事件将压缩状态推送到面板时间线。
+            this.emit("status-change", event.sessionId, "compacting", actionInfo);
+            return;
+        }
         this.emitProviderEvent(event, "thinking", {
             text: JSON.stringify(event.data),
         });
@@ -1057,10 +1404,34 @@ export class AcodeSdkAdapter extends EventEmitter {
             data: { text: error instanceof Error ? error.message : String(error) },
         });
     }
+    /**
+     * 从会话消息中估算 AI 输出 token 数（字符数 / 4 粗略估算）。
+     * 注意：该估算对 CJK 文本偏高（实际每字约 1-2 tokens），
+     * 对纯 ASCII 文本偏低（约 3-5 字符/token），仅供面板展示实时趋势使用，
+     * 不应用于精确计费或配额判定。精确值以 turn_complete 事件中的 usage 为准。
+     */
+    estimateOutputTokensFromMessages(messages) {
+        const assistantText = messages
+            .filter((m) => m.role === "assistant")
+            .map((m) => m.content)
+            .join("");
+        return Math.max(0, Math.round(assistantText.length / 4));
+    }
     recoverTurnFailure(sessionId, entry) {
         if (this.isTerminalStatus(entry.adapterSession.status)) {
             return;
         }
+        // ★ 修复：超时恢复前强制 emit turn_complete，计入已有的 output tokens，
+        //   否则面板上 output_tokens 永远是 0（turn_complete 从未发射）。
+        //   使用消息历史中的 assistant 文本粗略估算 output tokens。
+        const estimatedOutput = this.estimateOutputTokensFromMessages(entry.adapterSession.messages);
+        if (estimatedOutput > 0 && entry.adapterSession.totalUsage.outputTokens < estimatedOutput) {
+            const delta = estimatedOutput - entry.adapterSession.totalUsage.outputTokens;
+            entry.adapterSession.totalUsage.outputTokens += delta;
+            adapterDebugLog(`[ACode] recoverTurnFailure: 强制计入 ${delta} output tokens ` +
+                `(totalUsage now: input=${entry.adapterSession.totalUsage.inputTokens}, ` +
+                `output=${entry.adapterSession.totalUsage.outputTokens})`);
+        }
         // ★ 修复：检测 idle 命令是否包含 poll_message，在 waiting_input 状态变更中携带 idle 动作信息
         const idleCommands = entry.idleCommands?.idleInputCommand;
         const willResumePolling = Boolean(idleCommands && isMessagePollingIdleCommand(idleCommands));
@@ -1072,13 +1443,19 @@ export class AcodeSdkAdapter extends EventEmitter {
         if (entry.autoPollTimer || entry.failedTurnRecoveryScheduled) {
             if (entry.adapterSession.status !== "waiting_input") {
                 entry.adapterSession.status = "waiting_input";
-                this.emit("status-change", sessionId, "waiting_input", idleActionInfo);
+                this.emit("status-change", sessionId, "waiting_input", {
+                    usage: entry.adapterSession.totalUsage,
+                    ...idleActionInfo,
+                });
             }
             return;
         }
         this.cancelScheduledAutoPoll(entry);
         entry.adapterSession.status = "waiting_input";
-        this.emit("status-change", sessionId, "waiting_input", idleActionInfo);
+        this.emit("status-change", sessionId, "waiting_input", {
+            usage: entry.adapterSession.totalUsage,
+            ...idleActionInfo,
+        });
         entry.failedTurnRecoveryScheduled = true;
         entry.autoPollTimer = setTimeout(() => {
             const currentEntry = this.sessions.get(sessionId);
@@ -1112,20 +1489,20 @@ export class AcodeSdkAdapter extends EventEmitter {
      * look permanently stuck. Recover to waiting_input and arm the listening loop.
      */
     recoverResolvedTurnWithoutTerminalEvent(sessionId) {
-        console.log(`[ACode] ▶️ recoverResolvedTurnWithoutTerminalEvent called for session ${sessionId}`);
+        adapterDebugLog(`[ACode] ▶️ recoverResolvedTurnWithoutTerminalEvent called for session ${sessionId}`);
         const entry = this.sessions.get(sessionId);
         if (!entry || this.isTerminalStatus(entry.adapterSession.status)) {
-            console.log(`[ACode]  Skipping recovery: entry=${!!entry}, isTerminal=${entry ? this.isTerminalStatus(entry.adapterSession.status) : 'N/A'}`);
+            adapterDebugLog(`[ACode]  Skipping recovery: entry=${!!entry}, isTerminal=${entry ? this.isTerminalStatus(entry.adapterSession.status) : 'N/A'}`);
             return;
         }
-        console.log(`[ACode]  Current status: ${entry.adapterSession.status}`);
+        adapterDebugLog(`[ACode]  Current status: ${entry.adapterSession.status}`);
         if (entry.adapterSession.status !== "thinking" &&
             entry.adapterSession.status !== "tool_using") {
-            console.log(`[ACode]  Skipping recovery: status is ${entry.adapterSession.status} (not thinking/tool_using)`);
+            adapterDebugLog(`[ACode]  Skipping recovery: status is ${entry.adapterSession.status} (not thinking/tool_using)`);
             return;
         }
-        console.log(`[ACode] ⚠️ Detected stuck state: ${entry.adapterSession.status} after submit resolved!`);
-        console.log(`[ACode]  Recovering to waiting_input...`);
+        adapterDebugLog(`[ACode] ⚠️ Detected stuck state: ${entry.adapterSession.status} after submit resolved!`);
+        adapterDebugLog(`[ACode]  Recovering to waiting_input...`);
         entry.adapterSession.status = "waiting_input";
         // ★ 修复：检测 idle 命令是否包含 poll_message，在 waiting_input 状态变更中携带 idle 动作信息
         const idleCommands = entry.idleCommands?.idleInputCommand;
@@ -1136,10 +1513,10 @@ export class AcodeSdkAdapter extends EventEmitter {
             actionDetail: 'aws-mcp/poll_message',
         } : undefined;
         this.emit("status-change", sessionId, "waiting_input", idleActionInfo);
-        console.log(`[ACode] ✅ Recovery complete, status now: ${entry.adapterSession.status}`);
-        console.log(`[ACode] ▶️ Arming idle loop or auto-poll...`);
+        adapterDebugLog(`[ACode] ✅ Recovery complete, status now: ${entry.adapterSession.status}`);
+        adapterDebugLog(`[ACode] ▶️ Arming idle loop or auto-poll...`);
         this.armIdleLoopOrAutoPoll(sessionId);
-        console.log(`[ACode] ✅ Idle loop armed, recovery process complete`);
+        adapterDebugLog(`[ACode] ✅ Idle loop armed, recovery process complete`);
     }
     /**
      * 启动 submit 超时检测（治本修复：防止状态永久卡住）