aws-runtime-bridge 1.9.9 → 1.9.20

package/dist/routes/terminal.js

@@ -16,16 +16,44 @@ import { adapterRegistry, getToolActionInfo, isTransientClipboardPasteFilePath,
 import { validateToken } from "../middleware/auth.js";
 import { getAgentProcessManager } from "../services/agent-process-manager.js";
 import { getAiConfigService } from "../services/cc-switch-sdk.js";
+import { prepareAcodeInstanceConfig, redactForLog } from "../services/instance-ai-config-service.js";
 import { enqueueMcpLaunchBinding } from "../services/mcp-launch-binding-queue.js";
 import { findClaudeCodeProcesses, isProcessRunning, } from "../services/process-detector.js";
-import { sendOutput, sendQuestionRequest, sendStatus, } from "../services/session-output.js";
+import { bridgeEventBuffer, sendOutput, sendQuestionRequest, sendStatus, } from "../services/session-output.js";
+import { getAllPushStats, startHeartbeatScheduler } from "../services/event-delta-pusher.js";
 import { findPersistedSessionByAgentId, removePersistedSession, savePersistedSessions, updatePersistedSessionAutoCommands, updatePersistedSessionRuntimeState, upsertPersistedSession, } from "../services/terminal-persistence.js";
+import { getInstanceAiConfigDebugLogger } from "../utils/instance-ai-config-debug-logger.js";
 import { logger as log } from "../utils/logger.js";
 export const terminalRouter = Router();
 // 导出 SDK 会话存储，供其他模块使用（如 sessions.ts）
 export const sdkSessions = new Map();
 const TOOL_RESULT_PREVIEW_MAX_LENGTH = 4000;
 const AI_REQUEST_BODY_MARKER = "\n\n请求体:\n";
+/**
+ * 把请求体中的 instanceAiConfig 归一化为 AdapterInstanceAiConfig。
+ * 任意字段类型错误或非字符串都返回 undefined，调用方应继续走 env/file fallback。
+ */
+function sanitizeInstanceAiConfig(value) {
+    if (value == null)
+        return undefined;
+    if (typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const raw = value;
+    const out = {};
+    if (typeof raw.model === "string" && raw.model.trim()) {
+        out.model = raw.model.trim();
+    }
+    if (typeof raw.baseURL === "string" && raw.baseURL.trim()) {
+        out.baseURL = raw.baseURL.trim();
+    }
+    if (typeof raw.apiKey === "string" && raw.apiKey.trim()) {
+        out.apiKey = raw.apiKey.trim();
+    }
+    if (typeof raw.effort === "string" && raw.effort.trim()) {
+        out.effort = raw.effort.trim();
+    }
+    return out;
+}
 const AI_REQUEST_HEADERS_MARKER = "\n\n请求头:\n";
 const startingAgents = new Set();
 export function resolveRuntimeContextResetSupport(providerId, hasResetContext) {
@@ -83,9 +111,13 @@ export function resolveStatusChangeUsage(actionInfo) {
     const outputTokens = Number.isFinite(usage.outputTokens)
         ? usage.outputTokens
         : 0;
-    if (inputTokens <= 0 && outputTokens <= 0)
+    if (inputTokens <= 0 && outputTokens <= 0 && !usage.contextLimit)
         return undefined;
-    return { inputTokens, outputTokens };
+    return {
+        inputTokens,
+        outputTokens,
+        ...(usage.contextLimit ? { contextLimit: usage.contextLimit } : {}),
+    };
 }
 export function resolveStatusChangeRuntimeState(status, actionInfo) {
     const normalizedStatus = String(status || "")
@@ -109,14 +141,14 @@ const TERMINAL_COMMAND_INACTIVITY_TIMEOUT_MS = 60_000;
 function padDatePart(value) {
     return String(value).padStart(2, "0");
 }
-export function buildAcodeCommandOutputPath(workspacePath, now = new Date()) {
+export function buildAcodeCommandOutputPath(agentId, now = new Date()) {
     const year = now.getFullYear();
     const month = padDatePart(now.getMonth() + 1);
     const day = padDatePart(now.getDate());
     const hour = padDatePart(now.getHours());
     const minute = padDatePart(now.getMinutes());
     const timestamp = `${year}${month}${day}-${hour}${minute}${padDatePart(now.getSeconds())}-${String(now.getMilliseconds()).padStart(3, "0")}`;
-    return path.join(workspacePath, ".agentswork", "acode", "cmd-dist", `${year}-${month}-${day}`, hour, minute, `${timestamp}-cmd.out`);
+    return path.join(os.homedir(), ".acode", "cmd-dist", agentId, `${year}-${month}-${day}`, hour, minute, `${timestamp}-cmd.out`);
 }
 export function countTerminalOutputLines(output) {
     if (!output) {
@@ -138,7 +170,7 @@ export function formatCommandInactivityTimeoutNotice(timeoutMs = TERMINAL_COMMAN
 }
 async function persistTerminalCommandOutput(state) {
     const outputPath = state.outputPath ||
-        buildAcodeCommandOutputPath(state.workspacePath, state.startedAt);
+        buildAcodeCommandOutputPath(state.agentId, state.startedAt);
     state.outputPath = outputPath;
     await fs.mkdir(path.dirname(outputPath), { recursive: true });
     await fs.writeFile(outputPath, state.chunks.join(""), "utf-8");
@@ -395,7 +427,7 @@ async function executeTerminalCommand(sessionId, commandValue) {
     const stderrDecoder = createTerminalOutputDecoder();
     const usesAcodeCommandOutputPolicy = entry.providerId === "acode";
     const outputSpilloverState = {
-        workspacePath: entry.workspacePath,
+        agentId: entry.agentId,
         startedAt: new Date(),
         chunks: [],
         spilled: false,
@@ -908,19 +940,11 @@ export function resolveRuntimeStatusFromProviderEvent(event, currentRuntimeStatu
         };
     }
     if (event.type === "turn_complete") {
-        const responseActionInfo = event.data
-            .responseBody
-            ? {
-                actionType: "ai_request",
-                actionLabel: "AI响应",
-                actionResult: event.data.responseBody,
-                usage: event.data.usage,
-            }
-            : undefined;
+        // 方案 A：不设置 "AI响应" action 信息，避免状态卡在 action 展示
+        // 只返回干净的 waiting_input 状态，usage 信息保留用于 token 统计
         return {
             status: "waiting_input",
-            actionInfo: responseActionInfo ||
-                (event.data.usage ? { usage: event.data.usage } : undefined),
+            actionInfo: event.data.usage ? { usage: event.data.usage } : undefined,
         };
     }
     if (event.type === "error") {
@@ -928,15 +952,111 @@ export function resolveRuntimeStatusFromProviderEvent(event, currentRuntimeStatu
     }
     return undefined;
 }
-function forwardSdkOutputEvent(event, entry) {
+// Per-session 输出队列：确保 sendOutput HTTP POST 按事件顺序串行到达 Server，
+// 避免并发 POST 因网络时序导致流式文本 chunk 乱序。
+const sdkOutputQueueBySession = new Map();
+/** 小 chunk 积攒缓存：sessionId:sourceEventType → { buffer, seq, timer, sourceEventType, entry }，不足 20 字符时积攒最多 500ms 再推送 */
+const sdkOutputSmallChunkAccumulators = new Map();
+/** 小 chunk 积攒阈值：字符数少于此值的 output 事件积攒发送 */
+const SMALL_CHUNK_CHAR_THRESHOLD = 20;
+/** 小 chunk 最大积攒时间（毫秒） */
+const SMALL_CHUNK_MAX_ACCUMULATE_MS = 500;
+function flushSmallChunkAccumulator(sessionId, sourceEventType) {
+    const key = sourceEventType
+        ? `${sessionId}:${sourceEventType}`
+        : undefined;
+    // 如果指定了 key 则精确刷新；否则回退到按 sessionId 前缀查找并刷新所有（兼容大 chunk 触发的全量刷新）
+    let acc;
+    let accKey;
+    if (key) {
+        acc = sdkOutputSmallChunkAccumulators.get(key);
+        accKey = key;
+    }
+    else {
+        // 刷新该 sessionId 下的所有 accumulator（可能有多种 sourceEventType）
+        for (const [k, v] of sdkOutputSmallChunkAccumulators) {
+            if (k.startsWith(sessionId + ":") && v.buffer) {
+                flushSmallChunkAccumulator(sessionId, v.sourceEventType);
+            }
+        }
+        return;
+    }
+    if (!acc || !acc.buffer)
+        return;
+    acc.timer = null;
+    const output = acc.buffer;
+    const seq = acc.seq;
+    const entry = acc.entry;
+    const eventType = acc.sourceEventType;
+    acc.buffer = "";
+    if (accKey)
+        sdkOutputSmallChunkAccumulators.delete(accKey);
+    const metadata = {
+        sourceEventType: eventType,
+        logCategory: "acode",
+    };
+    const authOptions = {
+        runtimeAccessToken: entry.runtimeAccessToken,
+        schedulerBaseUrl: entry.schedulerBaseUrl,
+    };
+    const prev = sdkOutputQueueBySession.get(sessionId) ?? Promise.resolve();
+    const next = prev.then(() => sendOutput(entry.agentId, output, sessionId, seq, metadata, authOptions), () => sendOutput(entry.agentId, output, sessionId, seq, metadata, authOptions));
+    sdkOutputQueueBySession.set(sessionId, next);
+    void next.finally(() => {
+        if (sdkOutputQueueBySession.get(sessionId) === next) {
+            sdkOutputQueueBySession.delete(sessionId);
+        }
+    });
+}
+function enqueueSdkOutputEvent(event, entry) {
     const output = formatSdkOutputEvent(event);
     if (!output) {
         return;
     }
     entry.seq += 1;
-    void sendOutput(entry.agentId, output, event.sessionId, entry.seq, buildSdkOutputMetadata(event), {
+    const seq = entry.seq;
+    const metadata = buildSdkOutputMetadata(event);
+    const authOptions = {
         runtimeAccessToken: entry.runtimeAccessToken,
         schedulerBaseUrl: entry.schedulerBaseUrl,
+    };
+    // 小 chunk 积攒优化：命令输出和 AI 文本增量等小片段不足阈值时积攒再推送
+    if ((event.type === "command_output" ||
+        event.type === "text_delta" ||
+        event.type === "thinking") &&
+        output.length < SMALL_CHUNK_CHAR_THRESHOLD) {
+        const accKey = `${event.sessionId}:${event.type}`;
+        let acc = sdkOutputSmallChunkAccumulators.get(accKey);
+        if (!acc) {
+            acc = {
+                buffer: "",
+                seq: 0,
+                timer: null,
+                entry,
+                sourceEventType: event.type,
+            };
+        }
+        acc.buffer += output;
+        acc.seq = seq;
+        acc.entry = entry;
+        if (!acc.timer) {
+            const capturedSessionId = event.sessionId;
+            const capturedType = event.type;
+            acc.timer = setTimeout(() => flushSmallChunkAccumulator(capturedSessionId, capturedType), SMALL_CHUNK_MAX_ACCUMULATE_MS);
+        }
+        sdkOutputSmallChunkAccumulators.set(accKey, acc);
+        return;
+    }
+    // 大 chunk 直接发送（先刷新可能存在的积攒缓存）
+    flushSmallChunkAccumulator(event.sessionId);
+    const prev = sdkOutputQueueBySession.get(event.sessionId) ?? Promise.resolve();
+    const next = prev.then(() => sendOutput(entry.agentId, output, event.sessionId, seq, metadata, authOptions), () => sendOutput(entry.agentId, output, event.sessionId, seq, metadata, authOptions));
+    sdkOutputQueueBySession.set(event.sessionId, next);
+    // 队列空闲时自动清理，避免内存泄漏
+    void next.finally(() => {
+        if (sdkOutputQueueBySession.get(event.sessionId) === next) {
+            sdkOutputQueueBySession.delete(event.sessionId);
+        }
     });
 }
 export function resolveSdkProviderId(command) {
@@ -948,6 +1068,8 @@ function ensureAdapterInitialized() {
     if (adapterInitialized)
         return;
     registerSdkProviders(adapterRegistry, wireSdkAdapterEvents);
+    // 需求 4.2.1 #2：启动全局心跳调度器（每 30s 推送空包检测 Server 连接存活）
+    startHeartbeatScheduler();
     adapterInitialized = true;
 }
 function wireSdkAdapterEvents(adapter, definition) {
@@ -955,20 +1077,36 @@ function wireSdkAdapterEvents(adapter, definition) {
         const entry = sdkSessions.get(event.sessionId);
         if (entry) {
             console.log(`[${definition.displayName} Adapter] Event: ${event.type} for session ${event.sessionId}`);
-            const runtimeStatus = resolveRuntimeStatusFromProviderEvent(event, entry.currentRuntimeStatus);
-            if (runtimeStatus) {
-                void sendStatus(entry.agentId, event.sessionId, runtimeStatus.status, runtimeStatus.actionInfo, resolveStatusChangeUsage(runtimeStatus.actionInfo), {
-                    runtimeAccessToken: entry.runtimeAccessToken,
-                    schedulerBaseUrl: entry.schedulerBaseUrl,
-                });
+            // Skip sendStatus for thinking/text_delta events — the status-change listener
+            // already emits the authoritative thinking status with restored actionInfo,
+            // avoiding duplicate timeline entries in agentEventStore.
+            const isThinkingDelta = event.type === "thinking" || event.type === "text_delta";
+            if (!isThinkingDelta) {
+                const runtimeStatus = resolveRuntimeStatusFromProviderEvent(event, entry.currentRuntimeStatus);
+                if (runtimeStatus) {
+                    void sendStatus(entry.agentId, event.sessionId, runtimeStatus.status, runtimeStatus.actionInfo, resolveStatusChangeUsage(runtimeStatus.actionInfo), {
+                        runtimeAccessToken: entry.runtimeAccessToken,
+                        schedulerBaseUrl: entry.schedulerBaseUrl,
+                    }, 
+                    // Pass original timestamp from ACode runtime for correct timeline ordering
+                    // Convert ISO string timestamp to epoch milliseconds
+                    event.timestamp ? new Date(event.timestamp).getTime() : undefined, 
+                    // Pass original event type for frontend gray-zone rendering (thinking vs text_delta)
+                    event.type);
+                }
             }
-            forwardSdkOutputEvent(event, entry);
+            enqueueSdkOutputEvent(event, entry);
             const toolResultActionInfo = buildToolResultTimelineActionInfo(event);
             if (toolResultActionInfo) {
                 void sendStatus(entry.agentId, event.sessionId, "tool_result", toolResultActionInfo, undefined, {
                     runtimeAccessToken: entry.runtimeAccessToken,
                     schedulerBaseUrl: entry.schedulerBaseUrl,
-                });
+                }, 
+                // Pass original timestamp from ACode runtime for correct timeline ordering
+                // Convert ISO string timestamp to epoch milliseconds
+                event.timestamp ? new Date(event.timestamp).getTime() : undefined, 
+                // Pass original event type (tool_use_end) for timeline sourceEventType
+                event.type);
             }
         }
     });
@@ -977,18 +1115,45 @@ function wireSdkAdapterEvents(adapter, definition) {
         if (entry) {
             const runtimeState = resolveStatusChangeRuntimeState(status, actionInfo);
             entry.currentRuntimeStatus = runtimeState.status;
-            entry.currentRuntimeActionType = runtimeState.actionInfo?.actionType;
-            entry.currentRuntimeActionLabel = runtimeState.actionInfo?.actionLabel;
-            entry.currentRuntimeActionDetail =
-                runtimeState.actionInfo?.actionDetail;
+            // 当新状态未携带动作且进入 thinking 时,保留上一个 idle 类动作(如 poll_message),
+            // 避免页面刷新后丢失"监听消息"状态而错误显示"思考中"。
+            // 注意:MCP client 发送的 actionType 是 "mcp" 而非 "idle",需要通过 actionDetail 判断。
+            // ★ 关键修复: turn_complete 后进入 waiting_input 时,如果携带的是 ai_request 动作,
+            //   不应该保留之前的 tool_using 动作,避免永久卡在工具调用状态。
+            const prevActionDetail = entry.currentRuntimeActionDetail ?? "";
+            const isPrevPollMessage = prevActionDetail.includes("poll_message") || prevActionDetail.includes("get_message");
+            const isNewAiRequestAction = runtimeState.actionInfo?.actionType === "ai_request";
+            const shouldPreservePrevAction = !isNewAiRequestAction && // 新动作不是 AI 响应
+                (runtimeState.status === "thinking" || runtimeState.status === "waiting_input") && // 状态是 thinking 或 waiting_input
+                (entry.currentRuntimeActionType === "idle" || entry.currentRuntimeActionType === "mcp") && // 之前是 idle/mcp 动作
+                isPrevPollMessage; // 且之前是 poll_message
+            if (runtimeState.actionInfo?.actionType || // 新状态携带了动作
+                !shouldPreservePrevAction // 不满足保留条件
+            ) {
+                entry.currentRuntimeActionType = runtimeState.actionInfo?.actionType;
+                entry.currentRuntimeActionLabel = runtimeState.actionInfo?.actionLabel;
+                entry.currentRuntimeActionDetail =
+                    runtimeState.actionInfo?.actionDetail;
+            }
             console.log(`[${definition.displayName} Adapter] Status changed: ${runtimeState.status} for agent ${entry.agentId}`, runtimeState.actionInfo || "");
             void updatePersistedSessionRuntimeState(sessionId, {
                 runtimeStatus: runtimeState.status,
-                runtimeActionType: runtimeState.actionInfo?.actionType,
-                runtimeActionLabel: runtimeState.actionInfo?.actionLabel,
-                runtimeActionDetail: runtimeState.actionInfo?.actionDetail,
+                runtimeActionType: entry.currentRuntimeActionType,
+                runtimeActionLabel: entry.currentRuntimeActionLabel,
+                runtimeActionDetail: entry.currentRuntimeActionDetail,
             });
-            void sendStatus(entry.agentId, sessionId, runtimeState.status, runtimeState.actionInfo, resolveStatusChangeUsage(runtimeState.actionInfo), {
+            // thinking + poll_message 动作保留时，派生恢复用 actionInfo 传给 sendStatus
+            // 支持 actionType 为 "idle" 或 "mcp"，通过 actionDetail 中的 poll_message/get_message 判断
+            const restoredActionInfo = runtimeState.actionInfo?.actionType
+                ? runtimeState.actionInfo
+                : entry.currentRuntimeActionType
+                    ? {
+                        actionType: entry.currentRuntimeActionType,
+                        actionLabel: entry.currentRuntimeActionLabel ?? "",
+                        actionDetail: entry.currentRuntimeActionDetail,
+                    }
+                    : undefined;
+            void sendStatus(entry.agentId, sessionId, runtimeState.status, restoredActionInfo, resolveStatusChangeUsage(runtimeState.actionInfo), {
                 runtimeAccessToken: entry.runtimeAccessToken,
                 schedulerBaseUrl: entry.schedulerBaseUrl,
             });
@@ -1008,6 +1173,17 @@ function wireSdkAdapterEvents(adapter, definition) {
         const entry = sdkSessions.get(data.sessionId);
         if (entry) {
             console.log(`[${definition.displayName} Adapter] Permission request: ${data.toolName} for agent ${entry.agentId}`);
+            const actionDetail = data.toolInput
+                ? redactTransientClipboardPastePaths(JSON.stringify(data.toolInput).slice(0, 400))
+                : undefined;
+            void sendStatus(entry.agentId, data.sessionId, "waiting_input", {
+                actionType: "other",
+                actionLabel: "权限确认",
+                actionDetail: actionDetail || data.toolName,
+            }, undefined, {
+                runtimeAccessToken: entry.runtimeAccessToken,
+                schedulerBaseUrl: entry.schedulerBaseUrl,
+            });
         }
     });
 }
@@ -1049,7 +1225,24 @@ async function startSdkSession(req, res) {
     // MCP 配置 - 加载 aws-client-agent-mcp
     mcpConfigPath, extraMcpServers, envOverrides, 
     // 空闲命令配置
-    idleInputAutoCommand, nonInputAutoCommand, } = req.body || {};
+    idleInputAutoCommand, nonInputAutoCommand, 
+    // Per-agent model override（优先于全局配置）
+    model: perAgentModel, 
+    // Per-instance AI provider 覆盖（仅 ACode 消费；优先级：api > env > file > global）
+    instanceAiConfig: perInstanceAiConfig, } = req.body || {};
+    const _dbg = getInstanceAiConfigDebugLogger();
+    void _dbg.log({
+        level: "info",
+        category: "launch",
+        message: "startSdkSession: 收到启动请求",
+        source: "bridge",
+        agentId: String(agentId || "").trim() || undefined,
+        details: {
+            reqBodyKeys: Object.keys(req.body || {}),
+            perInstanceAiConfig: perInstanceAiConfig ? redactForLog(perInstanceAiConfig) : null,
+            perAgentModel: perAgentModel ?? null,
+        },
+    });
     let sessionId = null;
     const normalizedAgentId = String(agentId || "").trim();
     const runtimeAccessToken = String(req.body?.runtimeAccessToken || "").trim() || undefined;
@@ -1098,7 +1291,6 @@ async function startSdkSession(req, res) {
         // 根据命令选择对应的 adapter
         const normalizedCommand = (command || "acode").toLowerCase();
         const providerId = resolveSdkProviderId(command);
-        console.log(`[Runtime] ★★★ SDK启动 ★★★ command="${command}", normalizedCommand="${normalizedCommand}", providerId="${providerId}"`);
         const adapter = adapterRegistry.get(providerId);
         sessionId = uuidv4();
         const savedClaudeConfig = providerId === "claude-code"
@@ -1107,18 +1299,108 @@ async function startSdkSession(req, res) {
         const claudeLaunchConfig = providerId === "claude-code"
             ? buildClaudeCodeLaunchConfig(savedClaudeConfig, envOverrides)
             : buildClaudeCodeLaunchConfig(null, envOverrides);
+        // 模型解析优先级（ACode 与非 ACode 不同）：
+        //
+        // ACode：模型仲裁收敛到 AcodeSdkAdapter.resolveAcodeProvider → resolveAcodeProviderConfig 纯函数
+        //   优先级：perSessionModel(request) > instanceAiConfig(instance) > acode.json(global) > default
+        //   这里不预解析，将原始输入传递给 adapter
+        //
+        // 非 ACode (claude-code/codex/opencode)：
+        //   优先级：perAgentModel(request) > claudeLaunchConfig.model(global)
+        //   通过 ANTHROPIC_MODEL/CODEX_MODEL 环境变量注入
+        const resolvedModel = providerId === "acode"
+            ? (perAgentModel ? String(perAgentModel).trim() : undefined)
+            : (() => {
+                const requestModel = perAgentModel ? String(perAgentModel).trim() : undefined;
+                const globalModel = claudeLaunchConfig.model ? String(claudeLaunchConfig.model).trim() : undefined;
+                return requestModel || globalModel;
+            })();
+        void _dbg.log({
+            level: "info",
+            category: "resolve",
+            message: "模型解析结果",
+            source: "bridge",
+            agentId: normalizedAgentId,
+            sessionId: sessionId ?? undefined,
+            details: {
+                perAgentModel: perAgentModel ?? null,
+                globalModel: claudeLaunchConfig.model ?? null,
+                resolvedModel: resolvedModel ?? null,
+                providerId,
+                note: providerId === "acode" ? "adapter handles full priority" : "request > global",
+            },
+        });
+        // 构建 effectiveEnvOverrides：将 resolvedModel 注入各 provider 对应的环境变量
+        const effectiveEnvOverrides = { ...claudeLaunchConfig.envOverrides };
+        if (resolvedModel) {
+            // Claude Code 使用 ANTHROPIC_MODEL
+            effectiveEnvOverrides.ANTHROPIC_MODEL = resolvedModel;
+            // Codex 使用 CODEX_MODEL
+            effectiveEnvOverrides.CODEX_MODEL = resolvedModel;
+            // ACode / OpenCode: 不通过 env var 传递模型
+        }
+        // ACode 实例自配置：解析 api > env > file，deep-merge 全局后写入 per-instance acode.json
+        // 其它 provider 不消费 instanceAiConfig，保持向后兼容
+        // 模型仲裁由 AcodeSdkAdapter.resolveAcodeProvider 统一处理
+        let resolvedInstanceAiConfig;
+        let resolvedMcpConfigPath = mcpConfigPath;
+        if (providerId === "acode") {
+            const mergedInstanceConfig = perInstanceAiConfig || {};
+            const prepared = await prepareAcodeInstanceConfig({
+                apiOverrides: sanitizeInstanceAiConfig(mergedInstanceConfig) ?? undefined,
+                agentId: normalizedAgentId,
+                sessionId: sessionId ?? undefined,
+                runtimeBridgeBaseUrl: requestedSchedulerBaseUrl,
+            });
+            resolvedInstanceAiConfig = prepared.instanceConfig.config;
+            resolvedMcpConfigPath = prepared.perInstanceConfigPath;
+            void _dbg.log({
+                level: "info",
+                category: "apply",
+                message: "prepareAcodeInstanceConfig 完成",
+                source: "bridge",
+                agentId: normalizedAgentId,
+                sessionId: sessionId ?? undefined,
+                details: {
+                    sanitizedApiOverrides: sanitizeInstanceAiConfig(mergedInstanceConfig) ? redactForLog(sanitizeInstanceAiConfig(mergedInstanceConfig)) : null,
+                    resolvedInstanceAiConfig: resolvedInstanceAiConfig ? redactForLog(resolvedInstanceAiConfig) : null,
+                    perInstanceConfigPath: resolvedMcpConfigPath,
+                    instanceConfigSources: prepared.instanceConfig.source ?? null,
+                },
+            });
+        }
         // 构建SDK配置
         const config = {
             command: command || "acode",
             workingDirectory: workspacePath,
+            agentId: normalizedAgentId,
             autoAccept: Boolean(autoAccept),
             initialPrompt,
-            model: claudeLaunchConfig.model,
+            model: resolvedModel,
             // MCP 配置：不再默认注入 aws-mcp；由用户在面板中安装/配置
-            mcpConfigPath,
+            // ACode 场景下，per-instance acode.json 已由 instance-ai-config-service 写入
+            mcpConfigPath: resolvedMcpConfigPath,
+            // ACode 实例自配置：来源与值会写入 d:/Instance-ai-configuration-debug.log
+            ...(resolvedInstanceAiConfig
+                ? { instanceAiConfig: resolvedInstanceAiConfig }
+                : {}),
             extraMcpServers: extraMcpServers || {},
-            envOverrides: buildRuntimeEnv(String(agentId), String(workspacePath), process.env, claudeLaunchConfig.envOverrides),
+            envOverrides: buildRuntimeEnv(String(agentId), String(workspacePath), process.env, effectiveEnvOverrides),
         };
+        void _dbg.log({
+            level: "info",
+            category: "launch",
+            message: "传递给 Adapter 的完整 AdapterSessionConfig",
+            source: "bridge",
+            agentId: normalizedAgentId,
+            sessionId,
+            details: {
+                adapterModel: config.model ?? null,
+                adapterInstanceAiConfig: config.instanceAiConfig ? redactForLog(config.instanceAiConfig) : null,
+                adapterMcpConfigPath: config.mcpConfigPath ?? null,
+            },
+        });
+        await _dbg.flush();
         // 存储会话信息
         sdkSessions.set(sessionId, {
             agentId: normalizedAgentId,
@@ -1784,3 +2066,58 @@ terminalRouter.post("/stop-all", validateToken, async (_req, res) => {
         errors: errors.length > 0 ? errors : undefined,
     });
 });
+// ============ 桥接侧事件查询 ============
+/**
+ * 查询最近 N 条桥接侧本地事件。
+ *
+ * 用于前端面板或调试工具获取最近的状态/输出事件快照。
+ * GET /runtime/events/last/:n
+ */
+terminalRouter.get("/events/last/:n", validateToken, (req, res) => {
+    const nParam = parseInt(req.params.n, 10);
+    if (!Number.isFinite(nParam) || nParam < 1) {
+        res.status(400).json({ error: ":n must be a positive integer" });
+        return;
+    }
+    const entries = bridgeEventBuffer.getLastN(nParam);
+    res.json({
+        ok: true,
+        count: entries.length,
+        entries,
+    });
+});
+/**
+ * 查询自指定 index（不含）之后的桥接侧本地事件。
+ *
+ * 增量轮询端点：客户端保存上一次看到的 index，
+ * 下次传入该 index 仅获取增量事件，适用于实时刷新场景。
+ * GET /runtime/events/since/:index
+ */
+terminalRouter.get("/events/since/:index", validateToken, (req, res) => {
+    const indexParam = parseInt(req.params.index, 10);
+    if (!Number.isFinite(indexParam) || indexParam < 0) {
+        res.status(400).json({ error: ":index must be a non-negative integer" });
+        return;
+    }
+    const slice = bridgeEventBuffer.getSinceIndex(indexParam);
+    res.json({
+        ok: true,
+        entries: slice.entries,
+        nextIndex: slice.nextIndex,
+        oldestIndex: slice.oldestIndex,
+        dataLoss: slice.oldestIndex > indexParam + 1,
+    });
+});
+/**
+ * 获取 Bridge 侧事件推送统计（需求 4.2.1 #3）。
+ * 返回每个 Agent 的待推送数、累计成功/失败、连续失败次数、最近延迟等。
+ * GET /runtime/events/push-stats
+ */
+terminalRouter.get("/events/push-stats", validateToken, (_req, res) => {
+    const stats = getAllPushStats();
+    res.json({
+        ok: true,
+        count: stats.length,
+        agents: stats,
+    });
+});

package/dist/routes/terminal.test.js

@@ -293,6 +293,19 @@ describe("SDK provider event runtime status mapping", () => {
             actionId: "tool-idle-1",
         });
     });
+    it("turn_complete returns clean waiting_input without action info (A方案）", () => {
+        // 验证: turn_complete 后返回干净的 waiting_input 状态，不设置 "AI响应" action
+        // 这样可以避免状态卡在 "AI响应" 显示
+        const state = resolveRuntimeStatusFromProviderEvent(event("turn_complete", {
+            responseBody: '{"choices":[{"message":{"content":"done"}}]}',
+            usage: { inputTokens: 100, outputTokens: 50 },
+        }));
+        expect(state?.status).toBe("waiting_input");
+        // 方案 A：不再设置 ai_request action，只保留 usage
+        expect(state?.actionInfo?.actionType).toBeUndefined();
+        expect(state?.actionInfo?.actionLabel).toBeUndefined();
+        expect(state?.actionInfo?.usage).toEqual({ inputTokens: 100, outputTokens: 50 });
+    });
 });
 describe("terminal command helpers", () => {
     it("expands a whole mini-term clipboard paste file path into SDK input content", async () => {
@@ -339,9 +352,9 @@ describe("terminal command helpers", () => {
         expect(countTerminalOutputLines("one\ntwo\n")).toBe(2);
         expect(countTerminalOutputLines("one\r\ntwo\rthree")).toBe(3);
     });
-    it("builds ACode command output spillover paths under the workspace cmd-dist directory", () => {
-        const outputPath = buildAcodeCommandOutputPath(path.join("D:", "code", "repo"), new Date(2026, 1, 3, 4, 5, 6, 7));
-        expect(outputPath).toBe(path.join("D:", "code", "repo", ".agentswork", "acode", "cmd-dist", "2026-02-03", "04", "05", "20260203-040506-007-cmd.out"));
+    it("builds ACode command output spillover paths under ~/.acode/cmd-dist/<agentId>/", () => {
+        const outputPath = buildAcodeCommandOutputPath("agent-abc-123", new Date(2026, 1, 3, 4, 5, 6, 7));
+        expect(outputPath).toBe(path.join(os.homedir(), ".acode", "cmd-dist", "agent-abc-123", "2026-02-03", "04", "05", "20260203-040506-007-cmd.out"));
     });
     it("formats ACode long-output and inactivity notices for terminal users", () => {
         expect(formatCommandOutputSpilloverNotice("/repo/out.txt", 300)).toContain("命令输出超过 300 行");
@@ -399,7 +412,7 @@ describe("SDK status usage forwarding", () => {
             actionLabel: "Calling MCP",
         })).toBeUndefined();
     });
-    it("forwards structured AI response body through action result", () => {
+    it("returns waiting_input without action info on turn_complete (A方案：避免状态卡住）", () => {
         const runtimeStatus = resolveRuntimeStatusFromProviderEvent({
             type: "turn_complete",
             sessionId: "session-1",
@@ -410,16 +423,29 @@ describe("SDK status usage forwarding", () => {
                 finishReason: "stop",
             },
         });
+        // 方案 A：不再设置 "AI响应" action 信息，只保留 usage 用于 token 统计
         expect(runtimeStatus).toEqual({
             status: "waiting_input",
             actionInfo: {
-                actionType: "ai_request",
-                actionLabel: "AI响应",
-                actionResult: '{"choices":[{"message":{"content":"done"}}]}',
                 usage: { inputTokens: 12, outputTokens: 4 },
             },
         });
     });
+    it("returns waiting_input without action info when turn_complete has no usage", () => {
+        const runtimeStatus = resolveRuntimeStatusFromProviderEvent({
+            type: "turn_complete",
+            sessionId: "session-1",
+            timestamp: new Date(0).toISOString(),
+            data: {
+                responseBody: '{"choices":[{"message":{"content":"done"}}]}',
+                finishReason: "stop",
+            },
+        });
+        expect(runtimeStatus).toEqual({
+            status: "waiting_input",
+            actionInfo: undefined,
+        });
+    });
     it("includes file paths and commands in tool status action details", () => {
         expect(resolveRuntimeStatusFromProviderEvent({
             type: "tool_use_start",