aws-runtime-bridge 1.9.33 → 1.9.41

package/dist/adapter/AcodeSdkAdapter.js

@@ -19,16 +19,34 @@ 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.",
     "Do not answer in plain text before calling aws-mcp__poll_message.",
     "After handling any received work, reply through the appropriate aws-mcp messaging tool, then continue listening again.",
 ].join(" ");
+// 异步看门狗轮询间隔：每 5s 检查一次运行时状态
+const ACODE_WATCHDOG_POLL_INTERVAL_MS = 5_000;
+// 数据流看门狗超时：ai_request 发出后，若 40s 内没有收到任何流式数据（assistant_delta/thinking_delta），
+// 触发 recoverTurnFailure 强制恢复。覆盖 provider requestTimeoutMs 配置不当或流挂死等场景。
+// 仅在 thinking/tool_using 状态下累计计时，waiting_input 状态下不计时（agent 正在有意等待）。
+const ACODE_DATA_FLOW_STREAM_WATCHDOG_MS = 40_000;
 const ACODE_AUTO_POLL_DELAY_MS = 250;
 // Backoff used when a polling-driven turn fails (e.g., 60s MCP tool timeout,
 // model 5xx, provider unreachable). Larger than ACODE_AUTO_POLL_DELAY_MS to
@@ -37,6 +55,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());
@@ -101,6 +122,25 @@ function lookupModelContextLimit(modelName) {
         return MODEL_CONTEXT_LIMITS[matches[0]].contextLimit;
     return DEFAULT_CONTEXT_LIMIT;
 }
