opencode-bridge 2.9.0-beta

package/dist/index.js

@@ -0,0 +1,1562 @@
+import { spawn } from 'node:child_process';
+import { feishuClient } from './feishu/client.js';
+import { feishuAdapter } from './platform/adapters/feishu-adapter.js';
+import { discordAdapter } from './platform/adapters/discord-adapter.js';
+import { opencodeClient } from './opencode/client.js';
+import { outputBuffer } from './opencode/output-buffer.js';
+import { delayedResponseHandler } from './opencode/delayed-handler.js';
+import { questionHandler } from './opencode/question-handler.js';
+import { permissionHandler } from './permissions/handler.js';
+import { chatSessionStore } from './store/chat-session.js';
+import { lifecycleHandler } from './handlers/lifecycle.js';
+import { createDiscordHandler } from './handlers/discord.js';
+import { commandHandler } from './handlers/command.js';
+import { validateConfig, routerConfig, outputConfig, reliabilityConfig, opencodeConfig } from './config.js';
+import { rootRouter } from './router/root-router.js';
+import { ConversationHeartbeatEngine } from './reliability/conversation-heartbeat.js';
+import { CronScheduler } from './reliability/scheduler.js';
+import { createInternalJobRegistry } from './reliability/job-registry.js';
+import { createProcessCheckJobRunner, createRepairBudgetState } from './reliability/process-check-job.js';
+import { createProactiveHeartbeatRunner } from './reliability/proactive-heartbeat.js';
+import { RuntimeCronManager } from './reliability/runtime-cron.js';
+import { createCronApiServer } from './reliability/cron-api-server.js';
+import { getRuntimeCronManager, setRuntimeCronManager } from './reliability/runtime-cron-registry.js';
+import { createRuntimeCronDispatcher } from './reliability/runtime-cron-dispatcher.js';
+import { cleanupRuntimeCronJobsByConversation, scanAndCleanupOrphanRuntimeCronJobs } from './reliability/runtime-cron-orphan.js';
+import { probeOpenCodeHealth } from './reliability/opencode-probe.js';
+import { decideRescuePolicy } from './reliability/rescue-policy.js';
+import { executeRescuePipeline } from './reliability/rescue-executor.js';
+import { reportRecoveryContext } from './reliability/recovery-reporter.js';
+import { FailureType, RescueState } from './reliability/types.js';
+import { createPermissionActionCallbacks, createQuestionActionCallbacks, } from './router/action-handlers.js';
+import { openCodeEventHub } from './router/opencode-event-hub.js';
+import { buildStreamCards, } from './feishu/cards-stream.js';
+export const createRescueOrchestrator = (logger = console) => {
+    let rescueState = RescueState.HEALTHY;
+    let failureCount = 0;
+    let firstFailureAtMs = 0;
+    let repairBudgetRemaining = reliabilityConfig.repairBudget;
+    let lastRepairAtMs;
+    const HEALTHY_LOG_INTERVAL_MS = 10 * 60 * 1000;
+    const WAIT_LOG_INTERVAL_MS = 5 * 60 * 1000;
+    let lastHealthyLogAtMs = 0;
+    let lastPolicyLogAtMs = 0;
+    let lastPolicySignature = '';
+    return {
+        runWatchdogProbe: async () => {
+            const nowMs = Date.now();
+            try {
+                const probeResult = await probeOpenCodeHealth({
+                    host: opencodeConfig.host,
+                    port: opencodeConfig.port,
+                });
+                if (probeResult.ok) {
+                    failureCount = 0;
+                    firstFailureAtMs = 0;
+                    rescueState = RescueState.HEALTHY;
+                    const shouldLogHealthy = lastHealthyLogAtMs === 0 || nowMs - lastHealthyLogAtMs >= HEALTHY_LOG_INTERVAL_MS;
+                    if (shouldLogHealthy) {
+                        logger.info('[Reliability] watchdog probe healthy');
+                        lastHealthyLogAtMs = nowMs;
+                    }
+                    return;
+                }
+                failureCount += 1;
+                if (firstFailureAtMs === 0) {
+                    firstFailureAtMs = nowMs;
+                }
+                const failureType = probeResult.failureType ?? FailureType.OPENCODE_HTTP_DOWN;
+                const policyDecision = decideRescuePolicy({
+                    failureType,
+                    currentState: rescueState,
+                    latestAttemptFailed: true,
+                    nowMs,
+                    retry: {
+                        mode: 'infinite',
+                        attempt: failureCount,
+                        failureCount,
+                        firstFailureAtMs,
+                    },
+                    rescue: {
+                        targetHost: opencodeConfig.host,
+                        budgetRemaining: repairBudgetRemaining,
+                        lastRepairAtMs,
+                    },
+                });
+                rescueState = policyDecision.nextState;
+                repairBudgetRemaining = policyDecision.nextBudgetRemaining;
+                if (policyDecision.action !== 'repair') {
+                    const signature = `${policyDecision.action}:${policyDecision.reason}`;
+                    const shouldLogPolicy = signature !== lastPolicySignature
+                        || lastPolicyLogAtMs === 0
+                        || nowMs - lastPolicyLogAtMs >= WAIT_LOG_INTERVAL_MS;
+                    if (shouldLogPolicy) {
+                        logger.info(`[Reliability] watchdog policy=${policyDecision.action} reason=${policyDecision.reason}`);
+                        lastPolicyLogAtMs = nowMs;
+                        lastPolicySignature = signature;
+                    }
+                    return;
+                }
+                logger.info(`[Reliability] watchdog rescue start reason=${policyDecision.reason}`);
+                const startOpenCode = async () => {
+                    return new Promise((resolve, reject) => {
+                        try {
+                            const child = spawn('opencode', [], {
+                                detached: true,
+                                stdio: 'ignore',
+                            });
+                            child.unref();
+                            setTimeout(() => resolve(), 2000);
+                        }
+                        catch (error) {
+                            reject(error);
+                        }
+                    });
+                };
+                const rescueResult = await executeRescuePipeline({
+                    lockTargetPath: './logs/opencode-rescue',
+                    pidFilePath: './logs/opencode.pid',
+                    host: opencodeConfig.host,
+                    port: opencodeConfig.port,
+                    configPath: process.env.OPENCODE_CONFIG_FILE?.trim() || './opencode.json',
+                    serverFields: {
+                        host: opencodeConfig.host,
+                        port: opencodeConfig.port,
+                        auth: {
+                            username: opencodeConfig.serverUsername,
+                            password: opencodeConfig.serverPassword,
+                        },
+                    },
+                    startOpenCode,
+                });
+                if (!rescueResult.ok) {
+                    rescueState = RescueState.DEGRADED;
+                    logger.error(`[Reliability] rescue failed step=${rescueResult.failedStep} reason=${rescueResult.reason}`);
+                    return;
+                }
+                lastRepairAtMs = Date.now();
+                rescueState = RescueState.RECOVERED;
+                await reportRecoveryContext({
+                    failureType,
+                    failureReason: policyDecision.reason,
+                    backupPath: rescueResult.config.backup.path,
+                    nextActions: [
+                        '检查 OpenCode 健康端点与认证配置是否长期稳定',
+                        '观察下一轮 watchdog 探针，确认故障不再复现',
+                    ],
+                    selfCheckCommands: [
+                        'npm run build',
+                        'npm test -- tests/reliability-bootstrap.test.ts',
+                    ],
+                    context: {
+                        policyAction: policyDecision.action,
+                        policyReason: policyDecision.reason,
+                        trace: rescueResult.trace,
+                        health: rescueResult.health,
+                    },
+                });
+                logger.info('[Reliability] rescue succeeded and recovery context reported');
+            }
+            catch (error) {
+                logger.error('[Reliability] watchdog probe failed:', error);
+            }
+        },
+        runStaleCleanup: async () => {
+            logger.info('[Reliability] stale cleanup tick');
+        },
+        runBudgetReset: async () => {
+            logger.info('[Reliability] budget reset tick');
+        },
+        cleanup: async () => {
+            logger.info('[Reliability] rescue orchestrator cleaned');
+        },
+    };
+};
+export const bootstrapReliabilityLifecycle = (dependencies = {}) => {
+    const logger = dependencies.logger ?? console;
+    const shouldUseInboundHeartbeat = reliabilityConfig.inboundHeartbeatEnabled || Boolean(dependencies.createHeartbeatEngine);
+    const heartbeatEngine = dependencies.createHeartbeatEngine?.()
+        ?? new ConversationHeartbeatEngine({
+            windowMs: reliabilityConfig.heartbeatIntervalMs,
+        });
+    const scheduler = dependencies.createScheduler?.() ?? new CronScheduler();
+    const rescueOrchestrator = dependencies.createRescueOrchestrator?.() ?? createRescueOrchestrator(logger);
+    // 初始化 process check job runner
+    const repairBudgetState = createRepairBudgetState(reliabilityConfig.repairBudget);
+    const processCheckRunner = createProcessCheckJobRunner({
+        bridgePidFilePath: './logs/bridge.pid',
+        opencodePidFilePath: './logs/opencode.pid',
+        opencodeHost: 'localhost',
+        opencodePort: 4096,
+        repairBudgetState,
+        staleLockPaths: [],
+    });
+    const jobHandlers = {
+        watchdogProbe: async () => {
+            await rescueOrchestrator.runWatchdogProbe();
+        },
+        processConsistencyCheck: async () => {
+            await processCheckRunner.checkProcessConsistency();
+        },
+        staleCleanup: async () => {
+            await rescueOrchestrator.runStaleCleanup();
+            await cleanupOrphanCronJobs();
+        },
+        budgetReset: async () => {
+            await processCheckRunner.resetBudget();
+        },
+    };
+    const registry = dependencies.createJobRegistry?.(jobHandlers)
+        ?? {
+            registerAll: (injectedScheduler) => {
+                if (!(injectedScheduler instanceof CronScheduler)) {
+                    throw new Error('[Reliability] 默认任务注册器要求 CronScheduler 实例');
+                }
+                createInternalJobRegistry({
+                    handlers: jobHandlers,
+                }).registerAll(injectedScheduler);
+            },
+        };
+    registry.registerAll(scheduler);
+    let runtimeCronManager = null;
+    const runtimeCronDispatcher = createRuntimeCronDispatcher({
+        getSessionById: async (sessionId, options) => {
+            return await opencodeClient.getSessionById(sessionId, options);
+        },
+        sendMessage: async (sessionId, text, options) => {
+            return await opencodeClient.sendMessage(sessionId, text, options);
+        },
+        sendMessageAsync: async (sessionId, text, options) => {
+            await opencodeClient.sendMessageAsync(sessionId, text, options);
+            return true;
+        },
+        getSender: platform => {
+            if (platform === 'feishu') {
+                return feishuAdapter.getSender();
+            }
+            if (platform === 'discord') {
+                return discordAdapter.getSender();
+            }
+            return null;
+        },
+        logger: {
+            info: message => {
+                logger.info(message);
+            },
+            warn: message => {
+                logger.info(message);
+            },
+            error: (...args) => {
+                logger.error('[RuntimeCronDispatch]', ...args);
+            },
+        },
+    });
+    if (scheduler instanceof CronScheduler) {
+        runtimeCronManager = new RuntimeCronManager({
+            scheduler,
+            filePath: reliabilityConfig.cronJobsFile,
+            dispatchPayload: async (job) => {
+                await runtimeCronDispatcher.dispatch(job);
+            },
+            logger: {
+                info: message => {
+                    logger.info(message);
+                },
+                warn: message => {
+                    logger.info(message);
+                },
+                error: (...args) => {
+                    logger.error('[RuntimeCron]', ...args);
+                },
+            },
+        });
+        setRuntimeCronManager(runtimeCronManager);
+    }
+    else {
+        logger.info('[Reliability] 当前 scheduler 非 CronScheduler，跳过 runtime cron manager 注入');
+        setRuntimeCronManager(null);
+    }
+    const cleanupOrphanCronJobs = async () => {
+        if (!runtimeCronManager || !reliabilityConfig.cronOrphanAutoCleanup) {
+            return;
+        }
+        const cleanup = await scanAndCleanupOrphanRuntimeCronJobs(runtimeCronManager, {
+            hasConversationBinding: (platform, conversationId, sessionId) => {
+                const binding = chatSessionStore.getSessionByConversation(platform, conversationId);
+                if (!binding) {
+                    return false;
+                }
+                return !sessionId || binding.sessionId === sessionId;
+            },
+            getSessionStatus: async (sessionId, directory) => {
+                try {
+                    const session = await opencodeClient.getSessionById(sessionId, directory ? { directory } : undefined);
+                    return session ? 'exists' : 'missing';
+                }
+                catch {
+                    return 'unknown';
+                }
+            },
+        });
+        if (cleanup.removedJobIds.length > 0) {
+            logger.info(`[RuntimeCron] orphan cleanup removed ${cleanup.removedJobIds.length} job(s)`);
+        }
+    };
+    const proactiveHeartbeatRunner = createProactiveHeartbeatRunner({
+        enabled: reliabilityConfig.proactiveHeartbeatEnabled,
+        intervalMs: reliabilityConfig.heartbeatIntervalMs,
+        prompt: reliabilityConfig.heartbeatPrompt || '',
+        agent: reliabilityConfig.heartbeatAgent,
+        client: {
+            createSession: async (title, directory) => {
+                const created = await opencodeClient.createSession(title, directory);
+                return { id: created.id };
+            },
+            getSessionById: async (sessionId, options) => {
+                return await opencodeClient.getSessionById(sessionId, options);
+            },
+            sendMessage: async (sessionId, text, options) => {
+                const response = await opencodeClient.sendMessage(sessionId, text, options);
+                return { parts: response.parts };
+            },
+        },
+        notifyAlert: async (alertText) => {
+            if (reliabilityConfig.heartbeatAlertChats.length === 0) {
+                return;
+            }
+            const sender = feishuAdapter.getSender();
+            for (const chatId of reliabilityConfig.heartbeatAlertChats) {
+                try {
+                    await sender.sendText(chatId, `⚠️ [Heartbeat Alert]\n${alertText}`);
+                }
+                catch (error) {
+                    logger.error(`[Heartbeat] 发送告警失败 chat=${chatId}:`, error);
+                }
+            }
+        },
+        logger: {
+            info: message => {
+                logger.info(message);
+            },
+            warn: message => {
+                logger.info(message);
+            },
+            error: (...args) => {
+                logger.error(...args);
+            },
+        },
+    });
+    let cronApiServer = null;
+    if (reliabilityConfig.cronApiEnabled && runtimeCronManager) {
+        cronApiServer = createCronApiServer(runtimeCronManager, {
+            host: reliabilityConfig.cronApiHost,
+            port: reliabilityConfig.cronApiPort,
+            token: reliabilityConfig.cronApiToken,
+            logger: {
+                info: message => {
+                    logger.info(message);
+                },
+                warn: message => {
+                    logger.info(message);
+                },
+                error: (...args) => {
+                    logger.error(...args);
+                },
+            },
+        });
+        void cronApiServer.start().catch(error => {
+            logger.error('[RuntimeCronAPI] 启动失败:', error);
+        });
+    }
+    if (reliabilityConfig.cronEnabled) {
+        void cleanupOrphanCronJobs().catch(error => {
+            logger.error('[RuntimeCron] startup orphan cleanup failed:', error);
+        });
+        scheduler.start();
+    }
+    proactiveHeartbeatRunner.start();
+    logger.info('[Reliability] bootstrap 完成（heartbeat + scheduler + rescue orchestrator）');
+    let cleaned = false;
+    return {
+        onInboundMessage: async () => {
+            if (!shouldUseInboundHeartbeat) {
+                return;
+            }
+            try {
+                await heartbeatEngine.onInboundMessage();
+            }
+            catch (error) {
+                logger.error('[Heartbeat] 入站触发执行失败:', error);
+            }
+        },
+        cleanup: async () => {
+            if (cleaned) {
+                return;
+            }
+            cleaned = true;
+            await Promise.all([
+                scheduler.stop(),
+                Promise.resolve(rescueOrchestrator.cleanup()),
+                Promise.resolve(proactiveHeartbeatRunner.stop()),
+                cronApiServer ? cronApiServer.stop() : Promise.resolve(),
+            ]);
+            setRuntimeCronManager(null);
+            logger.info('[Reliability] cleanup 完成');
+        },
+    };
+};
+async function main() {
+    console.log('╔════════════════════════════════════════════════╗');
+    console.log('║   飞书 × OpenCode 桥接服务 v2.9.0-beta (Group)  ║');
+    console.log('╚════════════════════════════════════════════════╝');
+    // 1. 验证配置
+    try {
+        validateConfig();
+    }
+    catch (error) {
+        console.error('配置错误:', error);
+        process.exit(1);
+    }
+    // 1.5. 路由器模式配置
+    console.log(`[Config] 路由器模式: ${routerConfig.mode}`);
+    if (routerConfig.enabledPlatforms.length > 0) {
+        console.log(`[Config] 启用的平台: ${routerConfig.enabledPlatforms.join(', ')}`);
+    }
+    else {
+        console.log(`[Config] 平台过滤: 未指定（所有平台可用）`);
+    }
+    if (routerConfig.mode === 'dual') {
+        console.log(`[Config] ⚠️  双轨模式: 将记录新旧路由对比日志，不改变当前行为`);
+        console.log(`[Config] 📝 如需回滚到旧版路由，设置 ROUTER_MODE=legacy 并重启服务`);
+    }
+    // 2. 连接 OpenCode
+    const connected = await opencodeClient.connect();
+    if (!connected) {
+        console.error('无法连接到OpenCode服务器，请确保 opencode serve 已运行');
+        process.exit(1);
+    }
+    // 3. 配置输出缓冲 (流式响应)
+    const streamContentMap = new Map();
+    const reasoningSnapshotMap = new Map();
+    const textSnapshotMap = new Map();
+    const retryNoticeMap = new Map();
+    const errorNoticeMap = new Map();
+    const streamCardMessageIdsMap = new Map();
+    const STREAM_CARD_COMPONENT_BUDGET = 180;
+    const CORRELATION_CACHE_TTL_MS = 10 * 60 * 1000;
+    const toolCallChatMap = new Map();
+    const messageChatMap = new Map();
+    const streamToolStateMap = new Map();
+    const streamTimelineMap = new Map();
+    const getPendingPermissionForChat = (chatId) => {
+        const head = permissionHandler.peekForChat(chatId);
+        if (!head)
+            return undefined;
+        const pendingCount = permissionHandler.getQueueSizeForChat(chatId);
+        return {
+            sessionId: head.sessionId,
+            permissionId: head.permissionId,
+            tool: head.tool,
+            description: head.description,
+            risk: head.risk,
+            pendingCount,
+        };
+    };
+    const getOrCreateTimelineState = (bufferKey) => {
+        let timeline = streamTimelineMap.get(bufferKey);
+        if (!timeline) {
+            timeline = {
+                order: [],
+                segments: new Map(),
+            };
+            streamTimelineMap.set(bufferKey, timeline);
+        }
+        return timeline;
+    };
+    const trimTimeline = (timeline) => {
+        const limit = 80;
+        while (timeline.order.length > limit) {
+            const removedKey = timeline.order.shift();
+            if (removedKey) {
+                timeline.segments.delete(removedKey);
+            }
+        }
+    };
+    const upsertTimelineSegment = (bufferKey, segmentKey, segment) => {
+        const timeline = getOrCreateTimelineState(bufferKey);
+        if (!timeline.segments.has(segmentKey)) {
+            timeline.order.push(segmentKey);
+            trimTimeline(timeline);
+        }
+        timeline.segments.set(segmentKey, segment);
+    };
+    const appendTimelineText = (bufferKey, segmentKey, type, deltaText) => {
+        if (!deltaText)
+            return;
+        const timeline = getOrCreateTimelineState(bufferKey);
+        const previous = timeline.segments.get(segmentKey);
+        if (previous && previous.type === type) {
+            timeline.segments.set(segmentKey, {
+                type,
+                text: `${previous.text}${deltaText}`,
+            });
+            return;
+        }
+        if (!timeline.segments.has(segmentKey)) {
+            timeline.order.push(segmentKey);
+            trimTimeline(timeline);
+        }
+        timeline.segments.set(segmentKey, {
+            type,
+            text: deltaText,
+        });
+    };
+    const setTimelineText = (bufferKey, segmentKey, type, text) => {
+        const timeline = getOrCreateTimelineState(bufferKey);
+        const previous = timeline.segments.get(segmentKey);
+        if (previous && previous.type === type && previous.text === text) {
+            return;
+        }
+        if (!timeline.segments.has(segmentKey)) {
+            timeline.order.push(segmentKey);
+            trimTimeline(timeline);
+        }
+        timeline.segments.set(segmentKey, { type, text });
+    };
+    const upsertTimelineTool = (bufferKey, toolKey, state, kind = 'tool') => {
+        const segmentKey = `tool:${toolKey}`;
+        const timeline = getOrCreateTimelineState(bufferKey);
+        const previous = timeline.segments.get(segmentKey);
+        if (previous && previous.type === 'tool') {
+            timeline.segments.set(segmentKey, {
+                type: 'tool',
+                name: state.name,
+                status: state.status,
+                output: state.output ?? previous.output,
+                kind,
+            });
+            return;
+        }
+        if (!timeline.segments.has(segmentKey)) {
+            timeline.order.push(segmentKey);
+            trimTimeline(timeline);
+        }
+        timeline.segments.set(segmentKey, {
+            type: 'tool',
+            name: state.name,
+            status: state.status,
+            ...(state.output !== undefined ? { output: state.output } : {}),
+            kind,
+        });
+    };
+    const upsertTimelineNote = (bufferKey, noteKey, text, variant) => {
+        upsertTimelineSegment(bufferKey, `note:${noteKey}`, {
+            type: 'note',
+            text,
+            ...(variant ? { variant } : {}),
+        });
+    };
+    // 注入动作处理回调到 RootRouter
+    rootRouter.setPermissionCallbacks(createPermissionActionCallbacks(upsertTimelineNote));
+    rootRouter.setQuestionCallbacks(createQuestionActionCallbacks());
+    const discordHandler = createDiscordHandler(discordAdapter.getSender());
+    const getTimelineSegments = (bufferKey) => {
+        const timeline = streamTimelineMap.get(bufferKey);
+        if (!timeline) {
+            return [];
+        }
+        const segments = [];
+        for (const key of timeline.order) {
+            const segment = timeline.segments.get(key);
+            if (!segment)
+                continue;
+            if (segment.type === 'text' || segment.type === 'reasoning') {
+                if (!segment.text.trim())
+                    continue;
+                segments.push({
+                    type: segment.type,
+                    text: segment.text,
+                });
+                continue;
+            }
+            if (segment.type === 'tool') {
+                segments.push({
+                    type: 'tool',
+                    name: segment.name,
+                    status: segment.status,
+                    ...(segment.output !== undefined ? { output: segment.output } : {}),
+                    ...(segment.kind ? { kind: segment.kind } : {}),
+                });
+                continue;
+            }
+            if (!segment.text.trim())
+                continue;
+            segments.push({
+                type: 'note',
+                text: segment.text,
+                ...(segment.variant ? { variant: segment.variant } : {}),
+            });
+        }
+        return segments;
+    };
+    const getPendingQuestionForBuffer = (sessionId, chatId) => {
+        const pending = questionHandler.getBySession(sessionId);
+        if (!pending || pending.chatId !== chatId) {
+            return undefined;
+        }
+        const totalQuestions = pending.request.questions.length;
+        if (totalQuestions === 0) {
+            return undefined;
+        }
+        const safeIndex = Math.min(Math.max(pending.currentQuestionIndex, 0), totalQuestions - 1);
+        const question = pending.request.questions[safeIndex];
+        if (!question) {
+            return undefined;
+        }
+        return {
+            requestId: pending.request.id,
+            sessionId: pending.request.sessionID,
+            chatId: pending.chatId,
+            questionIndex: safeIndex,
+            totalQuestions,
+            header: typeof question.header === 'string' ? question.header : '',
+            question: typeof question.question === 'string' ? question.question : '',
+            options: Array.isArray(question.options)
+                ? question.options.map(option => ({
+                    label: typeof option.label === 'string' ? option.label : '',
+                    description: typeof option.description === 'string' ? option.description : '',
+                }))
+                : [],
+            multiple: question.multiple === true,
+        };
+    };
+    const toSessionId = (value) => {
+        return typeof value === 'string' ? value : '';
+    };
+    const toNonEmptyString = (value) => {
+        if (typeof value !== 'string') {
+            return undefined;
+        }
+        const normalized = value.trim();
+        return normalized.length > 0 ? normalized : undefined;
+    };
+    const setCorrelationChatRef = (map, key, chatId) => {
+        const normalizedKey = toNonEmptyString(key);
+        const normalizedChatId = toNonEmptyString(chatId);
+        if (!normalizedKey || !normalizedChatId) {
+            return;
+        }
+        map.set(normalizedKey, {
+            chatId: normalizedChatId,
+            expiresAt: Date.now() + CORRELATION_CACHE_TTL_MS,
+        });
+    };
+    const getCorrelationChatRef = (map, key) => {
+        const normalizedKey = toNonEmptyString(key);
+        if (!normalizedKey) {
+            return undefined;
+        }
+        const entry = map.get(normalizedKey);
+        if (!entry) {
+            return undefined;
+        }
+        if (entry.expiresAt <= Date.now()) {
+            map.delete(normalizedKey);
+            return undefined;
+        }
+        if (!chatSessionStore.hasConversationId(entry.chatId)) {
+            map.delete(normalizedKey);
+            return undefined;
+        }
+        return entry.chatId;
+    };
+    const resolvePermissionChat = (event) => {
+        const directChatId = chatSessionStore.getChatId(event.sessionId);
+        if (directChatId) {
+            return { chatId: directChatId, source: 'session' };
+        }
+        const parentSessionId = toNonEmptyString(event.parentSessionId);
+        if (parentSessionId) {
+            const parentChatId = chatSessionStore.getChatId(parentSessionId);
+            if (parentChatId) {
+                return { chatId: parentChatId, source: 'parent_session' };
+            }
+        }
+        const relatedSessionId = toNonEmptyString(event.relatedSessionId);
+        if (relatedSessionId) {
+            const relatedChatId = chatSessionStore.getChatId(relatedSessionId);
+            if (relatedChatId) {
+                return { chatId: relatedChatId, source: 'related_session' };
+            }
+        }
+        const toolCallChatId = getCorrelationChatRef(toolCallChatMap, event.callId);
+        if (toolCallChatId) {
+            return { chatId: toolCallChatId, source: 'tool_call' };
+        }
+        const messageChatId = getCorrelationChatRef(messageChatMap, event.messageId);
+        if (messageChatId) {
+            return { chatId: messageChatId, source: 'message' };
+        }
+        return { source: 'unresolved' };
+    };
+    const resolveSessionConversation = (sessionId) => {
+        const conversation = chatSessionStore.getConversationBySessionId(sessionId);
+        if (conversation) {
+            return {
+                platform: conversation.platform,
+                conversationId: conversation.conversationId,
+            };
+        }
+        const feishuChatId = chatSessionStore.getChatId(sessionId);
+        if (feishuChatId) {
+            return {
+                platform: 'feishu',
+                conversationId: feishuChatId,
+            };
+        }
+        return null;
+    };
+    const buildBufferKeyBySession = (sessionId, conversationId) => {
+        const conversation = resolveSessionConversation(sessionId);
+        const platform = conversation?.platform ?? 'feishu';
+        const resolvedConversationId = conversation?.conversationId ?? conversationId;
+        if (platform === 'feishu') {
+            return `chat:${resolvedConversationId}`;
+        }
+        return `chat:${platform}:${resolvedConversationId}`;
+    };
+    const buildPermissionQueueKeyBySession = (sessionId, conversationId) => {
+        const conversation = resolveSessionConversation(sessionId);
+        const platform = conversation?.platform ?? 'feishu';
+        const resolvedConversationId = conversation?.conversationId ?? conversationId;
+        if (platform === 'feishu') {
+            return resolvedConversationId;
+        }
+        return `${platform}:${resolvedConversationId}`;
+    };
+    const buildPortableUpdateText = (data, showThinking = true) => {
+        const mainText = data.text.trim();
+        const thinkingText = showThinking ? data.thinking.trim() : '';
+        if (mainText && thinkingText) {
+            const safeThinking = thinkingText.replace(/```/g, '` ` `');
+            const clippedThinking = safeThinking.length > 1400
+                ? `${safeThinking.slice(0, 1400)}\n...(思考内容已截断)`
+                : safeThinking;
+            return [
+                '-----------',
+                '```md',
+                clippedThinking,
+                '```',
+                '-----------',
+                mainText,
+            ].join('\n');
+        }
+        if (mainText) {
+            return `-----------\n${mainText}`;
+        }
+        if (thinkingText) {
+            const safeThinking = thinkingText.replace(/```/g, '` ` `');
+            const clippedThinking = safeThinking.length > 1400
+                ? `${safeThinking.slice(0, 1400)}\n...(思考内容已截断)`
+                : safeThinking;
+            return [
+                '-----------',
+                '```md',
+                clippedThinking,
+                '```',
+                '-----------',
+                '⏳ 正在处理...',
+            ].join('\n');
+        }
+        if (data.status === 'failed') {
+            return '❌ 执行失败';
+        }
+        if (data.status === 'completed') {
+            return '✅ 已完成';
+        }
+        return '⏳ 正在处理...';
+    };
+    const buildPortableUpdatePayload = (data, conversationId, platform = 'feishu') => {
+        // 根据平台读取可见性配置
+        const showThinkingChain = platform === 'discord'
+            ? outputConfig.discord.showThinkingChain
+            : platform === 'feishu'
+                ? outputConfig.feishu.showThinkingChain
+                : outputConfig.showThinkingChain;
+        const showToolChain = platform === 'discord'
+            ? outputConfig.discord.showToolChain
+            : platform === 'feishu'
+                ? outputConfig.feishu.showToolChain
+                : outputConfig.showToolChain;
+        // 过滤 segments，移除 tool 和 reasoning 类型（当对应开关关闭时）
+        const filteredSegments = showToolChain && showThinkingChain
+            ? data.segments
+            : (data.segments ?? []).filter(segment => {
+                if (!showToolChain && segment.type === 'tool')
+                    return false;
+                if (!showThinkingChain && segment.type === 'reasoning')
+                    return false;
+                return true;
+            });
+        const filteredData = {
+            ...data,
+            segments: filteredSegments,
+        };
+        const baseText = buildPortableUpdateText(filteredData, showThinkingChain);
+        if (!data.pendingQuestion) {
+            return { discordText: baseText };
+        }
+        const questionLine = `❓ ${data.pendingQuestion.question}`;
+        const progressLine = `第 ${data.pendingQuestion.questionIndex + 1}/${data.pendingQuestion.totalQuestions} 题`;
+        const discordText = `${baseText}\n${questionLine}\n${progressLine}`;
+        const optionList = data.pendingQuestion.options
+            .filter(option => option.label.trim().length > 0)
+            .slice(0, 24)
+            .map(option => ({
+            label: option.label,
+            value: option.label,
+            ...(option.description ? { description: option.description } : {}),
+        }));
+        const options = [...optionList, {
+                label: '跳过本题',
+                value: '__skip__',
+                description: '留空并进入下一题',
+            }];
+        if (options.length === 0) {
+            return { discordText };
+        }
+        const maxValues = data.pendingQuestion.multiple
+            ? Math.min(Math.max(1, optionList.length), 25)
+            : 1;
+        return {
+            discordText,
+            discordComponents: [
+                {
+                    type: 'select',
+                    customId: `oc_question:${conversationId}`,
+                    placeholder: '选择当前问题答案',
+                    options,
+                    minValues: 1,
+                    maxValues,
+                },
+            ],
+        };
+    };
+    const normalizeToolStatus = (status) => {
+        if (status === 'pending' || status === 'running' || status === 'completed') {
+            return status;
+        }
+        if (status === 'error' || status === 'failed') {
+            return 'failed';
+        }
+        return 'running';
+    };
+    const getToolStatusText = (status) => {
+        if (status === 'pending')
+            return '等待中';
+        if (status === 'running')
+            return '执行中';
+        if (status === 'completed')
+            return '已完成';
+        return '失败';
+    };
+    const stringifyToolOutput = (value) => {
+        if (value === undefined || value === null)
+            return undefined;
+        if (typeof value === 'string')
+            return value;
+        try {
+            return JSON.stringify(value, null, 2);
+        }
+        catch {
+            return String(value);
+        }
+    };
+    const asRecord = (value) => {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return null;
+        }
+        return value;
+    };
+    const pickFirstDefined = (...values) => {
+        for (const value of values) {
+            if (value !== undefined && value !== null) {
+                return value;
+            }
+        }
+        return undefined;
+    };
+    const buildToolTraceOutput = (part, status, withInput) => {
+        const state = asRecord(part.state);
+        const inputValue = withInput
+            ? pickFirstDefined(part.input, part.args, part.arguments, state?.input, state?.args, state?.arguments)
+            : undefined;
+        const outputValue = status === 'failed'
+            ? pickFirstDefined(state?.error, state?.output, part.error)
+            : pickFirstDefined(state?.output, state?.result, state?.message, part.output, part.result);
+        const inputText = stringifyToolOutput(inputValue);
+        const outputText = stringifyToolOutput(outputValue);
+        const blocks = [];
+        if (inputText && inputText.trim()) {
+            blocks.push(`调用参数:\n${inputText.trim()}`);
+        }
+        if (outputText && outputText.trim()) {
+            blocks.push(`${status === 'failed' ? '错误输出' : '执行输出'}:\n${outputText.trim()}`);
+        }
+        if (blocks.length === 0) {
+            return `状态更新：${getToolStatusText(status)}`;
+        }
+        return blocks.join('\n\n');
+    };
+    const TOOL_TRACE_LIMIT = 20000;
+    const clipToolTrace = (text) => {
+        if (text.length <= TOOL_TRACE_LIMIT) {
+            return text;
+        }
+        const retained = text.slice(-TOOL_TRACE_LIMIT);
+        return `...（历史输出过长，已截断前 ${text.length - TOOL_TRACE_LIMIT} 字）...\n${retained}`;
+    };
+    const mergeToolOutput = (previous, incoming) => {
+        if (!incoming || !incoming.trim()) {
+            return previous;
+        }
+        const next = incoming.trim();
+        if (!previous || !previous.trim()) {
+            return clipToolTrace(next);
+        }
+        const prev = previous.trim();
+        if (prev === next) {
+            return previous;
+        }
+        if (next.startsWith(prev) || next.includes(prev)) {
+            return clipToolTrace(next);
+        }
+        if (prev.startsWith(next) || prev.includes(next)) {
+            return previous;
+        }
+        return clipToolTrace(`${previous}\n\n---\n${next}`);
+    };
+    const getOrCreateToolStateBucket = (bufferKey) => {
+        let bucket = streamToolStateMap.get(bufferKey);
+        if (!bucket) {
+            bucket = new Map();
+            streamToolStateMap.set(bufferKey, bucket);
+        }
+        return bucket;
+    };
+    const syncToolsToBuffer = (bufferKey) => {
+        const bucket = streamToolStateMap.get(bufferKey);
+        if (!bucket) {
+            outputBuffer.setTools(bufferKey, []);
+            return;
+        }
+        outputBuffer.setTools(bufferKey, Array.from(bucket.values()).map(item => ({
+            name: item.name,
+            status: item.status,
+            ...(item.output !== undefined ? { output: item.output } : {}),
+        })));
+    };
+    const upsertToolState = (bufferKey, toolKey, nextState, kind = 'tool') => {
+        const bucket = getOrCreateToolStateBucket(bufferKey);
+        const previous = bucket.get(toolKey);
+        const mergedOutput = mergeToolOutput(previous?.output, nextState.output);
+        bucket.set(toolKey, {
+            name: nextState.name,
+            status: nextState.status,
+            output: mergedOutput,
+            kind: nextState.kind ?? previous?.kind ?? kind,
+        });
+        upsertTimelineTool(bufferKey, toolKey, {
+            name: nextState.name,
+            status: nextState.status,
+            output: mergedOutput,
+            kind: nextState.kind ?? previous?.kind ?? kind,
+        }, nextState.kind ?? previous?.kind ?? kind);
+        syncToolsToBuffer(bufferKey);
+    };
+    const markActiveToolsCompleted = (bufferKey) => {
+        const bucket = streamToolStateMap.get(bufferKey);
+        if (!bucket)
+            return;
+        for (const [toolKey, item] of bucket.entries()) {
+            if (item.status === 'running' || item.status === 'pending') {
+                bucket.set(toolKey, {
+                    ...item,
+                    status: 'completed',
+                });
+                upsertTimelineTool(bufferKey, toolKey, {
+                    ...item,
+                    status: 'completed',
+                }, item.kind ?? 'tool');
+            }
+        }
+        syncToolsToBuffer(bufferKey);
+    };
+    const appendTextFromPart = (sessionID, part, bufferKey) => {
+        if (typeof part.text !== 'string')
+            return;
+        if (typeof part.id !== 'string' || !part.id) {
+            outputBuffer.append(bufferKey, part.text);
+            appendTimelineText(bufferKey, `text:${sessionID}:anonymous`, 'text', part.text);
+            return;
+        }
+        const key = `${sessionID}:${part.id}`;
+        const prev = textSnapshotMap.get(key) || '';
+        const current = part.text;
+        if (current.startsWith(prev)) {
+            const deltaText = current.slice(prev.length);
+            if (deltaText) {
+                outputBuffer.append(bufferKey, deltaText);
+            }
+        }
+        else if (current !== prev) {
+            outputBuffer.append(bufferKey, current);
+        }
+        textSnapshotMap.set(key, current);
+        setTimelineText(bufferKey, `text:${key}`, 'text', current);
+    };
+    const appendReasoningFromPart = (sessionID, part, bufferKey) => {
+        if (typeof part.text !== 'string')
+            return;
+        if (typeof part.id !== 'string' || !part.id) {
+            outputBuffer.appendThinking(bufferKey, part.text);
+            appendTimelineText(bufferKey, `reasoning:${sessionID}:anonymous`, 'reasoning', part.text);
+            return;
+        }
+        const key = `${sessionID}:${part.id}`;
+        const prev = reasoningSnapshotMap.get(key) || '';
+        const current = part.text;
+        if (current.startsWith(prev)) {
+            const deltaText = current.slice(prev.length);
+            if (deltaText) {
+                outputBuffer.appendThinking(bufferKey, deltaText);
+            }
+        }
+        else if (current !== prev) {
+            outputBuffer.appendThinking(bufferKey, current);
+        }
+        reasoningSnapshotMap.set(key, current);
+        setTimelineText(bufferKey, `reasoning:${key}`, 'reasoning', current);
+    };
+    const clearPartSnapshotsForSession = (sessionID) => {
+        const prefix = `${sessionID}:`;
+        for (const key of reasoningSnapshotMap.keys()) {
+            if (key.startsWith(prefix)) {
+                reasoningSnapshotMap.delete(key);
+            }
+        }
+        for (const key of textSnapshotMap.keys()) {
+            if (key.startsWith(prefix)) {
+                textSnapshotMap.delete(key);
+            }
+        }
+        retryNoticeMap.delete(sessionID);
+        errorNoticeMap.delete(sessionID);
+    };
+    const formatProviderError = (raw) => {
+        if (!raw || typeof raw !== 'object') {
+            return '模型执行失败';
+        }
+        const error = raw;
+        const name = typeof error.name === 'string' ? error.name : 'UnknownError';
+        const data = error.data && typeof error.data === 'object' ? error.data : {};
+        if (name === 'APIError') {
+            const message = typeof data.message === 'string' ? data.message : '上游接口报错';
+            const statusCode = typeof data.statusCode === 'number' ? data.statusCode : undefined;
+            if (statusCode === 429) {
+                return `模型请求过快（429）：${message}`;
+            }
+            if (statusCode === 408 || statusCode === 504) {
+                return `模型响应超时：${message}`;
+            }
+            return statusCode ? `模型接口错误（${statusCode}）：${message}` : `模型接口错误：${message}`;
+        }
+        if (name === 'ProviderAuthError') {
+            const providerID = typeof data.providerID === 'string' ? data.providerID : 'unknown';
+            const message = typeof data.message === 'string' ? data.message : '鉴权失败';
+            return `模型鉴权失败（${providerID}）：${message}`;
+        }
+        if (name === 'MessageOutputLengthError') {
+            return '模型输出超过长度限制，已中断';
+        }
+        if (name === 'MessageAbortedError') {
+            const message = typeof data.message === 'string' ? data.message : '会话已中断';
+            return `会话已中断：${message}`;
+        }
+        const generic = typeof data.message === 'string' ? data.message : '';
+        return generic ? `${name}：${generic}` : `${name}`;
+    };
+    const upsertLiveCardInteraction = (chatId, replyMessageId, cardData, bodyMessageIds, thinkingMessageId, openCodeMsgId) => {
+        const botMessageIds = [...bodyMessageIds, thinkingMessageId].filter((id) => typeof id === 'string' && id.length > 0);
+        if (botMessageIds.length === 0) {
+            return;
+        }
+        let existing;
+        for (const msgId of botMessageIds) {
+            existing = chatSessionStore.findInteractionByBotMsgId(chatId, msgId);
+            if (existing) {
+                break;
+            }
+        }
+        if (existing) {
+            chatSessionStore.updateInteraction(chatId, r => r === existing, r => {
+                if (!r.userFeishuMsgId && replyMessageId) {
+                    r.userFeishuMsgId = replyMessageId;
+                }
+                for (const msgId of botMessageIds) {
+                    if (!r.botFeishuMsgIds.includes(msgId)) {
+                        r.botFeishuMsgIds.push(msgId);
+                    }
+                }
+                r.cardData = { ...cardData };
+                r.type = 'normal';
+                if (openCodeMsgId) {
+                    r.openCodeMsgId = openCodeMsgId;
+                }
+                r.timestamp = Date.now();
+            });
+            return;
+        }
+        chatSessionStore.addInteraction(chatId, {
+            userFeishuMsgId: replyMessageId || '',
+            openCodeMsgId: openCodeMsgId || '',
+            botFeishuMsgIds: botMessageIds,
+            type: 'normal',
+            cardData: { ...cardData },
+            timestamp: Date.now(),
+        });
+    };
+    const parsePermissionDecision = (raw) => {
+        const normalized = raw.normalize('NFKC').trim().toLowerCase();
+        if (!normalized)
+            return null;
+        const compact = normalized
+            .replace(/[\s\u3000]+/g, '')
+            .replace(/[。！!,.，；;:：\-]/g, '');
+        const hasAlways = compact.includes('始终') ||
+            compact.includes('永久') ||
+            compact.includes('always') ||
+            compact.includes('记住') ||
+            compact.includes('总是');
+        const containsAny = (words) => {
+            return words.some(word => compact === word || compact.includes(word));
+        };
+        const isDeny = compact === 'n' ||
+            compact === 'no' ||
+            compact === '否' ||
+            compact === '拒绝' ||
+            containsAny(['拒绝', '不同意', '不允许', 'deny']);
+        if (isDeny) {
+            return { allow: false, remember: false };
+        }
+        const isAllow = compact === 'y' ||
+            compact === 'yes' ||
+            compact === 'ok' ||
+            compact === 'always' ||
+            compact === '允许' ||
+            compact === '始终允许' ||
+            containsAny(['允许', '同意', '通过', '批准', 'allow']);
+        if (isAllow) {
+            return { allow: true, remember: hasAlways };
+        }
+        return null;
+    };
+    const tryHandlePendingPermissionByText = async (event) => {
+        if (event.chatType !== 'group') {
+            return false;
+        }
+        const trimmedContent = event.content.trim();
+        if (!trimmedContent || trimmedContent.startsWith('/')) {
+            return false;
+        }
+        const pending = permissionHandler.peekForChat(event.chatId);
+        if (!pending) {
+            return false;
+        }
+        const decision = parsePermissionDecision(trimmedContent);
+        if (!decision) {
+            await feishuClient.reply(event.messageId, '当前有待确认权限，请回复：允许 / 拒绝 / 始终允许（也支持 y / n / always）');
+            return true;
+        }
+        const responded = await opencodeClient.respondToPermission(pending.sessionId, pending.permissionId, decision.allow, decision.remember);
+        if (!responded) {
+            console.error(`[权限] 文本响应失败: chat=${event.chatId}, session=${pending.sessionId}, permission=${pending.permissionId}`);
+            await feishuClient.reply(event.messageId, '权限响应失败，请重试');
+            return true;
+        }
+        const removed = permissionHandler.resolveForChat(event.chatId, pending.permissionId);
+        const bufferKey = `chat:${event.chatId}`;
+        if (!outputBuffer.get(bufferKey)) {
+            outputBuffer.getOrCreate(bufferKey, event.chatId, pending.sessionId, event.messageId);
+        }
+        const toolName = removed?.tool || pending.tool || '工具';
+        const resolvedText = decision.allow
+            ? decision.remember
+                ? `✅ 已允许并记住权限：${toolName}`
+                : `✅ 已允许权限：${toolName}`
+            : `❌ 已拒绝权限：${toolName}`;
+        upsertTimelineNote(bufferKey, `permission-result-text:${pending.sessionId}:${pending.permissionId}:${decision.allow ? 'allow' : 'deny'}:${decision.remember ? 'always' : 'once'}`, resolvedText, 'permission');
+        outputBuffer.touch(bufferKey);
+        await feishuClient.reply(event.messageId, decision.allow ? (decision.remember ? '已允许并记住该权限' : '已允许该权限') : '已拒绝该权限');
+        return true;
+    };
+    outputBuffer.setUpdateCallback(async (buffer) => {
+        const { text, thinking } = outputBuffer.getAndClear(buffer.key);
+        const timelineSegments = getTimelineSegments(buffer.key);
+        const sessionConversation = resolveSessionConversation(buffer.sessionId);
+        const platform = sessionConversation?.platform ?? 'feishu';
+        const conversationId = sessionConversation?.conversationId ?? buffer.chatId;
+        const permissionQueueKey = buildPermissionQueueKeyBySession(buffer.sessionId, conversationId);
+        const pendingPermission = getPendingPermissionForChat(permissionQueueKey);
+        const pendingQuestion = getPendingQuestionForBuffer(buffer.sessionId, conversationId);
+        if (!text &&
+            !thinking &&
+            timelineSegments.length === 0 &&
+            buffer.tools.length === 0 &&
+            !pendingPermission &&
+            !pendingQuestion &&
+            buffer.status === 'running')
+            return;
+        const current = streamContentMap.get(buffer.key) || { text: '', thinking: '' };
+        current.text += text;
+        current.thinking += thinking;
+        if (buffer.status !== 'running') {
+            if (buffer.finalText) {
+                current.text = buffer.finalText;
+            }
+            if (buffer.finalThinking) {
+                current.thinking = buffer.finalThinking;
+            }
+        }
+        streamContentMap.set(buffer.key, current);
+        const hasVisibleContent = current.text.trim().length > 0 ||
+            current.thinking.trim().length > 0 ||
+            buffer.tools.length > 0 ||
+            timelineSegments.length > 0 ||
+            Boolean(pendingPermission) ||
+            Boolean(pendingQuestion);
+        if (!hasVisibleContent && buffer.status === 'running')
+            return;
+        const status = buffer.status === 'failed' || buffer.status === 'aborted'
+            ? 'failed'
+            : buffer.status === 'completed'
+                ? 'completed'
+                : 'processing';
+        let existingMessageIds = streamCardMessageIdsMap.get(buffer.key) || [];
+        if (existingMessageIds.length === 0 && buffer.messageId) {
+            existingMessageIds = [buffer.messageId];
+        }
+        const cardData = {
+            text: current.text,
+            thinking: current.thinking,
+            chatId: conversationId,
+            messageId: existingMessageIds[0] || undefined,
+            tools: [...buffer.tools],
+            segments: timelineSegments,
+            ...(pendingPermission ? { pendingPermission } : {}),
+            ...(pendingQuestion ? { pendingQuestion } : {}),
+            status,
+            showThinking: false,
+        };
+        if (platform !== 'feishu') {
+            const sender = platform === 'discord' ? discordAdapter.getSender() : feishuAdapter.getSender();
+            const payload = buildPortableUpdatePayload(cardData, conversationId, platform);
+            const nextMessageIds = [];
+            const existingMessageId = existingMessageIds[0];
+            if (existingMessageId) {
+                const updated = await sender.updateCard(existingMessageId, payload);
+                if (updated) {
+                    nextMessageIds.push(existingMessageId);
+                }
+                else {
+                    const replacementMessageId = await sender.sendCard(conversationId, payload);
+                    if (replacementMessageId) {
+                        void sender.deleteMessage(existingMessageId).catch(() => undefined);
+                        nextMessageIds.push(replacementMessageId);
+                    }
+                }
+            }
+            else {
+                const newMessageId = await sender.sendCard(conversationId, payload);
+                if (newMessageId) {
+                    nextMessageIds.push(newMessageId);
+                }
+            }
+            for (let index = 1; index < existingMessageIds.length; index++) {
+                const redundantMessageId = existingMessageIds[index];
+                if (!redundantMessageId) {
+                    continue;
+                }
+                void sender.deleteMessage(redundantMessageId).catch(() => undefined);
+            }
+            if (nextMessageIds.length > 0) {
+                outputBuffer.setMessageId(buffer.key, nextMessageIds[0]);
+                streamCardMessageIdsMap.set(buffer.key, nextMessageIds);
+            }
+            else {
+                streamCardMessageIdsMap.delete(buffer.key);
+            }
+            if (buffer.status !== 'running') {
+                streamContentMap.delete(buffer.key);
+                streamToolStateMap.delete(buffer.key);
+                streamTimelineMap.delete(buffer.key);
+                streamCardMessageIdsMap.delete(buffer.key);
+                clearPartSnapshotsForSession(buffer.sessionId);
+                outputBuffer.clear(buffer.key);
+            }
+            return;
+        }
+        const cards = buildStreamCards({
+            ...cardData,
+            messageId: existingMessageIds[0] || undefined,
+        }, {
+            componentBudget: STREAM_CARD_COMPONENT_BUDGET,
+        });
+        const nextMessageIds = [];
+        const sender = feishuAdapter.getSender();
+        for (let index = 0; index < cards.length; index++) {
+            const card = cards[index];
+            const existingMessageId = existingMessageIds[index];
+            if (existingMessageId) {
+                const updated = await sender.updateCard(existingMessageId, card);
+                if (updated) {
+                    nextMessageIds.push(existingMessageId);
+                    continue;
+                }
+                const replacementMessageId = await sender.sendCard(conversationId, card);
+                if (replacementMessageId) {
+                    void sender.deleteMessage(existingMessageId).catch(() => undefined);
+                    nextMessageIds.push(replacementMessageId);
+                }
+                else {
+                    nextMessageIds.push(existingMessageId);
+                }
+                continue;
+            }
+            const newMessageId = await sender.sendCard(conversationId, card);
+            if (newMessageId) {
+                nextMessageIds.push(newMessageId);
+            }
+        }
+        for (let index = cards.length; index < existingMessageIds.length; index++) {
+            const redundantMessageId = existingMessageIds[index];
+            if (!redundantMessageId) {
+                continue;
+            }
+            void sender.deleteMessage(redundantMessageId).catch(() => undefined);
+        }
+        if (nextMessageIds.length > 0) {
+            outputBuffer.setMessageId(buffer.key, nextMessageIds[0]);
+            streamCardMessageIdsMap.set(buffer.key, nextMessageIds);
+        }
+        else {
+            streamCardMessageIdsMap.delete(buffer.key);
+        }
+        cardData.messageId = nextMessageIds[0] || undefined;
+        cardData.thinkingMessageId = undefined;
+        upsertLiveCardInteraction(conversationId, buffer.replyMessageId, cardData, nextMessageIds, null, buffer.openCodeMsgId);
+        if (buffer.status !== 'running') {
+            streamContentMap.delete(buffer.key);
+            streamToolStateMap.delete(buffer.key);
+            streamTimelineMap.delete(buffer.key);
+            streamCardMessageIdsMap.delete(buffer.key);
+            clearPartSnapshotsForSession(buffer.sessionId);
+            outputBuffer.clear(buffer.key);
+        }
+    });
+    // 3.5 初始化 Reliability 生命周期（heartbeat + scheduler + rescue orchestrator）
+    const reliabilityLifecycle = bootstrapReliabilityLifecycle();
+    // 4. 监听飞书消息（通过路由器分发）
+    feishuClient.on('message', async (event) => {
+        await reliabilityLifecycle.onInboundMessage();
+        await rootRouter.onMessage(event);
+    });
+    feishuClient.on('chatUnavailable', (chatId) => {
+        console.warn(`[Index] 检测到不可用群聊，移除会话绑定: ${chatId}`);
+        chatSessionStore.removeSession(chatId);
+    });
+    // 5. 监听飞书卡片动作（通过路由器分发）
+    feishuClient.setCardActionHandler(async (event) => {
+        return await rootRouter.onAction(event);
+    });
+    discordAdapter.onMessage(async (event) => {
+        await discordHandler.handleMessage(event);
+    });
+    discordAdapter.onInteraction(async (interaction) => {
+        await discordHandler.handleInteraction(interaction);
+    });
+    // 6. OpenCode 事件监听已移至 openCodeEventHub（单一入口）
+    // 6.5 注入事件处理上下文到 OpenCode Event Hub（必须在所有辅助函数声明之后）
+    const applyFailureToSession = async (sessionID, errorText) => {
+        const conversation = resolveSessionConversation(sessionID);
+        if (!conversation)
+            return;
+        const platform = conversation.platform;
+        const conversationId = conversation.conversationId;
+        const dedupeKey = `${sessionID}:${errorText}`;
+        if (errorNoticeMap.get(sessionID) === dedupeKey) {
+            return;
+        }
+        errorNoticeMap.set(sessionID, dedupeKey);
+        const bufferKey = buildBufferKeyBySession(sessionID, conversationId);
+        const existingBuffer = outputBuffer.get(bufferKey) || outputBuffer.getOrCreate(bufferKey, conversationId, sessionID, null);
+        upsertTimelineNote(bufferKey, `error:${sessionID}:${errorText}`, `❌ ${errorText}`, 'error');
+        outputBuffer.append(bufferKey, `\n\n❌ ${errorText}`);
+        outputBuffer.touch(bufferKey);
+        outputBuffer.setStatus(bufferKey, 'failed');
+        if (!existingBuffer.messageId) {
+            const sender = platform === 'discord' ? discordAdapter.getSender() : feishuAdapter.getSender();
+            await sender.sendText(conversationId, `❌ ${errorText}`);
+        }
+    };
+    openCodeEventHub.setContext({
+        CORRELATION_CACHE_TTL_MS,
+        streamContentMap,
+        reasoningSnapshotMap,
+        textSnapshotMap,
+        retryNoticeMap,
+        errorNoticeMap,
+        streamCardMessageIdsMap,
+        toolCallChatMap,
+        messageChatMap,
+        streamToolStateMap,
+        streamTimelineMap,
+        toSessionId,
+        toNonEmptyString,
+        setCorrelationChatRef,
+        getCorrelationChatRef,
+        resolvePermissionChat,
+        normalizeToolStatus,
+        getToolStatusText,
+        stringifyToolOutput,
+        asRecord,
+        pickFirstDefined,
+        buildToolTraceOutput,
+        clipToolTrace,
+        mergeToolOutput,
+        getOrCreateToolStateBucket,
+        syncToolsToBuffer,
+        upsertToolState,
+        markActiveToolsCompleted,
+        appendTextFromPart,
+        appendReasoningFromPart,
+        clearPartSnapshotsForSession,
+        formatProviderError,
+        upsertLiveCardInteraction,
+        getTimelineSegments,
+        getPendingPermissionForChat,
+        getPendingQuestionForBuffer,
+        applyFailureToSession,
+        upsertTimelineNote,
+        appendTimelineText,
+        setTimelineText,
+        upsertTimelineTool,
+    });
+    // 注册 OpenCode 事件监听器（单一入口）
+    openCodeEventHub.register();
+    // 7. 监听生命周期事件 (需要在启动后注册)
+    feishuClient.onMemberLeft(async (chatId, memberId) => {
+        await lifecycleHandler.handleMemberLeft(chatId, memberId);
+    });
+    feishuClient.onChatDisbanded(async (chatId) => {
+        console.log(`[Index] 群 ${chatId} 已解散`);
+        if (reliabilityConfig.cronOrphanAutoCleanup) {
+            cleanupRuntimeCronJobsByConversation(getRuntimeCronManager(), 'feishu', chatId);
+        }
+        chatSessionStore.removeSession(chatId);
+    });
+    feishuClient.onMessageRecalled(async (event) => {
+        // 处理撤回
+        // event.message_id, event.chat_id
+        // 如果撤回的消息是该会话最后一条 User Message，则触发 Undo
+        const chatId = event.chat_id;
+        const recalledMsgId = event.message_id;
+        if (chatId && recalledMsgId) {
+            const session = chatSessionStore.getSession(chatId);
+            if (session && session.lastFeishuUserMsgId === recalledMsgId) {
+                console.log(`[Index] 检测到用户撤回最后一条消息: ${recalledMsgId}`);
+                await commandHandler.handleUndo(chatId);
+            }
+        }
+    });
+    // 7.5. 启动 Discord 适配器（如果启用）
+    try {
+        await discordAdapter.start();
+    }
+    catch (e) {
+        console.error('[Discord] 启动失败:', e);
+        // Discord 启动失败不影响 Feishu 流程
+    }
+    // 8. 启动飞书客户端
+    await feishuClient.start();
+    // 9. 启动清理检查
+    await lifecycleHandler.cleanUpOnStart();
+    console.log('✅ 服务已就绪');
+    // 优雅退出处理
+    let shuttingDown = false;
+    const gracefulShutdown = async (signal) => {
+        if (shuttingDown) {
+            return;
+        }
+        shuttingDown = true;
+        console.log(`\n[${signal}] 正在关闭服务...`);
+        // 停止 reliability 调度和救援资源
+        try {
+            await reliabilityLifecycle.cleanup();
+        }
+        catch (e) {
+            console.error('停止 reliability 资源失败:', e);
+        }
+        // 停止 Discord 适配器
+        try {
+            discordAdapter.stop();
+        }
+        catch (e) {
+            console.error('停止 Discord 适配器失败:', e);
+        }
+        // 停止飞书连接
+        try {
+            feishuClient.stop();
+        }
+        catch (e) {
+            console.error('停止飞书连接失败:', e);
+        }
+        // 断开 OpenCode 连接
+        try {
+            opencodeClient.disconnect();
+        }
+        catch (e) {
+            console.error('断开 OpenCode 失败:', e);
+        }
+        // 清理所有缓冲区和定时器
+        try {
+            outputBuffer.clearAll();
+            delayedResponseHandler.cleanupExpired(0);
+            questionHandler.cleanupExpired(0);
+        }
+        catch (e) {
+            console.error('清理资源失败:', e);
+        }
+        // 延迟退出以确保所有清理完成
+        setTimeout(() => {
+            console.log('✅ 服务已安全关闭');
+            process.exit(0);
+        }, 500);
+    };
+    process.on('SIGINT', () => {
+        void gracefulShutdown('SIGINT');
+    });
+    process.on('SIGTERM', () => {
+        void gracefulShutdown('SIGTERM');
+    });
+    process.on('SIGUSR2', () => {
+        void gracefulShutdown('SIGUSR2');
+    }); // nodemon 重启信号
+}
+if (process.env.VITEST !== 'true') {
+    main().catch(error => {
+        console.error('Fatal Error:', error);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=index.js.map