aws-runtime-bridge 1.9.40 → 1.9.45

package/dist/adapter/AcodeSdkAdapter.js

@@ -41,6 +41,12 @@ const ACODE_AUTO_POLL_PROMPT = [
     "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
@@ -116,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;
@@ -224,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,
@@ -361,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) {
@@ -368,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,
@@ -619,6 +656,9 @@ export class AcodeSdkAdapter extends EventEmitter {
                 : 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({
@@ -715,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;
         }
@@ -742,26 +786,61 @@ export class AcodeSdkAdapter extends EventEmitter {
         }
         if (event.type === "ai_request") {
             const estimatedTokens = toEstimatedContextTokens(event.data);
+            let displayUsage;
             if (estimatedTokens > 0) {
-                // ★ 不再覆盖 totalUsage.inputTokens 和重置 outputTokens=0。
-                //    runModelTurn 的多轮迭代中每个 iter 都会发 ai_request，
-                //    重置 outputTokens=0 导致面板在整个 executeSubmit 期间看到 0。
-                //    改用 Math.max 确保 inputTokens 单调递增即可。
-                //    注意：如果上下文缩减（如释放历史），Math.max 不会反映真实缩减，
-                //    但对面板展示而言单调递增是可接受的设计取舍。
-                if (estimatedTokens > entry.adapterSession.totalUsage.inputTokens) {
+                // ★ 限制估算值的增长幅度，防止 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;
                 }
-                // ★ 使用消息历史估算实时的 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: displayUsage,
-                });
+                // ★ 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"
@@ -795,8 +874,25 @@ export class AcodeSdkAdapter extends EventEmitter {
         if (event.type === "turn_complete") {
             const usage = toUsage(event.data.usage);
             if (usage) {
-                // ★ 只累加 outputTokens；inputTokens 由 ai_request 的事件估算维护（Math.max 单调递增）
-                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;
@@ -817,9 +913,24 @@ export class AcodeSdkAdapter extends EventEmitter {
                 // session got permanently stuck in 'error'. Now we always recover
                 // for non-terminal sessions so the idle loop can retry.
                 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"
@@ -836,15 +947,17 @@ export class AcodeSdkAdapter extends EventEmitter {
             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();
@@ -857,6 +970,9 @@ export class AcodeSdkAdapter extends EventEmitter {
         }
         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 推到前端。
@@ -873,6 +989,7 @@ export class AcodeSdkAdapter extends EventEmitter {
             }
             this.emit("ask-user-question", {
                 sessionId: event.sessionId,
+                toolCallId: toolCallId || undefined,
                 questions,
             });
             return;
@@ -881,11 +998,16 @@ export class AcodeSdkAdapter extends EventEmitter {
             // 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"),
@@ -991,6 +1113,13 @@ export class AcodeSdkAdapter extends EventEmitter {
                 }, 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;
@@ -1000,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 ||
@@ -1035,6 +1169,14 @@ export class AcodeSdkAdapter extends EventEmitter {
                     ? "waiting_input"
                     : "thinking";
                 entry.adapterSession.status = status;
+                // ★ 修复 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 已创建条目。
@@ -1045,6 +1187,16 @@ export class AcodeSdkAdapter extends EventEmitter {
             }
             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;
@@ -1134,9 +1286,37 @@ export class AcodeSdkAdapter extends EventEmitter {
         }
         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,
                 });
@@ -1176,12 +1356,19 @@ export class AcodeSdkAdapter extends EventEmitter {
             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 = "上下文压缩开始";
-                actionDetail = `压缩前: ${sizeKB}KB, 消息: ${msgCount}条` +
-                    (actualInput ? `, 实际 tokens: ${actualInput} ${actualOutput}` : "") + trigger;
+                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
@@ -1190,6 +1377,9 @@ export class AcodeSdkAdapter extends EventEmitter {
             }
             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 ?? "?");
@@ -1197,9 +1387,17 @@ export class AcodeSdkAdapter extends EventEmitter {
                 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}条` : "");
+                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）不重复更新状态，仅推送到时间线
@@ -1232,12 +1430,17 @@ export class AcodeSdkAdapter extends EventEmitter {
             if (isPhase && parentId && !actionInfo.parentId) {
                 actionInfo.parentId = parentId;
             }
-            // ★ 压缩结束时重置 totalUsage.inputTokens，使面板显示压缩后的真实上下文大小。
+            // ★ 压缩结束时重置 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;
-                actionInfo.usage = entry.adapterSession.totalUsage;
+                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 等）一致，
@@ -1291,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";
@@ -1310,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;
@@ -1327,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") {
@@ -1421,14 +1642,37 @@ export class AcodeSdkAdapter extends EventEmitter {
         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。
+        //   使用消息历史中的 assistant 文本粗略估算 output tokens（累计估算）。
+        //   此为异常恢复路径（turn_complete 未到达，无真实 completion_tokens），
+        //   直接覆盖式赋值（不再用 delta += 累加，避免与覆盖式语义冲突导致重复计算）。
         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 ` +
+        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})`);
         }
@@ -1501,7 +1745,10 @@ export class AcodeSdkAdapter extends EventEmitter {
             adapterDebugLog(`[ACode]  Skipping recovery: status is ${entry.adapterSession.status} (not thinking/tool_using)`);
             return;
         }
-        adapterDebugLog(`[ACode] ⚠️ Detected stuck state: ${entry.adapterSession.status} after submit resolved!`);
+        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 动作信息
@@ -1519,36 +1766,114 @@ export class AcodeSdkAdapter extends EventEmitter {
         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();
     }
 }