+const DEFAULT_MAX_OUTPUT = 4_096;
+/**
+ * Look up model max output token limit by model name.
+ * Mirrors lookupModelContextLimit: exact match first, then longest-prefix match.
+ * Used to compute the compaction point (contextLimit - maxOutput) on the frontend.
+ */
+function lookupModelMaxOutput(modelName) {
+    if (!modelName)
+        return DEFAULT_MAX_OUTPUT;
+    const key = modelName.toLowerCase().trim();
+    if (MODEL_CONTEXT_LIMITS[key])
+        return MODEL_CONTEXT_LIMITS[key].maxOutput;
+    const matches = Object.keys(MODEL_CONTEXT_LIMITS)
+        .filter((prefix) => key.startsWith(prefix))
+        .sort((a, b) => b.length - a.length);
+    if (matches.length > 0)
+        return MODEL_CONTEXT_LIMITS[matches[0]].maxOutput;
+    return DEFAULT_MAX_OUTPUT;
+}
 function toUsage(value) {
     if (!value || typeof value !== "object") {
         return undefined;
@@ -209,12 +249,13 @@ export class AcodeSdkAdapter extends EventEmitter {
         const resolvedModel = resolved.model;
         // priority: acode.json top-level contextLimit > model lookup table > 128K default
         const contextLimit = configContextLimit ?? lookupModelContextLimit(resolvedModel);
+        const maxOutput = lookupModelMaxOutput(resolvedModel);
         const session = {
             sessionId,
             status: "starting",
             messages: [],
             createdAt: new Date().toISOString(),
-            totalUsage: { inputTokens: 0, outputTokens: 0, contextLimit },
+            totalUsage: { inputTokens: 0, outputTokens: 0, contextLimit, maxOutput },
         };
         this.sessions.set(sessionId, {
             adapterSession: session,
@@ -249,20 +290,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 +320,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();
     }
@@ -318,6 +387,7 @@ export class AcodeSdkAdapter extends EventEmitter {
         entry.autoPollActive = false;
         entry.autoPollObservedPollingTool = false;
         entry.autoPollObservedAssistantText = false;
+        entry.autoPollObservedAnyTool = false;
         entry.stopAutoPollAfterCurrentTurn = false;
         entry.idlePollLoop?.stop();
         if (!entry.runtime.resetContext) {
@@ -325,7 +395,17 @@ export class AcodeSdkAdapter extends EventEmitter {
         }
         await entry.runtime.resetContext();
         entry.adapterSession.messages = [];
-        entry.adapterSession.totalUsage = { inputTokens: 0, outputTokens: 0, contextLimit: entry.adapterSession.totalUsage.contextLimit };
+        // ★ 重置 token 计数但保留压缩配置（contextLimit/maxOutput/inputLimit/compactionThreshold），
+        //   这些值在 session 期间不变，避免重置后前端压缩点竖线消失。
+        const preservedUsage = entry.adapterSession.totalUsage;
+        entry.adapterSession.totalUsage = {
+            inputTokens: 0,
+            outputTokens: 0,
+            contextLimit: preservedUsage.contextLimit,
+            maxOutput: preservedUsage.maxOutput,
+            inputLimit: preservedUsage.inputLimit,
+            compactionThreshold: preservedUsage.compactionThreshold,
+        };
         entry.adapterSession.status = "waiting_input";
         this.emit("status-change", sessionId, "waiting_input", {
             usage: entry.adapterSession.totalUsage,
@@ -344,6 +424,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 +445,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 +655,10 @@ export class AcodeSdkAdapter extends EventEmitter {
                 ? config.memory
                 : undefined,
             env: config.envOverrides,
+            subAgentManager,
+            ...(config.subAgentModel ? { subAgentModel: config.subAgentModel } : {}),
+            ...(config.subAgentEffort ? { subAgentEffort: config.subAgentEffort } : {}),
+            ...(config.instanceAiConfig?.effort ? { effort: config.instanceAiConfig.effort } : {}),
         });
         const debugLogger = getInstanceAiConfigDebugLogger();
         void debugLogger.log({
@@ -644,11 +755,15 @@ export class AcodeSdkAdapter extends EventEmitter {
                 content: text,
                 timestamp: event.timestamp,
             });
+            // 收到流式数据，重置看门狗
+            this.resetDataFlowWatchdog(event.sessionId, entry);
             this.emitProviderEvent(event, "text_delta", { text });
             return;
         }
         if (event.type === "thinking_delta") {
             const text = typeof event.data.text === "string" ? event.data.text : "";
+            // 收到流式思考过程数据，重置看门狗
+            this.resetDataFlowWatchdog(event.sessionId, entry);
             this.emitProviderEvent(event, "thinking", { text });
             return;
         }
@@ -671,13 +786,61 @@ export class AcodeSdkAdapter extends EventEmitter {
         }
         if (event.type === "ai_request") {
             const estimatedTokens = toEstimatedContextTokens(event.data);
+            let displayUsage;
             if (estimatedTokens > 0) {
-                entry.adapterSession.totalUsage.inputTokens = estimatedTokens;
-                entry.adapterSession.totalUsage.outputTokens = 0;
-                this.emit("status-change", event.sessionId, entry.adapterSession.status, {
-                    usage: entry.adapterSession.totalUsage,
-                });
+                // ★ 限制估算值的增长幅度，防止 JSON 结构开销导致的虚高跳变。
+                //    estimateTokensFromText(requestBody) 基于 pretty-printed JSON 字符串长度 / 3 估算，
+                //    JSON 结构开销（键名、引号、缩进、转义）导致估算值系统性虚高 3-5x+，
+                //    在 turn_complete 到达前会造成面板显示从 xx k 突跳到几 M 再跳回。
+                //    正常单轮上下文增长 < 50%，cap 1.5x 足够覆盖增长同时防止跳变。
+                //    turn_complete 携带 provider 实际 prompt_tokens 时始终覆盖此估算值。
+                //    压缩后 context_compaction end 将 inputTokens 重置为 0，
+                //    此处 0 值直接使用估算值（压缩后对话更小，估算值也相应更小）。
+                const currentInput = entry.adapterSession.totalUsage.inputTokens;
+                if (currentInput > 0) {
+                    entry.adapterSession.totalUsage.inputTokens = Math.min(estimatedTokens, Math.floor(currentInput * 1.5));
+                }
+                else {
+                    entry.adapterSession.totalUsage.inputTokens = estimatedTokens;
+                }
+                // ★ outputTokens 保持上一轮 turn_complete 写入的单轮值（覆盖式语义），
+                //    不再用 estimateOutputTokensFromMessages（累计估算）通过 Math.max 撑高。
+                //    该累计估算会把历史所有 assistant 输出叠加，与 prompt_tokens(已含历史) 重复，
+                //    导致显示 total 系统性虚高。结构与 runtime 的 actualUsed 一致：
+                //    input(请求体估算) + output(当前轮 completion)。
+                displayUsage = { ...entry.adapterSession.totalUsage };
+            }
+            // ★ 修复 BUG：状态切换与 status-change 发射必须移到 if (estimatedTokens > 0) 块外。
+            //    原实现仅在 estimatedTokens > 0 时才切换状态并发射 status-change，
+            //    导致 estimatedTokens === 0（如 ai_request 无 requestBody 或无法解析）时：
+            //    1. adapter 内部 status 保持 waiting_input（未切换为 thinking）
+            //    2. 不发射 status-change 事件，但 emitProviderEvent 照常发射
+            //    3. terminal.ts 通过 provider event 路径发送 thinking + ai_request 到前端
+            //    4. recoverResolvedTurnWithoutTerminalEvent 因 status 是 waiting_input 而跳过恢复
+            //    5. 残留 actionType:"ai_request" 永远无法清理，前端永久显示 "AI请求: 模型: xxx"
+            // ★ 压缩完成后 adapterSession.status 仍为 "compacting"，此处恢复为 "thinking"，
+            //    使 status-change 走普通路径（而非 compacting 串行队列），
+            //    并带上 actionType 避免 restoredActionInfo 覆盖 usage。
+            if (entry.adapterSession.status === "compacting") {
+                entry.adapterSession.status = "thinking";
+            }
+            // ★ 修复：ai_request 表示 AI 正在请求模型，无论 keepWaitingStatus 如何，
+            //    状态都应切换为 "thinking"。否则 keepWaitingStatus=true 时 status 保持
+            //    "waiting_input"，导致 submit 完成后跳过 recoverResolvedTurnWithoutTerminalEvent，
+            //    残留 actionType:"ai_request" 永远无法清理，前端永久显示 "AI请求: 模型: xxx"。
+            if (entry.adapterSession.status === "waiting_input") {
+                entry.adapterSession.status = "thinking";
+            }
+            const aiRequestActionInfo = {
+                actionType: "ai_request",
+                actionLabel: "AI请求",
+            };
+            if (displayUsage) {
+                aiRequestActionInfo.usage = displayUsage;
             }
+            this.emit("status-change", event.sessionId, entry.adapterSession.status, aiRequestActionInfo);
+            // 启动数据流看门狗：ai_request 发出后开始监控流式数据返回
+            this.startDataFlowWatchdog(event.sessionId, entry);
             this.emitProviderEvent(event, "ai_request", {
                 model: typeof event.data.model === "string" ? event.data.model : undefined,
                 endpoint: typeof event.data.endpoint === "string"
@@ -711,12 +874,29 @@ export class AcodeSdkAdapter extends EventEmitter {
         if (event.type === "turn_complete") {
             const usage = toUsage(event.data.usage);
             if (usage) {
-                entry.adapterSession.totalUsage.inputTokens += usage.inputTokens;
-                entry.adapterSession.totalUsage.outputTokens += usage.outputTokens;
+                // ★ 同时更新 inputTokens 和 outputTokens（均覆盖式赋值）。
+                //    provider 返回的 prompt_tokens 是当前上下文大小的最准确度量，
+                //    优于 ai_request 的 requestBody/3 估算。直接赋值（非累加），
+                //    因为 prompt_tokens 代表本次请求时 provider 看到的完整上下文大小。
+                //    outputTokens 也采用覆盖式（= 当前轮 completion_tokens），与 runtime 的
+                //    state.accumulatedOutputTokens（runtime.ts，覆盖式）同构。
+                //    之前 outputTokens 用 += 累加，导致显示的 total = prompt_tokens(已含历史output)
+                //    + Σcompletion 把历史 output 重复计算，面板系统性虚高，先于 runtime 达到压缩阈值。
+                // ★ 过滤 fallback usage：当 provider 不返回 usage 时，runtime 会用
+                //    { inputTokens: trimmed.length, outputTokens: text.length } 作为 fallback。
+                //    trimmed.length 只是用户消息长度（通常 < 1000），远小于实际上下文，
+                //    会把面板从几十 k 砸到几百，造成显示突降。检测方式：fallback inputTokens
+                //    远小于当前值（< 20%），说明不是真实 provider 数据，跳过更新。
+                const currentInput = entry.adapterSession.totalUsage.inputTokens;
+                const isFallbackUsage = currentInput > 0 && usage.inputTokens < Math.floor(currentInput * 0.2);
+                if (!isFallbackUsage) {
+                    entry.adapterSession.totalUsage.inputTokens = usage.inputTokens;
+                    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,10 +912,25 @@ 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.cancelDataFlowWatchdog(entry);
+                this.recoverTurnFailure(event.sessionId, entry);
+                return;
+            }
+            // ★ 修复竞态：看门狗触发 abort() 后，runtime 在 catch 块发射
+            //   turn_complete { aborted: true }（而非 failed: true）。
+            //   原逻辑走正常完成路径，立即 armIdleLoopOrAutoPoll（250ms 重臂），
+            //   导致新 submit 在前一轮 executeSubmit 仍占用 submitQueue 时就排队，
+            //   加剧竞态。改为走 R2 恢复路径（2s 退避），给前一轮更多时间完成。
+            if (event.data.aborted === true && entry.autoPollActive) {
+                adapterDebugLog(`[ACode] Recovering from aborted turn_complete (session: ${event.sessionId}), ` +
+                    `using R2 2s backoff instead of immediate rearm`);
+                this.cancelDataFlowWatchdog(entry);
                 this.recoverTurnFailure(event.sessionId, entry);
                 return;
             }
+            // turn 正常完成，取消数据流看门狗
+            this.cancelDataFlowWatchdog(entry);
             this.emitProviderEvent(event, "turn_complete", {
                 usage: entry.adapterSession.totalUsage,
                 responseBody: typeof event.data.responseBody === "string"
@@ -749,18 +944,20 @@ 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) {
+                !entry.autoPollObservedPollingTool &&
+                !entry.autoPollObservedAnyTool) {
                 entry.stopAutoPollAfterCurrentTurn = true;
-                console.warn(`[${this.displayName}] Auto-poll turn produced assistant text without calling poll_message; stopping auto-poll rearm for session ${event.sessionId}`);
+                console.warn(`[${this.displayName}] Auto-poll turn produced assistant text without calling any tool; stopping auto-poll rearm for session ${event.sessionId}`);
                 return;
             }
             this.armIdleLoopOrAutoPoll(event.sessionId);
             return;
         }
         if (event.type === "session_complete") {
+            this.cancelDataFlowWatchdog(entry);
             this.cancelScheduledAutoPoll(entry);
             entry.failedTurnRecoveryScheduled = false;
             entry.idlePollLoop?.stop();
@@ -771,7 +968,46 @@ export class AcodeSdkAdapter extends EventEmitter {
             this.emit("status-change", event.sessionId, "completed");
             return;
         }
+        if (event.type === "question_request") {
+            // ask_user_question 工具被调用：runtime 在 execute() 中阻塞等待答案。
+            // 取消数据流看门狗（用户思考/回答时间不计入 40s 超时），
+            // 等用户回答后 LLM 重新输出时 assistant_delta/thinking_delta 会重新启动看门狗。
+            this.cancelDataFlowWatchdog(entry);
+            // 取消 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,
+                toolCallId: toolCallId || undefined,
+                questions,
+            });
+            return;
+        }
         if (event.type === "error") {
+            // nonFatal=true 表示工具执行失败等非致命错误（Agent 会继续处理），
+            // 仅推送事件到时间线，不变更运行态为 "error"，避免面板启动/停止按钮异常。
+            if (event.data.nonFatal) {
+                // ★ 修复：重试期间（每次 fetch failed 后退避）无流式数据到达，
+                //   看门狗仍以"上次 delta + 40s"倒计时，可能在重试周期内误触发 40s 超时。
+                //   重置数据流计时基准，让看门狗从重试时刻重新计时。
+                this.resetDataFlowWatchdog(event.sessionId, entry);
+                this.emitProviderEvent(event, "error", {
+                    text: String(event.data.message || "ACode runtime error"),
+                });
+                return;
+            }
+            this.cancelDataFlowWatchdog(entry);
             entry.adapterSession.status = "error";
             this.emitProviderEvent(event, "error", {
                 text: String(event.data.message || "ACode runtime error"),
@@ -812,8 +1048,78 @@ 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 eventAction = String(event.data.action ?? "");
+            adapterDebugLog(`[ACode] 📡 mcp_status event: action=${eventAction}, ` +
+                `server=${typeof event.data.server === "string" ? event.data.server : "?"}, ` +
+                `tool=${typeof event.data.tool === "string" ? event.data.tool : "?"}, ` +
+                `toolUseId=${typeof event.data.toolUseId === "string" ? event.data.toolUseId.slice(0, 16) + "…" : "none"}, ` +
+                `failed=${event.data.failed === true}, ` +
+                `session=${event.sessionId}, status=${entry.adapterSession.status}`);
             const server = typeof event.data.server === "string" ? event.data.server : "mcp";
             const tool = typeof event.data.tool === "string" ? event.data.tool : "";
             const toolName = server && tool ? `${server}__${tool}` : tool || server;
@@ -823,8 +1129,13 @@ export class AcodeSdkAdapter extends EventEmitter {
                 ? event.data.arguments
                 : undefined;
             const actionInfo = getToolActionInfo(toolName, toolInput);
-            if (entry.autoPollActive && actionInfo.actionType === "idle") {
-                entry.autoPollObservedPollingTool = true;
+            if (entry.autoPollActive) {
+                // ★ 修复永久卡死：任何工具调用（包括工作工具）都标记为已观察，
+                //   避免 turn_complete 时误判为"只输出文本不调用工具"而停止 auto-poll。
+                entry.autoPollObservedAnyTool = true;
+                if (actionInfo.actionType === "idle") {
+                    entry.autoPollObservedPollingTool = true;
+                }
             }
             const actionDetail = isAcodeSemanticToolAction(actionInfo.actionType)
                 ? actionInfo.actionDetail ||
@@ -843,6 +1154,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,24 +1169,154 @@ 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);
+                // ★ 修复 BUG（时间线永久卡在"编辑文件"）：工具执行完成时取消数据流看门狗。
+                //   原实现中 tool_use_start/tool_use_end 既不取消也不重置看门狗，
+                //   导致工具执行期间看门狗仍以"上次 delta + 40s"倒计时，
+                //   若工具执行时间接近或超过 40s（如大文件编辑、Windows 杀毒扫描），
+                //   看门狗会在 tool_using 状态误触发，abort 无效（内置工具不可中断），
+                //   recoverTurnFailure 不补发 tool_use_end → 时间线永久卡在"编辑文件"。
+                this.cancelDataFlowWatchdog(entry);
+                entry.pendingToolEventData = undefined;
+                // ★ 修复重复时间线条目：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";
             entry.adapterSession.status = status;
+            // ★ 修复 BUG（时间线永久卡在"编辑文件"）：工具开始执行时重置数据流看门狗。
+            //   工具执行（如 edit_file）可能耗时较长（大文件、Windows I/O、杀毒扫描），
+            //   期间无流式 delta 数据返回。若不重置看门狗，40s 超时后会在 tool_using 状态误触发，
+            //   导致 recoverTurnFailure 不补发 tool_use_end，时间线永久卡住。
+            //   重置看门狗让计时从工具开始时重新计算，给工具执行留出充足时间。
+            if (status === "tool_using") {
+                this.resetDataFlowWatchdog(event.sessionId, entry);
+                // 缓存当前工具事件数据，供 recoverTurnFailure 补发 tool_use_end 使用
+                entry.pendingToolEventData = { ...eventData };
+            }
             this.emitProviderEvent(event, "tool_use_start", eventData);
             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);
+            // ★ 用 runtime emit 的实际压缩配置覆盖 totalUsage。
+            //   runtime 的 contextLimit/maxOutput/inputLimit 来自 resolveProviderConfig（读 provider.default.* 三级），
+            //   是后端实际触发压缩用的值；adapter 启动时从顶层+查表解析的值仅作初始占位，必须被覆盖。
+            //   compactionThreshold 是后端算好的实际阈值，前端直接显示此值，不再自算。
+            const runtimeContextLimit = toFiniteTokenCount(event.data.contextLimit) || undefined;
+            const runtimeMaxOutput = toFiniteTokenCount(event.data.maxOutput) || undefined;
+            const runtimeInputLimit = toFiniteTokenCount(event.data.inputLimit) || undefined;
+            const runtimeCompactionThreshold = toFiniteTokenCount(event.data.compactionThreshold) || undefined;
+            let usageChanged = false;
             if (estimatedTokens > 0) {
                 entry.adapterSession.totalUsage.inputTokens = estimatedTokens;
                 entry.adapterSession.totalUsage.outputTokens = 0;
+                usageChanged = true;
+            }
+            if (runtimeContextLimit !== undefined) {
+                entry.adapterSession.totalUsage.contextLimit = runtimeContextLimit;
+                usageChanged = true;
+            }
+            if (runtimeMaxOutput !== undefined) {
+                entry.adapterSession.totalUsage.maxOutput = runtimeMaxOutput;
+                usageChanged = true;
+            }
+            if (runtimeInputLimit !== undefined) {
+                entry.adapterSession.totalUsage.inputLimit = runtimeInputLimit;
+                usageChanged = true;
+            }
+            if (runtimeCompactionThreshold !== undefined) {
+                entry.adapterSession.totalUsage.compactionThreshold = runtimeCompactionThreshold;
+                usageChanged = true;
+            }
+            if (usageChanged) {
                 this.emit("status-change", event.sessionId, entry.adapterSession.status, {
                     usage: entry.adapterSession.totalUsage,
                 });
@@ -898,6 +1341,113 @@ 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 estimatedTokens = data.estimatedTokens;
+                const actualInput = data.actualInputTokens ? `input=${data.actualInputTokens}` : "";
+                const actualOutput = data.actualOutputTokens ? `output=${data.actualOutputTokens}` : "";
+                const trigger = data.trigger ? `, 触发: ${data.trigger}` : "";
+                actionLabel = "上下文压缩开始";
+                if (estimatedTokens !== undefined) {
+                    actionDetail = `压缩前: ~${estimatedTokens} tokens, 消息: ${msgCount}条` +
+                        (actualInput ? `, 实际 tokens: ${actualInput} ${actualOutput}` : "") + trigger;
+                }
+                else {
+                    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 tokensBefore = data.tokensBefore;
+                const tokensAfter = data.tokensAfter;
+                const freedTokensNum = data.freedTokens;
+                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 = "压缩完成";
+                if (tokensBefore !== undefined && tokensAfter !== undefined) {
+                    const diff = freedTokensNum ?? (tokensBefore - tokensAfter);
+                    actionDetail = `释放: ${diff} tokens, ${tokensBefore} tokens → ${tokensAfter} tokens, 策略: ${strategy}` +
+                        (pruned ? `, 裁剪工具: ${pruned}条` : "") +
+                        (summarized ? `, 摘要化: ${summarized}条` : "");
+                }
+                else {
+                    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（input 和 output 均归零），使面板显示压缩后的真实上下文大小。
+            //    与 runtime 压缩后重置 accumulatedInputTokens/accumulatedOutputTokens = 0（runtime.ts）对齐。
+            //    若只重置 input 不重置 output，压缩后面板 total 仍含压缩前 output，持续虚高。
+            //    将 usage 合并到 end 事件的 actionInfo 中，避免额外的无 actionInfo status-change
+            //    触发前端 handleDeltaStatusEvent 创建无 actionId 的占位事件（会导致扁平化渲染）。
+            if (isEnd) {
+                entry.adapterSession.totalUsage.inputTokens = 0;
+                entry.adapterSession.totalUsage.outputTokens = 0;
+                // ★ 使用 spread 副本，避免后续事件（如 ai_request）修改 totalUsage 时
+                //    通过引用别名反向改变已发出的 compaction 事件 usage 快照。
+                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),
         });
@@ -944,9 +1494,16 @@ export class AcodeSdkAdapter extends EventEmitter {
         const entry = this.sessions.get(sessionId);
         if (!entry || this.isTerminalStatus(entry.adapterSession.status))
             return;
+        // ★ 修复竞态：递增 token，.finally() 只在 token 匹配时执行清理。
+        //   防止前一轮 submit() 的 .finally() 清除新一轮的看门狗和 autoPollActive。
+        //   场景：看门狗 120s 触发 abort → R2 恢复 → 新一轮 submit 排队 →
+        //   前一轮 executeSubmit 数百秒后才完成 → .finally() 错误清除新一轮状态。
+        const myToken = (entry.autoPollToken ?? 0) + 1;
+        entry.autoPollToken = myToken;
         entry.autoPollActive = true;
         entry.autoPollObservedPollingTool = false;
         entry.autoPollObservedAssistantText = false;
+        entry.autoPollObservedAnyTool = false;
         entry.stopAutoPollAfterCurrentTurn = false;
         if (!options?.keepWaitingStatus) {
             entry.adapterSession.status = "thinking";
@@ -963,6 +1520,16 @@ export class AcodeSdkAdapter extends EventEmitter {
             const latestEntry = this.sessions.get(sessionId);
             if (!latestEntry)
                 return;
+            // ★ token 守卫：如果 token 不匹配，说明新一轮 submitAutoPollPrompt 已启动，
+            //   当前轮的清理操作（取消看门狗、清除 autoPollActive）会错误覆盖新一轮状态。
+            //   新一轮已设置了新的看门狗和 autoPollActive=true，直接跳过清理。
+            //   关键：这防止了"前一轮 .finally() 清除新一轮看门狗 → 新一轮 fetch 挂死时无保护 → 永久卡死"的竞态。
+            if (latestEntry.autoPollToken !== myToken) {
+                adapterDebugLog(`[ACode] submitAutoPollPrompt.finally: token mismatch ` +
+                    `(my=${myToken}, current=${latestEntry.autoPollToken}), ` +
+                    `skipping cleanup — newer turn has taken over`);
+                return;
+            }
             // 无论 submit 是正常返回还是超时恢复，都需要取消超时检测（超时回调里已设置 submitTimeoutTimer=undefined，再调 cancel 是安全的）
             this.cancelSubmitTimeoutDetection(latestEntry);
             latestEntry.autoPollActive = false;
@@ -980,6 +1547,7 @@ export class AcodeSdkAdapter extends EventEmitter {
                 latestEntry.stopAutoPollAfterCurrentTurn = false;
                 latestEntry.autoPollObservedPollingTool = false;
                 latestEntry.autoPollObservedAssistantText = false;
+                latestEntry.autoPollObservedAnyTool = false;
                 return;
             }
             if (latestEntry.adapterSession.status === "error") {
@@ -1057,10 +1625,57 @@ 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;
         }
+        // ★ 修复 BUG（时间线永久卡在"编辑文件"）：当恢复前状态为 tool_using 时，
+        //   补发 tool_use_end 事件，关闭前端时间线中由 tool_use_start 创建的工具条目。
+        //   根因：数据流看门狗在 tool_using 状态触发后调用本方法，但原实现只切换状态为
+        //   waiting_input，从不补发 tool_use_end。而 runtime 端因 abortRequested===true，
+        //   在 catch 块中 rethrow 前跳过了 tool_result 发射（3241 行），
+        //   导致 adapter 永远收不到 tool_result，tool_use_end 永不发射，时间线永久卡住。
+        if (entry.adapterSession.status === "tool_using" && entry.pendingToolEventData) {
+            const toolData = entry.pendingToolEventData;
+            adapterDebugLog(`[ACode] recoverTurnFailure: 补发 tool_use_end (tool: ${toolData.toolName ?? "unknown"}) ` +
+                `关闭时间线条目，避免永久卡在工具执行状态`);
+            this.emit("event", {
+                type: "tool_use_end",
+                sessionId,
+                timestamp: new Date().toISOString(),
+                data: {
+                    ...toolData,
+                    toolResult: "[aborted] 工具执行被数据流看门狗中断",
+                },
+            });
+            entry.pendingToolEventData = undefined;
+        }
+        // ★ 修复：超时恢复前强制 emit turn_complete，计入已有的 output tokens，
+        //   否则面板上 output_tokens 永远是 0（turn_complete 从未发射）。
+        //   使用消息历史中的 assistant 文本粗略估算 output tokens（累计估算）。
+        //   此为异常恢复路径（turn_complete 未到达，无真实 completion_tokens），
+        //   直接覆盖式赋值（不再用 delta += 累加，避免与覆盖式语义冲突导致重复计算）。
+        const estimatedOutput = this.estimateOutputTokensFromMessages(entry.adapterSession.messages);
+        if (estimatedOutput > 0) {
+            const prev = entry.adapterSession.totalUsage.outputTokens;
+            entry.adapterSession.totalUsage.outputTokens = estimatedOutput;
+            adapterDebugLog(`[ACode] recoverTurnFailure: 估算覆盖 output tokens ${prev} -> ${estimatedOutput} ` +
+                `(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 +1687,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 +1733,23 @@ 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...`);
+        console.warn(`[ACode] ⚠️ Detected stuck state: ${entry.adapterSession.status} after submit resolved! ` +
+            `Recovering to waiting_input. ` +
+            `If runtime.submit() is still pending (e.g., built-in tool execution not interruptible by abort()), ` +
+            `the submitQueue is deadlocked and subsequent auto-poll/user submits will never execute.`);
+        adapterDebugLog(`[ACode]  Recovering to waiting_input...`);
         entry.adapterSession.status = "waiting_input";
         // ★ 修复：检测 idle 命令是否包含 poll_message，在 waiting_input 状态变更中携带 idle 动作信息
         const idleCommands = entry.idleCommands?.idleInputCommand;
@@ -1136,42 +1760,120 @@ 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 超时检测（治本修复：防止状态永久卡住）
+     * 启动异步看门狗：周期性轮询运行时状态，仅在真正卡死时恢复。
      *
-     * 如果 runtime.submit() 在指定时间内未返回，强制触发恢复机制，
-     * 避免会话永久卡在 thinking/tool_using 状态。
+     * 替代原来两个独立的 setTimeout（submitTimeoutDetection + dataFlowWatchdog），
+     * 改为单一 setInterval 轮询。核心设计：
+     * - 每 ACODE_WATCHDOG_POLL_INTERVAL_MS（5s）检查一次状态
+     * - waiting_input 状态下不累计超时（agent 正在有意等待，如 poll_message/ask_user_question）
+     * - 仅在 thinking/tool_using 状态下累计"活跃持续时间"和"无数据流时间"
+     * - submit 超时 120s 或数据流超时 40s 时触发 recoverTurnFailure
+     *
+     * 相比 setTimeout 方案的优势：
+     * 1. 状态感知：每次轮询都读取当前真实状态，不会因状态在定时周期内多次变化而误判
+     * 2. waiting_input 自动暂停计时：无需递归重新计时，天然跳过
+     * 3. 单一 timer：避免两个独立 timer 的竞态和重复恢复
      */
     startSubmitTimeoutDetection(sessionId, entry, source) {
-        // 清除之前的超时检测
         this.cancelSubmitTimeoutDetection(entry);
-        entry.submitStartTime = Date.now();
-        entry.submitTimeoutTimer = setTimeout(() => {
+        entry.watchdogSubmitStartTime = Date.now();
+        entry.watchdogLastDataFlowTime = Date.now();
+        entry.watchdogTimer = setInterval(() => {
             const currentEntry = this.sessions.get(sessionId);
-            if (!currentEntry)
+            if (!currentEntry) {
+                this.cancelSubmitTimeoutDetection(entry);
                 return;
-            const elapsed = Date.now() - (currentEntry.submitStartTime || 0);
-            console.warn(`[ACode] CRITICAL: submit timeout detected after ${Math.round(elapsed / 1000)}s ` +
-                `(source: ${source}, session: ${sessionId}, status: ${currentEntry.adapterSession.status}). ` +
-                `Forcing recovery to prevent permanent state stuck.`);
-            // 强制恢复到 waiting_input 状态
-            currentEntry.submitTimeoutTimer = undefined;
-            this.recoverTurnFailure(sessionId, currentEntry);
-        }, ACODE_SUBMIT_TIMEOUT_MS);
+            }
+            const status = currentEntry.adapterSession.status;
+            const now = Date.now();
+            // waiting_input：agent 正在有意等待（poll_message/ask_user_question），不计时
+            if (status === "waiting_input") {
+                // 重置计时基准，下次进入 thinking/tool_using 时从 0 开始计
+                currentEntry.watchdogSubmitStartTime = now;
+                currentEntry.watchdogLastDataFlowTime = now;
+                return;
+            }
+            // 仅 thinking/tool_using 状态下检查超时
+            if (status !== "thinking" && status !== "tool_using") {
+                return;
+            }
+            const submitElapsed = now - (currentEntry.watchdogSubmitStartTime || now);
+            const dataFlowElapsed = now - (currentEntry.watchdogLastDataFlowTime || now);
+            // 数据流超时（40s 无流式数据）— 比 submit 超时（120s）更短，优先触发
+            if (dataFlowElapsed >= ACODE_DATA_FLOW_STREAM_WATCHDOG_MS) {
+                console.warn(`[ACode] CRITICAL: Data flow watchdog triggered after ${Math.round(dataFlowElapsed / 1000)}s ` +
+                    `(source: ${source}, session: ${sessionId}, status: ${status}). ` +
+                    `No stream data received. Forcing recovery via recoverTurnFailure.`);
+                this.executeWatchdogRecovery(sessionId, currentEntry, source, "data_flow", dataFlowElapsed);
+                return;
+            }
+            // submit 超时（120s 未返回）
+            if (submitElapsed >= ACODE_SUBMIT_TIMEOUT_MS) {
+                console.warn(`[ACode] CRITICAL: submit timeout detected after ${Math.round(submitElapsed / 1000)}s ` +
+                    `(source: ${source}, session: ${sessionId}, status: ${status}). ` +
+                    `Forcing recovery to prevent permanent state stuck.`);
+                this.executeWatchdogRecovery(sessionId, currentEntry, source, "submit_timeout", submitElapsed);
+                return;
+            }
+        }, ACODE_WATCHDOG_POLL_INTERVAL_MS);
     }
     /**
-     * 取消 submit 超时检测
+     * 执行看门狗恢复：abort runtime + recoverTurnFailure
+     */
+    executeWatchdogRecovery(sessionId, entry, source, reason, elapsedMs) {
+        // ★ 关键修复：先 abort runtime 打断挂起的 fetch / stream reader，
+        //   否则 submitQueue 永久阻塞，后续 submit 全部排队等待，agent 彻底死锁。
+        adapterDebugLog(`[ACode]  Watchdog (${reason}): calling runtime.abort() after ${Math.round(elapsedMs / 1000)}s...`);
+        try {
+            void entry.runtime.abort();
+            adapterDebugLog(`[ACode]  Watchdog (${reason}): runtime.abort() called`);
+        }
+        catch (abortError) {
+            console.warn(`[ACode] ⚠️ Watchdog (${reason}): runtime.abort() threw: ${abortError instanceof Error ? abortError.message : String(abortError)}`);
+        }
+        // 取消看门狗（recoverTurnFailure 会重新 arm idle loop）
+        this.cancelSubmitTimeoutDetection(entry);
+        this.recoverTurnFailure(sessionId, entry);
+        console.warn(`[ACode] ⚠️ Watchdog (${reason}) recovery complete. ` +
+            `If abort() could not cancel the underlying operation, submitQueue may still be deadlocked.`);
+    }
+    /**
+     * 取消看门狗
      */
     cancelSubmitTimeoutDetection(entry) {
-        if (entry.submitTimeoutTimer) {
-            clearTimeout(entry.submitTimeoutTimer);
-            entry.submitTimeoutTimer = undefined;
+        if (entry.watchdogTimer) {
+            clearInterval(entry.watchdogTimer);
+            entry.watchdogTimer = undefined;
         }
-        entry.submitStartTime = undefined;
+        entry.watchdogSubmitStartTime = undefined;
+        entry.watchdogLastDataFlowTime = undefined;
+    }
+    /**
+     * 重置数据流计时基准：收到流式数据（assistant_delta/thinking_delta）时调用。
+     * 不再重启定时器，仅更新计时基准，下次轮询时从新基准计算。
+     */
+    resetDataFlowWatchdog(sessionId, entry) {
+        void sessionId;
+        entry.watchdogLastDataFlowTime = Date.now();
+    }
+    /**
+     * 启动数据流看门狗：由 ai_request 调用，初始化数据流计时基准。
+     * 实际的轮询由 startSubmitTimeoutDetection 的 interval 统一处理。
+     */
+    startDataFlowWatchdog(sessionId, entry) {
+        void sessionId;
+        entry.watchdogLastDataFlowTime = Date.now();
+    }
+    /**
+     * 取消数据流看门狗（已合并到 cancelSubmitTimeoutDetection，此方法保留兼容性）
+     */
+    cancelDataFlowWatchdog(entry) {
+        entry.watchdogLastDataFlowTime = Date.now();
     }
 }