@qwen-code/channel-qqbot 0.21.0-preview.0

package/dist/QQChannel.js

@@ -0,0 +1,2153 @@
+/**
+ * QQ Bot channel adapter for Qwen Code.
+ *
+ * Connects QQ Bot via official QQ Bot WebSocket API.
+ * Extends ChannelBase for streaming, access control, and session routing.
+ * Supports QR code login, credential persistence, C2C and group chat.
+ *
+ * Cross-server context continuation: persists SessionRouter mappings and
+ * QQ-specific routing state (chatTypeMap, replyMsgId, msgSeqMap) to disk,
+ * restoring them on reconnect so conversations survive daemon restarts.
+ *
+ * @see https://bot.q.qq.com/wiki/develop/api-v2/
+ */
+import { ChannelBase, SessionRouter, getGlobalQwenDir, sanitizeSenderName, sanitizePromptText, sanitizeLogText, } from '@qwen-code/channel-base';
+import WebSocket from 'ws';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync, unlinkSync, } from 'node:fs';
+import { join } from 'node:path';
+import { OpCode, Intent } from './types.js';
+import { getCredsFilePath, loadCredentials, saveCredentials, } from './accounts.js';
+import { qrCodeLogin } from './login.js';
+import { fetchAccessToken, fetchGatewayUrl, getApiBase, sendQQMessage, } from './api.js';
+export class DeliveryError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'DeliveryError';
+    }
+}
+/** Validate chatId to prevent SSRF when constructing URLs. */
+export function isValidChatId(id) {
+    return /^[A-Za-z0-9_-]+$/.test(id) && id.length <= 128;
+}
+export class QQChannel extends ChannelBase {
+    ws = null;
+    accessToken = '';
+    tokenExpiresAt = 0;
+    tokenRefreshTimer = null;
+    heartbeatTimer = null;
+    heartbeatInterval = 45000;
+    seq = 0;
+    reconnectAttempts = 0;
+    maxReconnectAttempts;
+    /** QQ Bot session_id from READY, used for RESUME on reconnect. */
+    sessionId = '';
+    /** Whether this connection attempt should try RESUME first. */
+    tryResume = false;
+    qqConfig;
+    /** Set when server sends RECONNECT opcode — close handler uses this to force reconnect. */
+    serverRequestedReconnect = false;
+    /** Pending connect promise reject — called when WebSocket closes before READY. */
+    connectReject = null;
+    /** Set to true when channel is disconnected — prevents orphaned connections. */
+    disposed = false;
+    /** Deduplicate inbound messages on reconnect replay (messageId → timestamp). */
+    seenMessages = new Map();
+    /** Cleanup timer for seenMessages TTL eviction. */
+    seenCleanupTimer = null;
+    /** Timestamp of last received HEARTBEAT_ACK, for zombie-connection detection. */
+    lastHeartbeatAck = 0;
+    /** Debounce timer for saveQQState to avoid blocking event loop. */
+    saveTimer = null;
+    /** beforeExit hook to flush state when the event loop drains naturally. Does NOT fire for SIGKILL, OOM kills, or uncaughtException. */
+    beforeExitHook = null;
+    /** Timer for reconnectWithRetry fallback (unref'd so it doesn't block exit). */
+    reconnectTimer = null;
+    /** 30s READY timeout to prevent hanging on gateway without response. */
+    readyTimeout = null;
+    /** Guard against parallel reconnectWithRetry chains from stale close events. */
+    isReconnecting = false;
+    /** Track whether a chatId is a group or C2C for correct API routing. */
+    chatTypeMap = new Map();
+    /** Track the latest user messageId per chatId for proper reply (msg_id). */
+    replyMsgId = new Map();
+    /** msg_seq counter per user messageId, for multi-block streaming. */
+    msgSeqMap = new Map();
+    /** Periodic cleanup timer for expired replyMsgId entries. */
+    replyMsgIdCleanupTimer = null;
+    /** 5-minute TTL for replyMsgId entries and seenMessages dedup. */
+    static REPLY_MSG_ID_TTL_MS = 300_000;
+    /** Idle-flush timeout: buffer is sent after this many ms of silence. */
+    static IDLE_FLUSH_MS = 2000;
+    /** Max consecutive send failures before the stream is abandoned. */
+    maxFlushRetries;
+    /** Retry delay for subsequent attempts (backoff beyond first retry). */
+    static IDLE_FLUSH_BACKOFF_MS = 4000;
+    /** Max buffer length before forcing an immediate flush. */
+    static MAX_BUFFER_LENGTH = 4096;
+    // ── Group / cron fields ────────────────────────────────────────
+    /** Per-group bot OPENID map for multi-group support. */
+    botOpenIdByGroup = new Map();
+    /** Guard: set to true after first READY + session restore completes. */
+    _ready = false;
+    /** Whether this process has never received READY (cold start). */
+    coldStart = true;
+    /** Track per-group active message permission. */
+    groupActiveMsgEnabled = new Map();
+    /** Lazy cache for compiled keyword trigger RegExp patterns.
+     * Built lazily on first access; never invalidated — keywordTriggers is not modified at runtime. */
+    _keywordTriggerCache = null;
+    /** Rate-limit timestamps for keyword non-match log entries (chatId → last log ms). */
+    _lastKeywordNoMatchLog = new Map();
+    /** Accumulation buffer for cron/non-prompt textChunk events. */
+    cronBuffer = new Map();
+    /** Named handler for permanent textChunk listener (cron/non-prompt). */
+    _cronTextHandler = null;
+    /** Gate: depth counter for cron-scheduled message flows. >0 means in-flow.
+        Prevents phantom cronBuffer entries when textChunk fires during normal
+        bridge.prompt() calls (ChannelBase has its own listener there).
+        Using a counter instead of a boolean supports concurrent cron flows. */
+    _inCronFlow = 0;
+    cronTextHandlerAttached = false;
+    /** Path to persisted QQ routing state: chatTypeMap, replyMsgId, msgSeqMap. */
+    /**
+     * Streaming state machine with per-session buffers.
+     *
+     * Three states for each session:
+     *   active   — accumulating chunks in buffer (onResponseChunk extends timer)
+     *   flushing — sendMessage() is in-flight (prevents parallel sends)
+     *   idle     — waiting for next chunk (timer counting down to idleFlush)
+     *
+     * Transitions:
+     *   active → flushing: idleFlush timer fires, or onToolCall cancels timer
+     *   flushing → idle: send settles, idle timer restarts on retry
+     *   any → done: onResponseComplete sends remaining content
+     *
+     * Guards:
+     *   - flushingSessions prevents concurrent sends per session
+     *   - pendingStreamDelete defers cleanup until in-flight send resolves
+     *   - flushedSessions tracks already-sent sessions to skip final fullText
+     */
+    // ── Streaming state ───────────────────────────────────────────
+    streamState = new Map();
+    flushingSessions = new Set();
+    pendingStreamDelete = new Set();
+    _reconnectId = 0;
+    blockStreaming = false;
+    flushedSessions = new Set();
+    qqStatePath;
+    /**
+     * Path to the global sessions.json managed by start.ts.
+     * start.ts deletes it on shutdown, so we back it up.
+     */
+    globalSessionsPath;
+    /** Backup of sessions.json so conversations survive daemon restarts. */
+    sessionsBackupPath;
+    constructor(name, config, bridge, options) {
+        const safeName = name.replace(/[^A-Za-z0-9_-]/g, '_');
+        const stateDir = join(getGlobalQwenDir(), 'channels');
+        mkdirSync(stateDir, { recursive: true });
+        const sessionsPath = join(stateDir, `${safeName}-sessions.json`);
+        // groupAllPolicy 'keyword' or 'all' requires 'single' session scope
+        // because all group messages share one conversation context.
+        const qqCfg = config;
+        if ((qqCfg.groupAllPolicy === 'keyword' || qqCfg.groupAllPolicy === 'all') &&
+            config.sessionScope !== 'single') {
+            const originalScope = config.sessionScope;
+            process.stderr.write(`[QQ:${name}] WARNING: groupAllPolicy is '${qqCfg.groupAllPolicy}' but sessionScope is '${originalScope}' (not 'single'). Forcing sessionScope to 'single' to ensure shared group context.\n`);
+            config = { ...config, sessionScope: 'single' };
+        }
+        const router = options?.router ??
+            new SessionRouter(bridge, config.cwd, config.sessionScope, sessionsPath);
+        super(name, config, bridge, {
+            ...options,
+            router,
+            registerBridgeEvents: options?.registerBridgeEvents ?? !options?.router,
+        });
+        this.qqConfig = config;
+        this.maxReconnectAttempts = this.qqConfig.maxReconnectAttempts ?? 20;
+        this.maxFlushRetries = this.qqConfig.maxFlushRetries ?? 3;
+        const raw = this.qqConfig.bufferFlushLength;
+        if (raw !== undefined &&
+            (!Number.isInteger(raw) || raw <= 0 || raw > QQChannel.MAX_BUFFER_LENGTH)) {
+            process.stderr.write(`[QQ:${this.name}] WARNING: invalid bufferFlushLength=${raw}, using default ${QQChannel.MAX_BUFFER_LENGTH}\n`);
+            this.qqConfig.bufferFlushLength = QQChannel.MAX_BUFFER_LENGTH;
+        }
+        this.blockStreaming = this.config.blockStreaming === 'on';
+        this.qqStatePath = join(stateDir, `${safeName}-state.json`);
+        // In standalone mode (no external router), use the per-channel
+        // sessions path so the channel owns its own session file.
+        this.globalSessionsPath = options?.router
+            ? join(stateDir, 'sessions.json')
+            : sessionsPath;
+        this.sessionsBackupPath = join(stateDir, `${safeName}-sessions-backup.json`);
+        // Permanent textChunk listener for cron/non-prompt messages.
+        // ChannelBase's prompt-path textChunk listener is only alive during
+        // bridge.prompt(). Cron messages bypass prompt() so their textChunk
+        // events arrive without a listener. This permanent listener catches them.
+        if (this.qqConfig['cron-msg-experimental']) {
+            this._cronTextHandler = (sid, t) => this.handleCronTextChunk(sid, t);
+            this.attachCronHandler();
+        }
+    }
+    handleCronTextChunk(sessionId, text) {
+        const wasInCronFlow = this._inCronFlow > 0;
+        setImmediate(() => {
+            if (!this._ready) {
+                process.stderr.write(`[QQ:${this.name}] Cron text chunk dropped (not ready): ${sanitizeLogText(text, 64)} for session ${sanitizeLogText(sessionId, 32)}\n`);
+                return;
+            }
+            if (!wasInCronFlow)
+                return;
+            if (this.streamState.has(sessionId))
+                return;
+            let entry = this.cronBuffer.get(sessionId);
+            if (!entry) {
+                entry = { buffer: '', timer: null };
+                this.cronBuffer.set(sessionId, entry);
+            }
+            if (entry.timer) {
+                clearTimeout(entry.timer);
+                entry.timer = null;
+                if (entry.pendingRetry) {
+                    entry.buffer = entry.pendingRetry + entry.buffer;
+                    entry.pendingRetry = '';
+                }
+            }
+            entry.buffer += text;
+            const limit = this.qqConfig.bufferFlushLength ?? QQChannel.MAX_BUFFER_LENGTH;
+            const delay = entry.buffer.length >= limit ? 0 : 2000;
+            entry.timer = setTimeout(() => {
+                const toFlush = entry.buffer;
+                entry.buffer = '';
+                entry.timer = null;
+                if (toFlush) {
+                    const target = this.router.getTarget(sessionId);
+                    if (target) {
+                        this.sendMessage(target.chatId, toFlush)
+                            .then(() => {
+                            if (!entry.buffer && this.cronBuffer.get(sessionId) === entry)
+                                this.cronBuffer.delete(sessionId);
+                        })
+                            .catch((err) => {
+                            const code = err instanceof DeliveryError ? err.code : null;
+                            const codeStr = code ? ` (${code})` : '';
+                            process.stderr.write(`[QQ:${this.name}] Cron flush send error${codeStr}: ${sanitizeLogText(err instanceof Error ? err.message : String(err), 200)}\n`);
+                            if (code === 'RETRY_EXHAUSTED' ||
+                                code === 'ACTIVE_MSG_DISABLED' ||
+                                code === 'FALLBACK_FAILED') {
+                                this.cronBuffer.delete(sessionId);
+                                return;
+                            }
+                            entry.pendingRetry = toFlush;
+                            entry.retryCount = 1;
+                            if (entry.timer) {
+                                clearTimeout(entry.timer);
+                            }
+                            entry.timer = setTimeout(() => {
+                                entry.timer = null;
+                                entry.pendingRetry = '';
+                                // Guard: if cronBuffer entry was removed (e.g., group deleted),
+                                // bail out instead of sending to a deleted group.
+                                if (this.cronBuffer.get(sessionId) !== entry) {
+                                    return;
+                                }
+                                const retryTarget = this.router.getTarget(sessionId);
+                                if (!retryTarget) {
+                                    process.stderr.write(`[QQ:${this.name}] Cron flush dropped after retry: no target for session ${sanitizeLogText(sessionId, 32)}\n`);
+                                    this.cronBuffer.delete(sessionId);
+                                    return;
+                                }
+                                this.sendMessage(retryTarget.chatId, toFlush)
+                                    .then(() => {
+                                    entry.pendingRetry = '';
+                                    if (!entry.buffer &&
+                                        this.cronBuffer.get(sessionId) === entry)
+                                        this.cronBuffer.delete(sessionId);
+                                })
+                                    .catch((retryErr) => {
+                                    const retryCode = retryErr instanceof DeliveryError
+                                        ? retryErr.code
+                                        : null;
+                                    const retryCodeStr = retryCode ? ` (${retryCode})` : '';
+                                    process.stderr.write(`[QQ:${this.name}] Cron flush retry failed${retryCodeStr}: ${sanitizeLogText(retryErr instanceof Error ? retryErr.message : String(retryErr), 200)}\n`);
+                                    entry.pendingRetry = '';
+                                    if (retryCode === 'RETRY_EXHAUSTED' ||
+                                        retryCode === 'ACTIVE_MSG_DISABLED' ||
+                                        retryCode === 'FALLBACK_FAILED') {
+                                        if (!entry.buffer &&
+                                            this.cronBuffer.get(sessionId) === entry) {
+                                            this.cronBuffer.delete(sessionId);
+                                        }
+                                        return;
+                                    }
+                                    // Transient error on retry (RATE_LIMITED, etc.) — re-schedule with backoff
+                                    entry.retryCount = (entry.retryCount ?? 1) + 1;
+                                    if (entry.timer) {
+                                        clearTimeout(entry.timer);
+                                    }
+                                    entry.pendingRetry = toFlush;
+                                    entry.timer = setTimeout(() => {
+                                        entry.timer = null;
+                                        entry.pendingRetry = '';
+                                        if (this.cronBuffer.get(sessionId) !== entry) {
+                                            return;
+                                        }
+                                        const retryTarget2 = this.router.getTarget(sessionId);
+                                        if (!retryTarget2) {
+                                            process.stderr.write(`[QQ:${this.name}] Cron flush dropped after retry: no target for session ${sanitizeLogText(sessionId, 32)}\n`);
+                                            this.cronBuffer.delete(sessionId);
+                                            return;
+                                        }
+                                        this.sendMessage(retryTarget2.chatId, toFlush)
+                                            .then(() => {
+                                            entry.pendingRetry = '';
+                                            if (!entry.buffer &&
+                                                this.cronBuffer.get(sessionId) === entry)
+                                                this.cronBuffer.delete(sessionId);
+                                        })
+                                            .catch((err2) => {
+                                            const code2 = err2 instanceof DeliveryError
+                                                ? err2.code
+                                                : null;
+                                            const code2Str = code2 ? ` (${code2})` : '';
+                                            process.stderr.write(`[QQ:${this.name}] Cron flush re-retry failed${code2Str}: ${sanitizeLogText(err2 instanceof Error ? err2.message : String(err2), 200)}, toFlush=${toFlush.length}, session=${sanitizeLogText(sessionId, 32)}\n`);
+                                            entry.pendingRetry = '';
+                                            if (code2 === 'RETRY_EXHAUSTED' ||
+                                                code2 === 'ACTIVE_MSG_DISABLED' ||
+                                                code2 === 'FALLBACK_FAILED') {
+                                                this.cronBuffer.delete(sessionId);
+                                                return;
+                                            }
+                                            // Transient error: retries exhausted after 3 total attempts
+                                            process.stderr.write(`[QQ:${this.name}] Cron flush retries exhausted, dropped ${toFlush.length} chars for session ${sanitizeLogText(sessionId, 32)}\n`);
+                                            this.cronBuffer.delete(sessionId);
+                                        });
+                                    }, entry.retryCount === 2 ? 10000 : 5000);
+                                    entry.timer.unref();
+                                });
+                            }, 5000);
+                            entry.timer.unref();
+                        });
+                        return;
+                    }
+                }
+                process.stderr.write(`[QQ:${this.name}] Cron flush dropped: no target for session ${sanitizeLogText(sessionId, 32)}, lost ${toFlush.length} chars\n`);
+                this.cronBuffer.delete(sessionId);
+            }, delay).unref();
+        });
+    }
+    /**
+     * Public gate for external cron/scheduler integration.
+     * Wraps a cron message flow to activate `_inCronFlow` so that
+     * `textChunk` events are captured into the cron accumulation buffer.
+     * Uses a depth counter (not boolean) so concurrent cron flows
+     * don't stomp each other's `_inCronFlow` state.
+     * Always decrements `_inCronFlow` in a `finally` block.
+     */
+    async runCronFlow(fn) {
+        this._inCronFlow++;
+        try {
+            await fn();
+        }
+        finally {
+            if (this._inCronFlow > 0)
+                this._inCronFlow--;
+        }
+    }
+    /**
+     * Override setBridge to re-attach the permanent `_cronTextHandler`
+     * after bridge crash-recovery.
+     */
+    setBridge(bridge) {
+        this.detachCronHandler();
+        super.setBridge(bridge);
+        this.attachCronHandler();
+    }
+    // ── ChannelBase interface ──────────────────────────────────────
+    async connect() {
+        // Clear any pending reconnect timer from a previous disconnect/reconnect
+        // chain — connect() is an explicit call and should not race with stale
+        // reconnectWithRetry timeouts.
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this._reconnectId++;
+        this.disposed = false;
+        this.reconnectAttempts = 0;
+        this.serverRequestedReconnect = false;
+        this.tryResume = false;
+        if (!this.config.instructions) {
+            const parts = [
+                '## QQ Bot Channel',
+                '',
+                '你是通过 QQ Bot 与用户对话的 AI 助手。',
+                '支持 Markdown 格式，回复自然流畅即可。',
+                '消息前缀 [atMention=true] 表示该消息 @了你，[atMention=false] 表示未 @你。',
+                '不想回复时只输出 <noreply> 即可，消息不会发出。',
+                '',
+                '以下规则仅适用于群聊消息。C2C 私聊中请始终正常回复。',
+                '## 群聊唤醒与静默规则',
+                '',
+                '### 当 [atMention=false] — 未 @你',
+                '由你自主判断当前聊天氛围是否适合插嘴：',
+                '- 闲聊/调侃/玩梗 → 可以接茬，风趣即可',
+                '- 严肃讨论/事务协商 → 保持沉默',
+                '- 不确定 → 沉默',
+                '',
+                '### 当 [atMention=true] — @了你',
+                '先去掉 @标签和你的名字，剩下的内容是对你的提问或指令吗？',
+                '',
+                '以下场景即使 @了你也必须沉默：',
+                '1. 纯提及/陈述 — "QwenCode 好像变聪明了"',
+                '2. 转述/引用 — "刚才 QwenCode 给的方案可以"',
+                '3. 间接呼叫 — "@李四 你让 QwenCode 查下"',
+                '4. 调侃/试探 — "这事 QwenCode 肯定不知道"',
+                '',
+                '### 回复准则',
+                '- 被唤醒后直接做事，禁止"我在"等占位回复',
+                '- 一条消息 @多人时，只有明确指派给你才接',
+                '- 不确认时先沉默',
+                '- 完成对话后立刻回归静默',
+            ];
+            // Only inject @mention format instructions when the operator has
+            // opted in (default: enabled). When disabled, the model receives
+            // no <@OPENID> tags and has no way to @mention, so the instructions
+            // are unnecessary and would confuse the model.
+            if (this.qqConfig.allowMention !== false) {
+                parts.push('', '## @提及格式', '', '消息内容中的 <@OPENID> 标签代表群成员的 QQ 标识。', '当其他群成员 @你（机器人）时，消息内容中会出现 <@你的BotOPENID> 标签，这代表该消息是 @给你的。机器人自己的 OPENID 将在连接建立后告知。', '你可以在回复中使用 <@OPENID> 格式来 @提及特定的群成员。', '例如：回复 "<@ABC123DEF456> 你好" 会在群里 @该成员。');
+            }
+            this.config.instructions = parts.join('\n');
+        }
+        for (let attempt = 0; attempt < 3; attempt++) {
+            try {
+                await this.fetchToken();
+                await this.connectGateway();
+                // Register beforeExit hook so the unref'd debounce timer's unflushed
+                // state is persisted when the event loop drains naturally. Does NOT
+                // fire for SIGKILL, OOM kills, or uncaughtException.
+                if (this.beforeExitHook) {
+                    process.off('beforeExit', this.beforeExitHook);
+                }
+                this.beforeExitHook = () => this.flushQQState();
+                process.on('beforeExit', this.beforeExitHook);
+                this.startReplyMsgIdCleanup();
+                return;
+            }
+            catch (e) {
+                if (attempt < 2) {
+                    const msg = e instanceof Error ? e.message : String(e);
+                    process.stderr.write(`[QQ:${this.name}] Connect attempt ${attempt + 1} failed: ${sanitizeLogText(msg, 200)}, retrying...\n`);
+                    await this.sleep(2000);
+                }
+                else {
+                    // Final attempt: wrap the connection error with sanitized text.
+                    // The sanitizeLogText path is exercised by the existing connect gateway
+                    // retry tests in send.test.ts (gateway reconnect timer block).
+                    throw new Error(sanitizeLogText(e instanceof Error ? e.message : String(e), 200), { cause: e });
+                }
+            }
+        }
+    }
+    async sendMessage(chatId, text) {
+        // <noreply> suppression
+        if (text.trim() === '<noreply>') {
+            process.stderr.write(`[QQ:${this.name}] <noreply> skipped for ${sanitizeLogText(chatId, 64)}\n`);
+            return;
+        }
+        const route = await this.resolveRoute(chatId);
+        if (!route)
+            return;
+        // Look up reply context with TTL check
+        const entry = this.replyMsgId.get(chatId);
+        const msgId = entry && Date.now() - entry.timestamp < QQChannel.REPLY_MSG_ID_TTL_MS
+            ? entry.msgId
+            : undefined;
+        if (entry && !msgId) {
+            process.stderr.write(`[QQ:${this.name}] replyMsgId entry expired for ${sanitizeLogText(chatId, 64)}, reply context expired, sending without msg_id\n`);
+            this.msgSeqMap.delete(entry.msgId);
+            this.replyMsgId.delete(chatId);
+            this.saveQQState();
+        }
+        // Respect QQ Bot active-message toggle: when a group admin disables
+        // active messages, drop outbound sends silently to avoid platform-policy
+        // violations. Only applies to active sends (no msgId — passive replies
+        // to @-bot messages must still be delivered).
+        if (!msgId && this.groupActiveMsgEnabled.get(chatId) === false) {
+            const cronCtx = this._inCronFlow ? ' (cron flow discarded)' : '';
+            process.stderr.write(`[QQ:${this.name}] sendMessage blocked: active messages disabled for ${sanitizeLogText(chatId, 64)}${cronCtx}\n`);
+            throw new DeliveryError('ACTIVE_MSG_DISABLED', `Active messages disabled for ${sanitizeLogText(chatId, 64)}`);
+        }
+        let nextSeq = 0;
+        let rollbackApplied = false;
+        try {
+            // ── STEP 1: Passive markdown attempt ──
+            const passiveBody = {
+                msg_type: 2,
+                markdown: { content: text },
+            };
+            nextSeq = msgId ? (this.msgSeqMap.get(msgId) ?? 0) + 1 : 0;
+            if (msgId) {
+                this.msgSeqMap.set(msgId, nextSeq);
+                passiveBody['msg_id'] = msgId;
+                passiveBody['msg_seq'] = nextSeq;
+            }
+            const resp = await sendQQMessage(route.base, route.path, this.accessToken, passiveBody);
+            if (!resp.ok) {
+                // Always consume response body to prevent undici resource leak
+                const errBody = sanitizeLogText(await resp.text().catch(() => ''), 200);
+                // Log diagnostic info for non-429 failures
+                if (resp.status !== 429) {
+                    process.stderr.write(`[QQ:${this.name}] Send failed (HTTP ${resp.status}: ${errBody})\n
+`);
+                }
+                // 429 = rate-limited — do not retry, bail immediately
+                if (resp.status === 429) {
+                    process.stderr.write(`[QQ:${this.name}] MESSAGE DROPPED: rate-limited (429) on markdown attempt for ${sanitizeLogText(chatId, 64)}\n`);
+                    if (msgId) {
+                        this.msgSeqMap.set(msgId, nextSeq - 1);
+                        this.saveQQState();
+                    }
+                    throw new DeliveryError('RATE_LIMITED', `Message blocked by rate limit for ${sanitizeLogText(chatId, 64)}`);
+                }
+                // Passive markdown failed (non-429). If we have msgId, roll back
+                // and try active retries (no msg_id/msg_seq).
+                if (msgId) {
+                    this.msgSeqMap.set(msgId, nextSeq - 1);
+                    rollbackApplied = true;
+                    // Check if active messages are allowed for this chat
+                    if (this.groupActiveMsgEnabled.get(chatId) === false) {
+                        process.stderr.write(`[QQ:${this.name}] MESSAGE DROPPED: active messages disabled for ${sanitizeLogText(chatId, 64)}, cannot retry\n`);
+                        this.saveQQState();
+                        throw new DeliveryError('ACTIVE_MSG_DISABLED', `Active messages disabled for ${sanitizeLogText(chatId, 64)}`);
+                    }
+                    // ── STEP 2: Active markdown (msg_type: 2, NO msg_id/msg_seq) ──
+                    const activeMdBody = {
+                        msg_type: 2,
+                        markdown: { content: text },
+                    };
+                    const activeMdResp = await sendQQMessage(route.base, route.path, this.accessToken, activeMdBody);
+                    if (activeMdResp.ok) {
+                        process.stderr.write(`[QQ:${this.name}] Active markdown retry succeeded for ${sanitizeLogText(chatId, 64)}\n`);
+                        this.saveQQState();
+                        await activeMdResp.text().catch(() => '');
+                        return;
+                    }
+                    const mdErrBody = sanitizeLogText(await activeMdResp.text().catch(() => ''), 200);
+                    if (activeMdResp.status === 429) {
+                        process.stderr.write(`[QQ:${this.name}] MESSAGE DROPPED: rate-limited (429) on active markdown retry for ${sanitizeLogText(chatId, 64)}\n`);
+                        this.saveQQState();
+                        throw new DeliveryError('RATE_LIMITED', `Message blocked by rate limit for ${sanitizeLogText(chatId, 64)}`);
+                    }
+                    process.stderr.write(`[QQ:${this.name}] Active markdown retry failed (HTTP ${activeMdResp.status}: ${mdErrBody}) for ${sanitizeLogText(chatId, 64)}\n`);
+                    // ── STEP 3: Active plain-text (msg_type: 0, NO msg_id/msg_seq) ──
+                    const activeTextBody = {
+                        content: text,
+                        msg_type: 0,
+                    };
+                    const activeTextResp = await sendQQMessage(route.base, route.path, this.accessToken, activeTextBody);
+                    if (activeTextResp.ok) {
+                        process.stderr.write(`[QQ:${this.name}] Active text fallback succeeded for ${sanitizeLogText(chatId, 64)}\n`);
+                        this.saveQQState();
+                        await activeTextResp.text().catch(() => '');
+                        return;
+                    }
+                    const textErrBody = sanitizeLogText(await activeTextResp.text().catch(() => ''), 200);
+                    if (activeTextResp.status === 429) {
+                        process.stderr.write(`[QQ:${this.name}] MESSAGE DROPPED: rate-limited (429) on active text fallback for ${sanitizeLogText(chatId, 64)}\n`);
+                        this.saveQQState();
+                        throw new DeliveryError('RATE_LIMITED', `Message blocked by rate limit for ${sanitizeLogText(chatId, 64)}`);
+                    }
+                    process.stderr.write(`[QQ:${this.name}] MESSAGE DROPPED: active text fallback failed (HTTP ${activeTextResp.status}: ${textErrBody}) for ${sanitizeLogText(chatId, 64)}\n`);
+                    this.saveQQState();
+                    throw new DeliveryError('FALLBACK_FAILED', `All delivery attempts exhausted for ${sanitizeLogText(chatId, 64)}`);
+                }
+                // Plain-text fallback for pure active messages (no reply context)
+                const plainBody = {
+                    content: text,
+                    msg_type: 0,
+                };
+                const fallbackRes = await sendQQMessage(route.base, route.path, this.accessToken, plainBody);
+                if (!fallbackRes.ok) {
+                    const fbErrBody = await fallbackRes.text().catch(() => '');
+                    if (fallbackRes.status === 429) {
+                        process.stderr.write(`[QQ:${this.name}] MESSAGE DROPPED: rate-limited (429) on plain-text fallback for ${sanitizeLogText(chatId, 64)}\n`);
+                        throw new DeliveryError('RATE_LIMITED', `Message blocked by rate limit for ${sanitizeLogText(chatId, 64)}`);
+                    }
+                    process.stderr.write(`[QQ:${this.name}] MESSAGE DROPPED: plain-text fallback failed (HTTP ${fallbackRes.status}: ${sanitizeLogText(fbErrBody, 200)}) for ${sanitizeLogText(chatId, 64)}\n`);
+                    throw new DeliveryError('FALLBACK_FAILED', `Plain-text fallback delivery failed for ${sanitizeLogText(chatId, 64)}`);
+                }
+                process.stderr.write(`[QQ:${this.name}] Plain-text fallback succeeded for ${sanitizeLogText(chatId, 64)}\n`);
+                await fallbackRes.text().catch(() => '');
+                return;
+            }
+            await resp.text().catch(() => '');
+            if (msgId)
+                this.saveQQState();
+        }
+        catch (e) {
+            // Rollback on failure if we haven't already
+            if (msgId && !rollbackApplied) {
+                this.msgSeqMap.set(msgId, nextSeq - 1);
+            }
+            if (msgId)
+                this.saveQQState();
+            // Note: sendQQMessage only throws on network/timeout errors, never HTTP status.
+            // Rate-limit (429) handling is in the resp.status checks above.
+            if (!(e instanceof DeliveryError)) {
+                process.stderr.write(`[QQ:${this.name}] Send error: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}\n`);
+            }
+            throw e; // Re-throw for .catch() callers
+        }
+    }
+    /**
+     * Resolve API routing: handles disposed check, token refresh, chatId validation,
+     * sandbox detection, and C2C/group path selection. Returns null if any guard fails.
+     */
+    async resolveRoute(chatId) {
+        if (this.disposed) {
+            process.stderr.write(`[QQ:${this.name}] resolveRoute: channel disposed, dropping message to ${sanitizeLogText(chatId, 64)}\n`);
+            return null;
+        }
+        if (Date.now() >= this.tokenExpiresAt) {
+            try {
+                await this.fetchToken();
+            }
+            catch (_e) {
+                process.stderr.write(`[QQ:${this.name}] resolveRoute: token refresh failed (${sanitizeLogText(_e instanceof Error ? _e.message : String(_e), 120)}), dropping message to ${sanitizeLogText(chatId, 64)}\n`);
+                return null;
+            }
+        }
+        if (!this.accessToken) {
+            process.stderr.write(`[QQ:${this.name}] resolveRoute: accessToken is empty after fetchToken\n`);
+            return null;
+        }
+        if (!isValidChatId(chatId)) {
+            process.stderr.write(`[QQ:${this.name}] resolveRoute: invalid chatId rejected (length=${chatId.length})\n`);
+            return null;
+        }
+        const base = getApiBase(Boolean(this.qqConfig.sandbox));
+        const routeType = this.chatTypeMap.get(chatId) || this.qqConfig.chatTypes?.[chatId];
+        if (routeType !== 'group' && routeType !== 'c2c') {
+            process.stderr.write(`[QQ:${this.name}] resolveRoute: no chat type for ${sanitizeLogText(chatId, 64)}, dropping message\n`);
+            return null;
+        }
+        const path = routeType === 'group'
+            ? `/v2/groups/${chatId}/messages`
+            : `/v2/users/${chatId}/messages`;
+        return { base, path };
+    }
+    disconnect() {
+        this._reconnectId++;
+        this.disposed = true;
+        this._ready = false;
+        this.stopHeartbeat();
+        this.stopTokenRefresh();
+        this.stopReplyMsgIdCleanup();
+        if (this.seenCleanupTimer) {
+            clearInterval(this.seenCleanupTimer);
+            this.seenCleanupTimer = null;
+        }
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.beforeExitHook) {
+            process.off('beforeExit', this.beforeExitHook);
+            this.beforeExitHook = null;
+        }
+        // Clean up cron buffers (always, regardless of config flag)
+        let droppedCount = 0;
+        for (const [, entry] of this.cronBuffer) {
+            if (entry.timer)
+                clearTimeout(entry.timer);
+            if (entry.buffer)
+                droppedCount++;
+        }
+        if (droppedCount > 0) {
+            process.stderr.write(`[QQ:${this.name}] Disconnect: discarding ${droppedCount} buffered cron message(s)\n`);
+        }
+        this.cronBuffer.clear();
+        this._lastKeywordNoMatchLog.clear();
+        this.flushQQState();
+        this.backupGlobalSessions();
+        if (this.readyTimeout) {
+            clearTimeout(this.readyTimeout);
+            this.readyTimeout = null;
+        }
+        if (this.ws) {
+            this.ws.close(1000);
+            this.ws = null;
+        }
+        if (this.connectReject) {
+            this.connectReject(new Error('Channel disconnected'));
+            this.connectReject = null;
+        }
+        this.detachCronHandler();
+        this.chatTypeMap.clear();
+        this.replyMsgId.clear();
+        this.msgSeqMap.clear();
+        this.botOpenIdByGroup.clear();
+        this.groupActiveMsgEnabled.clear();
+        this.seenMessages.clear();
+        this.coldStart = true;
+        if (this._inCronFlow > 0) {
+            process.stderr.write(`[QQ:${this.name}] resetRoutingState: orphaned cron flow (depth=${this._inCronFlow}) during disconnect\n`);
+        }
+        this._inCronFlow = 0;
+        for (const [, state] of this.streamState) {
+            if (state.timer)
+                clearTimeout(state.timer);
+        }
+        this.streamState.clear();
+        this.flushingSessions.clear();
+        this.pendingStreamDelete.clear();
+        this.flushedSessions.clear();
+    }
+    /**
+     * QQ Bot API V2 does not provide a typing indicator endpoint.
+     * ChannelBase calls these hooks to signal prompt start/end;
+     * they are intentionally no-ops for this channel.
+     */
+    onPromptStart(_chatId, _sessionId, _messageId) { }
+    onPromptEnd(_chatId, _sessionId, _messageId) { }
+    // ── Streaming (idle-flush with per-session buffers) ────────────
+    onResponseChunk(chatId, chunk, sessionId) {
+        if (this.blockStreaming)
+            return;
+        let state = this.streamState.get(sessionId);
+        if (!state) {
+            state = { chatId, buffer: chunk, timer: null, retryCount: 0 };
+            this.streamState.set(sessionId, state);
+        }
+        else {
+            state.buffer += chunk;
+            if (state.timer) {
+                clearTimeout(state.timer);
+                state.timer = null;
+            }
+            // Size-cap flush: check flushingSessions to prevent concurrent sends.
+            if (state.buffer.length >=
+                (this.qqConfig.bufferFlushLength ?? QQChannel.MAX_BUFFER_LENGTH)) {
+                const buf = state.buffer;
+                state.buffer = '';
+                if (this.flushingSessions.has(sessionId)) {
+                    // Send in-flight — re-buffer and let the in-flight send's .then() pick it up
+                    state.buffer = buf + (state.buffer || '');
+                    state.timer = setTimeout(() => {
+                        this.idleFlush(sessionId, this._reconnectId);
+                    }, QQChannel.IDLE_FLUSH_MS);
+                    state.timer.unref?.();
+                    return;
+                }
+                this.flushAndTrack(sessionId, buf, state, 'idleFlush');
+                return;
+            }
+        }
+        const reconnectId = this._reconnectId;
+        state.timer = setTimeout(() => {
+            this.idleFlush(sessionId, reconnectId);
+        }, QQChannel.IDLE_FLUSH_MS);
+        state.timer.unref?.();
+    }
+    idleFlush(sessionId, reconnectId) {
+        if (this._reconnectId !== reconnectId) {
+            process.stderr.write(`[QQ:${this.name}] idleFlush discarded (reconnect) session=${sanitizeLogText(sessionId, 32)}\n`);
+            return;
+        }
+        const state = this.streamState.get(sessionId);
+        if (!state || !state.buffer)
+            return;
+        if (this.flushingSessions.has(sessionId)) {
+            // Another send is in-flight — re-schedule idle timer so we retry later
+            if (!state.timer) {
+                const retryReconnectId = this._reconnectId;
+                state.timer = setTimeout(() => {
+                    this.idleFlush(sessionId, retryReconnectId);
+                }, QQChannel.IDLE_FLUSH_MS);
+                state.timer.unref?.();
+            }
+            return;
+        }
+        const buffer = state.buffer;
+        state.buffer = '';
+        state.timer = null; // Clear expired one-shot timer reference
+        this.flushAndTrack(sessionId, buffer, state, 'idleFlush');
+    }
+    /**
+     * Shared send-and-track helper used by idleFlush and onToolCall.
+     * Encapsulates .then() (cleanup on success) and .catch() (retry/re-buffer
+     * on failure) logic to eliminate duplication.
+     */
+    flushAndTrack(sessionId, buffer, state, logLabel) {
+        this.flushingSessions.add(sessionId);
+        // sendMessage throws DeliveryError for delivery failures.
+        // RETRY_EXHAUSTED, ACTIVE_MSG_DISABLED, and FALLBACK_FAILED are
+        // permanent. RATE_LIMITED is transient and falls through to re-buffer/retry.
+        this.sendMessage(state.chatId, buffer)
+            .then(() => {
+            // #3: Guard — if session died during in-flight send, touch nothing
+            const current = this.streamState.get(sessionId);
+            if (current !== state)
+                return;
+            current.retryCount = 0;
+            this.flushedSessions.add(sessionId);
+            if (this.pendingStreamDelete.has(sessionId)) {
+                this.pendingStreamDelete.delete(sessionId);
+                // #2: Flush immediately — idle timer would add unnecessary delay
+                const s = this.streamState.get(sessionId);
+                if (s === state && s.buffer) {
+                    // Don't clear buffer or retryCount — idleFlush will pick them up.
+                    this.idleFlush(sessionId, this._reconnectId);
+                    // Don't return — let .finally() clear flushingSessions
+                    // so deferred idleFlush can proceed.
+                }
+            }
+            // #8: Clean up streamState only if no content arrived during send
+            const s = this.streamState.get(sessionId);
+            if (s === state && !s.buffer) {
+                this.streamState.delete(sessionId);
+            }
+        })
+            .catch((e) => {
+            if (e instanceof DeliveryError &&
+                (e.code === 'RETRY_EXHAUSTED' ||
+                    e.code === 'ACTIVE_MSG_DISABLED' ||
+                    e.code === 'FALLBACK_FAILED')) {
+                process.stderr.write(`[QQ:${this.name}] ${logLabel} delivery failed (${e.code}): ${sanitizeLogText(e.message, 200)}, dropping ${buffer.length} chars\n`);
+                // RETRY_EXHAUSTED / ACTIVE_MSG_DISABLED / FALLBACK_FAILED = permanent failure.
+                // Drop everything — including any residual buffer that arrived concurrently.
+                const current = this.streamState.get(sessionId);
+                if (current === state) {
+                    this.streamState.delete(sessionId);
+                }
+                if (this.pendingStreamDelete.has(sessionId)) {
+                    this.pendingStreamDelete.delete(sessionId);
+                    this.flushedSessions.delete(sessionId);
+                }
+                return;
+            }
+            process.stderr.write(`[QQ:${this.name}] ${logLabel} send failed: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}\n`);
+            // #1: Never undo previously-succeeded flush records on failure
+            if (this.pendingStreamDelete.has(sessionId)) {
+                // Session is ending - retry up to MAX_FLUSH_RETRIES
+                this.pendingStreamDelete.delete(sessionId);
+                const current = this.streamState.get(sessionId);
+                if (current === state) {
+                    current.buffer = buffer;
+                    current.retryCount++;
+                    if (this.maxFlushRetries <= 0 ||
+                        current.retryCount < this.maxFlushRetries) {
+                        const reconnectId = this._reconnectId;
+                        const delay = current.retryCount > 1
+                            ? QQChannel.IDLE_FLUSH_BACKOFF_MS
+                            : QQChannel.IDLE_FLUSH_MS;
+                        current.timer = setTimeout(() => {
+                            this.idleFlush(sessionId, reconnectId);
+                        }, delay);
+                        current.timer.unref?.();
+                    }
+                    else {
+                        this.streamState.delete(sessionId);
+                        // #2: Clean up flushedSessions on retry exhaustion
+                        this.flushedSessions.delete(sessionId);
+                        process.stderr.write(`[QQ:${this.name}] ${logLabel} retries exhausted for ${sanitizeLogText(sessionId, 64)}\n`);
+                    }
+                }
+            }
+            else {
+                // Not ending - re-buffer and retry
+                const current = this.streamState.get(sessionId);
+                // #6: Identity guard — only operate on the same state reference
+                if (current === state) {
+                    current.buffer = buffer + (current.buffer || '');
+                    // #3: If re-buffer exceeds max length, flush immediately
+                    if (current.buffer.length >=
+                        (this.qqConfig.bufferFlushLength ?? QQChannel.MAX_BUFFER_LENGTH)) {
+                        current.retryCount++;
+                        if (this.maxFlushRetries > 0 &&
+                            current.retryCount >= this.maxFlushRetries) {
+                            this.streamState.delete(sessionId);
+                            this.flushedSessions.delete(sessionId);
+                            process.stderr.write(`[QQ:${this.name}] ${logLabel} retries exhausted (buffer exceeds limit) for ${sanitizeLogText(sessionId, 64)}\n`);
+                        }
+                        else {
+                            this.idleFlush(sessionId, this._reconnectId);
+                        }
+                    }
+                    else {
+                        current.retryCount++;
+                        if (this.maxFlushRetries <= 0 ||
+                            current.retryCount < this.maxFlushRetries) {
+                            if (!current.timer) {
+                                const reconnectId = this._reconnectId;
+                                const delay = current.retryCount > 1
+                                    ? QQChannel.IDLE_FLUSH_BACKOFF_MS
+                                    : QQChannel.IDLE_FLUSH_MS;
+                                current.timer = setTimeout(() => {
+                                    this.idleFlush(sessionId, reconnectId);
+                                }, delay);
+                                current.timer.unref?.();
+                            }
+                        }
+                        else {
+                            this.streamState.delete(sessionId);
+                            // #2: Clean up flushedSessions on retry exhaustion
+                            this.flushedSessions.delete(sessionId);
+                            process.stderr.write(`[QQ:${this.name}] ${logLabel} retries exhausted for ${sanitizeLogText(sessionId, 64)}\n`);
+                        }
+                    }
+                }
+            }
+        })
+            .finally(() => {
+            // #1: Identity guard — only delete if no new state replaced us
+            const current = this.streamState.get(sessionId);
+            if (!current || current === state) {
+                this.flushingSessions.delete(sessionId);
+            }
+        });
+    }
+    onToolCall(_chatId, event) {
+        const state = this.streamState.get(event.sessionId);
+        if (!state || !state.buffer)
+            return;
+        if (this.flushingSessions.has(event.sessionId))
+            return;
+        if (state.timer) {
+            clearTimeout(state.timer);
+            state.timer = null;
+        }
+        const buffer = state.buffer;
+        state.buffer = '';
+        this.flushAndTrack(event.sessionId, buffer, state, 'toolCallFlush');
+    }
+    onResponseBoundary(_chatId, sessionId) {
+        const state = this.streamState.get(sessionId);
+        if (state?.timer) {
+            clearTimeout(state.timer);
+        }
+        this.streamState.delete(sessionId);
+        this.flushingSessions.delete(sessionId);
+        this.pendingStreamDelete.delete(sessionId);
+        this.flushedSessions.delete(sessionId);
+    }
+    async onResponseComplete(chatId, fullText, sessionId) {
+        const state = this.streamState.get(sessionId);
+        if (state?.timer) {
+            clearTimeout(state.timer);
+            state.timer = null;
+        }
+        if (state && this.flushingSessions.has(sessionId)) {
+            this.pendingStreamDelete.add(sessionId);
+            process.stderr.write(`[QQ:${this.name}] onResponseComplete deferred (flush in-flight) session=${sanitizeLogText(sessionId, 32)}\n`);
+            return;
+        }
+        const wasFlushed = this.flushedSessions.has(sessionId);
+        const remaining = state?.buffer ?? (wasFlushed ? '' : fullText);
+        this.streamState.delete(sessionId);
+        this.flushedSessions.delete(sessionId);
+        if (remaining) {
+            await super.onResponseComplete(chatId, remaining, sessionId);
+        }
+    }
+    onSessionDied(sessionId) {
+        const state = this.streamState.get(sessionId);
+        if (state?.timer) {
+            clearTimeout(state.timer);
+        }
+        this.streamState.delete(sessionId);
+        this.flushingSessions.delete(sessionId);
+        this.pendingStreamDelete.delete(sessionId);
+        this.flushedSessions.delete(sessionId);
+        super.onSessionDied(sessionId);
+    }
+    // ── State Persistence (cross-server context continuation) ──────
+    serializeQQState() {
+        return JSON.stringify({
+            chatTypeMap: Array.from(this.chatTypeMap.entries()),
+            replyMsgId: Array.from(this.replyMsgId.entries()),
+            msgSeqMap: Array.from(this.msgSeqMap.entries()),
+            groupActiveMsgEnabled: Array.from(this.groupActiveMsgEnabled.entries()),
+            botOpenIdByGroup: Array.from(this.botOpenIdByGroup.entries()),
+        });
+    }
+    /** Debounced state persistence with atomic write. */
+    saveQQState() {
+        // NOTE: guarded here; flushQQState() is intentionally NOT — disconnect()
+        // sets disposed=true *before* calling it, so it must still write final state.
+        if (this.disposed)
+            return;
+        if (this.saveTimer)
+            clearTimeout(this.saveTimer);
+        this.saveTimer = setTimeout(() => {
+            if (this.disposed)
+                return;
+            const tmpPath = this.qqStatePath + '.tmp';
+            try {
+                writeFileSync(tmpPath, this.serializeQQState(), { mode: 0o600 });
+                renameSync(tmpPath, this.qqStatePath);
+            }
+            catch (e) {
+                try {
+                    unlinkSync(tmpPath);
+                }
+                catch {
+                    /* best-effort cleanup */
+                }
+                process.stderr.write(`[QQ:${this.name}] saveQQState write failed: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}\n
+`);
+            }
+        }, 500);
+        this.saveTimer.unref();
+    }
+    /**
+     * Attach the permanent textChunk handler for cron/non-prompt messages
+     * to the current bridge. No-op if already attached or if cron is disabled.
+     */
+    attachCronHandler() {
+        if (this.qqConfig['cron-msg-experimental'] &&
+            this._cronTextHandler &&
+            !this.cronTextHandlerAttached) {
+            this.bridge.on?.('textChunk', this._cronTextHandler);
+            this.cronTextHandlerAttached = true;
+        }
+    }
+    _checkGroupAllPolicyRequireMention() {
+        const policy = this.qqConfig.groupAllPolicy;
+        if (policy !== 'keyword' && policy !== 'all')
+            return;
+        const groups = this.config.groups;
+        const anyFalse = groups && Object.values(groups).some((g) => g.requireMention === false);
+        if (!anyFalse) {
+            process.stderr.write(`[QQ:${this.name}] WARNING: groupAllPolicy is '${policy}' but requireMention is true (default). Non-@-bot messages passing keyword/all policy will be silently dropped by GroupGate. Set 'groups': { '*': { 'requireMention': false } } in channel config.\n`);
+        }
+    }
+    /**
+     * Detach the permanent textChunk handler from the current bridge.
+     * No-op if not attached or if cron is disabled.
+     */
+    detachCronHandler() {
+        if (this.qqConfig['cron-msg-experimental'] &&
+            this._cronTextHandler &&
+            this.cronTextHandlerAttached) {
+            this.bridge.off?.('textChunk', this._cronTextHandler);
+            this.cronTextHandlerAttached = false;
+        }
+    }
+    /** Flush pending state writes immediately (called on disconnect). */
+    flushQQState() {
+        if (this.saveTimer) {
+            clearTimeout(this.saveTimer);
+            this.saveTimer = null;
+        }
+        const tmpPath = this.qqStatePath + '.tmp';
+        try {
+            writeFileSync(tmpPath, this.serializeQQState(), { mode: 0o600 });
+            renameSync(tmpPath, this.qqStatePath);
+        }
+        catch (e) {
+            try {
+                unlinkSync(tmpPath);
+            }
+            catch {
+                /* best-effort cleanup */
+            }
+            process.stderr.write(`[QQ:${this.name}] flushQQState write failed: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}\n
+`);
+        }
+    }
+    /**
+     * Restore QQ routing state from disk.
+     *
+     * Validates all restored state extensively — type checks, length bounds,
+     * and sanity filters — so a corrupted file produces clean empty maps
+     * rather than propagating invalid data.
+     */
+    restoreQQState() {
+        try {
+            if (!existsSync(this.qqStatePath))
+                return false;
+            const raw = JSON.parse(readFileSync(this.qqStatePath, 'utf-8'));
+            if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+                process.stderr.write(`[QQ:${this.name}] Invalid QQ state file (not an object), ignoring\n`);
+                return false;
+            }
+            if (raw.chatTypeMap) {
+                const arr = raw.chatTypeMap;
+                const totalRaw = Array.isArray(arr) ? arr.length : 0;
+                this.chatTypeMap = new Map(Array.isArray(arr)
+                    ? arr.filter(([k, v]) => typeof k === 'string' &&
+                        k.length <= 256 &&
+                        (v === 'c2c' || v === 'group'))
+                    : []);
+                if (this.chatTypeMap.size < totalRaw) {
+                    process.stderr.write(`[QQ:${this.name}] restoreQQState: accepted ${this.chatTypeMap.size} chatTypeMap entries (rejected ${totalRaw - this.chatTypeMap.size})\n`);
+                }
+            }
+            if (raw.replyMsgId) {
+                const arr = raw.replyMsgId;
+                const totalRaw = Array.isArray(arr) ? arr.length : 0;
+                this.replyMsgId = new Map(Array.isArray(arr)
+                    ? arr
+                        .filter(([k]) => typeof k === 'string' && k.length <= 256)
+                        .filter(([, v]) => {
+                        if (typeof v === 'string' && v.length <= 128)
+                            return true;
+                        if (v === null || typeof v !== 'object')
+                            return false;
+                        const o = v;
+                        return (typeof o['msgId'] === 'string' &&
+                            o['msgId'].length <= 128 &&
+                            typeof o['timestamp'] === 'number' &&
+                            Number.isFinite(o['timestamp']) &&
+                            o['timestamp'] <= Date.now() + QQChannel.REPLY_MSG_ID_TTL_MS);
+                    })
+                        .map(([k, v]) => [
+                        k,
+                        typeof v === 'string'
+                            ? { msgId: v, timestamp: Date.now() }
+                            : v,
+                    ])
+                    : []);
+                if (this.replyMsgId.size < totalRaw) {
+                    process.stderr.write(`[QQ:${this.name}] restoreQQState: accepted ${this.replyMsgId.size} replyMsgId entries (rejected ${totalRaw - this.replyMsgId.size})\n`);
+                }
+            }
+            if (raw.msgSeqMap) {
+                const arr = raw.msgSeqMap;
+                const totalRaw = Array.isArray(arr) ? arr.length : 0;
+                this.msgSeqMap = new Map(Array.isArray(arr)
+                    ? arr.filter(([k, v]) => typeof k === 'string' &&
+                        k.length <= 256 &&
+                        typeof v === 'number' &&
+                        Number.isSafeInteger(v) &&
+                        v >= 0)
+                    : []);
+                if (this.msgSeqMap.size < totalRaw) {
+                    process.stderr.write(`[QQ:${this.name}] restoreQQState: accepted ${this.msgSeqMap.size} msgSeqMap entries (rejected ${totalRaw - this.msgSeqMap.size})\n`);
+                }
+            }
+            if (raw.groupActiveMsgEnabled) {
+                const arr = raw.groupActiveMsgEnabled;
+                const totalRaw = Array.isArray(arr) ? arr.length : 0;
+                this.groupActiveMsgEnabled = new Map(Array.isArray(arr)
+                    ? arr.filter(([k, v]) => typeof k === 'string' &&
+                        k.length <= 256 &&
+                        typeof v === 'boolean')
+                    : []);
+                if (this.groupActiveMsgEnabled.size < totalRaw) {
+                    process.stderr.write(`[QQ:${this.name}] restoreQQState: accepted ${this.groupActiveMsgEnabled.size} groupActiveMsgEnabled entries (rejected ${totalRaw - this.groupActiveMsgEnabled.size})\n`);
+                }
+            }
+            if (raw.botOpenIdByGroup) {
+                const arr = raw.botOpenIdByGroup;
+                const totalRaw = Array.isArray(arr) ? arr.length : 0;
+                this.botOpenIdByGroup = new Map(Array.isArray(arr)
+                    ? arr.filter(([k, v]) => typeof k === 'string' &&
+                        k.length <= 256 &&
+                        typeof v === 'string' &&
+                        /^[A-F0-9]{32}$/i.test(v))
+                    : []);
+                if (this.botOpenIdByGroup.size < totalRaw) {
+                    process.stderr.write(`[QQ:${this.name}] restoreQQState: accepted ${this.botOpenIdByGroup.size} botOpenIdByGroup entries (rejected ${totalRaw - this.botOpenIdByGroup.size})\n`);
+                }
+            }
+            return true;
+        }
+        catch (e) {
+            process.stderr.write(`[QQ:${this.name}] Failed to restore QQ state: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}\n`);
+            return false;
+        }
+    }
+    /**
+     * Backup the global sessions.json before start.ts deletes it on shutdown.
+     * Restored on next connect so conversations survive daemon restarts.
+     */
+    backupGlobalSessions() {
+        try {
+            if (existsSync(this.globalSessionsPath)) {
+                const data = readFileSync(this.globalSessionsPath, 'utf-8');
+                if (data.trim())
+                    writeFileSync(this.sessionsBackupPath, data, { mode: 0o600 });
+            }
+        }
+        catch (e) {
+            process.stderr.write(`[QQ:${this.name}] backupGlobalSessions failed: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}\n
+`);
+        }
+    }
+    restoreGlobalSessions() {
+        try {
+            if (!existsSync(this.globalSessionsPath) &&
+                existsSync(this.sessionsBackupPath)) {
+                writeFileSync(this.globalSessionsPath, readFileSync(this.sessionsBackupPath, 'utf-8'), { mode: 0o600 });
+            }
+        }
+        catch (e) {
+            process.stderr.write(`[QQ:${this.name}] restoreGlobalSessions failed: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}\n
+`);
+        }
+    }
+    /**
+     * Compatibility repair for legacy restored session state where older router
+     * code could keep an empty session id after bridge.loadSession() failed to
+     * return a session_id.
+     *
+     * **Fragile**: accesses SessionRouter's private `toSession`/`toTarget`/`toCwd`
+     * maps via type coercion. If SessionRouter internals change, this breaks
+     * silently. The only signal will be cross-server conversations failing to
+     * restore after daemon restart — no crash, no log.
+     *
+     * Keep this while old persisted files may still exist.
+     */
+    fixRestoredSessions() {
+        try {
+            if (!existsSync(this.globalSessionsPath))
+                return;
+            const raw = JSON.parse(readFileSync(this.globalSessionsPath, 'utf-8'));
+            const r = this.router;
+            const tm = r['toSession'];
+            const tt = r['toTarget'];
+            const tc = r['toCwd'];
+            if (!tm || !tt)
+                return;
+            for (const [key, sid] of tm) {
+                if (sid)
+                    continue;
+                const entry = raw[key];
+                if (!entry?.sessionId)
+                    continue;
+                const correctId = entry.sessionId;
+                const target = entry.target;
+                tm.set(key, correctId);
+                tt.delete(undefined);
+                tt.set(correctId, target);
+                if (tc) {
+                    tc.delete(undefined);
+                    tc.set(correctId, entry.cwd || '');
+                }
+            }
+        }
+        catch (e) {
+            process.stderr.write(`[QQ:${this.name}] fixRestoredSessions failed: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}\n
+`);
+        }
+    }
+    // ── ReplyMsgId helpers ────────────────────────────────────────
+    /**
+     * Set replyMsgId for a chat, cleaning up the previous entry's msgSeqMap
+     * to prevent orphaned entries accumulating over time.
+     */
+    setReplyMsgId(chatId, msgId) {
+        const oldEntry = this.replyMsgId.get(chatId);
+        if (oldEntry && oldEntry.msgId !== msgId) {
+            this.msgSeqMap.delete(oldEntry.msgId);
+        }
+        this.replyMsgId.set(chatId, { msgId, timestamp: Date.now() });
+        this.saveQQState();
+    }
+    /**
+     * Start periodic cleanup of expired replyMsgId entries.
+     * Evicts entries older than 5 minutes every 60 seconds, and cascades
+     * to msgSeqMap.
+     */
+    startReplyMsgIdCleanup() {
+        this.stopReplyMsgIdCleanup();
+        this.replyMsgIdCleanupTimer = setInterval(() => {
+            const cutoff = Date.now() - QQChannel.REPLY_MSG_ID_TTL_MS;
+            let dirty = false;
+            for (const [chatId, entry] of this.replyMsgId) {
+                if (entry.timestamp < cutoff) {
+                    this.msgSeqMap.delete(entry.msgId);
+                    this.replyMsgId.delete(chatId);
+                    dirty = true;
+                }
+            }
+            if (dirty)
+                this.saveQQState();
+        }, 60_000);
+        this.replyMsgIdCleanupTimer.unref();
+    }
+    stopReplyMsgIdCleanup() {
+        if (this.replyMsgIdCleanupTimer) {
+            clearInterval(this.replyMsgIdCleanupTimer);
+            this.replyMsgIdCleanupTimer = null;
+        }
+    }
+    // ── Token ──────────────────────────────────────────────────────
+    async fetchToken() {
+        const safeName = this.name.replace(/[^A-Za-z0-9_-]/g, '_');
+        const credsFile = getCredsFilePath(safeName);
+        let appID = this.qqConfig.appID;
+        let appSecret = this.qqConfig.appSecret;
+        if (!appID || !appSecret) {
+            const saved = loadCredentials(credsFile);
+            if (saved) {
+                appID = saved.appId;
+                appSecret = saved.appSecret;
+                this.qqConfig.appID = appID;
+                this.qqConfig.appSecret = appSecret;
+            }
+        }
+        if (!appID || !appSecret) {
+            process.stderr.write(`[QQ:${this.name}] No credentials, scan QR code with QQ...\n`);
+            const creds = await qrCodeLogin();
+            appID = creds.appId;
+            appSecret = creds.appSecret;
+            this.qqConfig.appID = appID;
+            this.qqConfig.appSecret = appSecret;
+            saveCredentials(credsFile, appID, appSecret);
+        }
+        const token = await fetchAccessToken(appID, appSecret);
+        this.accessToken = token.accessToken;
+        this.tokenExpiresAt = Date.now() + token.expiresIn * 1000;
+        this.scheduleTokenRefresh();
+    }
+    scheduleTokenRefresh() {
+        if (this.disposed)
+            return;
+        this.stopTokenRefresh();
+        const ttl = Math.max(0, this.tokenExpiresAt - Date.now());
+        // Refresh at 80% of TTL, at least 10s before expiry, at most ttl-30s
+        const delay = Math.min(ttl * 0.8, Math.max(ttl - 30_000, 10_000));
+        if (delay > 0) {
+            const tokenReconnectId = this._reconnectId;
+            this.tokenRefreshTimer = setTimeout(() => {
+                this.fetchToken().catch((e) => {
+                    if (this.disposed || this._reconnectId !== tokenReconnectId)
+                        return;
+                    process.stderr.write(`[QQ:${this.name}] Token refresh failed: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}, will retry\n
+`);
+                    // Retry up to 10 times at 60s intervals, then give up.
+                    // Token refresh failure after 10 attempts (10 min) indicates
+                    // a persistent issue (revoked credentials, DNS, firewall) that
+                    // won't resolve by retrying — disconnect and reconnect so the
+                    // fresh connection re-fetches the token, preventing zombie-state
+                    // where the WS stays connected but outbound messages are dropped.
+                    let retryCount = 0;
+                    const retry = () => {
+                        if (this.disposed || this._reconnectId !== tokenReconnectId)
+                            return;
+                        if (++retryCount > 10) {
+                            process.stderr.write(`[QQ:${this.name}] FATAL: token refresh exhausted, reconnecting\n
+`);
+                            this.isReconnecting = true;
+                            this.disconnect();
+                            const postDisconnectReconnectId = this._reconnectId;
+                            this.reconnectTimer = setTimeout(() => {
+                                if (this._reconnectId !== postDisconnectReconnectId)
+                                    return;
+                                this.isReconnecting = false;
+                                this.disposed = false;
+                                // Use reconnectWithRetry instead of bare connect() —
+                                // gives exponential backoff + maxReconnectAttempts guard,
+                                // preventing zombie state where the channel is permanently
+                                // offline after token exhaustion.
+                                this.reconnectWithRetry();
+                            }, 1000);
+                            this.reconnectTimer.unref?.();
+                            return;
+                        }
+                        this.tokenRefreshTimer = setTimeout(() => {
+                            this.fetchToken().catch((e2) => {
+                                if (this.disposed || this._reconnectId !== tokenReconnectId)
+                                    return;
+                                process.stderr.write(`[QQ:${this.name}] Token refresh retry failed (attempt ${retryCount}): ${sanitizeLogText(e2 instanceof Error ? e2.message : String(e2), 200)}\n
+`);
+                                retry();
+                            });
+                        }, 60_000);
+                        this.tokenRefreshTimer.unref?.();
+                    };
+                    retry();
+                });
+            }, delay);
+            this.tokenRefreshTimer.unref?.();
+        }
+    }
+    stopTokenRefresh() {
+        if (this.tokenRefreshTimer) {
+            clearTimeout(this.tokenRefreshTimer);
+            this.tokenRefreshTimer = null;
+        }
+    }
+    // ── WebSocket Gateway ──────────────────────────────────────────
+    async connectGateway() {
+        if (this.disposed)
+            throw new Error('Channel disposed');
+        const url = await fetchGatewayUrl(this.accessToken, Boolean(this.qqConfig.sandbox));
+        return new Promise((resolve, reject) => {
+            this.connectReject = reject;
+            this.dialGateway(url, resolve, reject);
+        });
+    }
+    dialGateway(url, resolve, reject) {
+        this.ws = new WebSocket(url);
+        const dialed = this.ws;
+        // 30-second READY timeout — if the gateway never sends READY,
+        // close the connection so connect() rejects instead of hanging.
+        this.readyTimeout = setTimeout(() => {
+            if (this.ws !== dialed)
+                return;
+            process.stderr.write(`[QQ:${this.name}] READY timeout after 30s, closing\n`);
+            this.ws?.close(4002, 'READY timeout');
+            reject(new Error(`[QQ:${this.name}] READY timeout after 30s`));
+        }, 30_000);
+        this.readyTimeout.unref?.();
+        this.ws.on('open', () => {
+            process.stderr.write(`[QQ:${this.name}] WebSocket connected\n`);
+        });
+        this.ws.on('message', (data) => {
+            try {
+                const msg = JSON.parse(data.toString());
+                this.handleGatewayMessage(msg, resolve);
+            }
+            catch (e) {
+                process.stderr.write(`[QQ:${this.name}] Malformed gateway message: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}\n`);
+            }
+        });
+        this.ws.on('close', (code) => {
+            if (this.ws !== dialed)
+                return;
+            process.stderr.write(`[QQ:${this.name}] WebSocket closed (code=${code})\n`);
+            if (this.readyTimeout) {
+                clearTimeout(this.readyTimeout);
+                this.readyTimeout = null;
+            }
+            this.stopHeartbeat();
+            this.ws = null;
+            this._ready = false;
+            const shouldReconnect = this.serverRequestedReconnect ||
+                (code !== 1000 &&
+                    (this.maxReconnectAttempts <= 0 ||
+                        this.reconnectAttempts < this.maxReconnectAttempts));
+            this.serverRequestedReconnect = false;
+            // Non-1000 close codes (e.g. 4009) imply the server-side session is
+            // gone; skip the RESUME attempt and go straight to IDENTIFY.
+            if (code !== 1000 && code !== 4000) {
+                this.tryResume = false;
+                this.flushQQState();
+                this.coldStart = true;
+            }
+            if (shouldReconnect && this.connectReject) {
+                this.connectReject(new Error(`WebSocket closed before READY (code=${code})`));
+                this.connectReject = null;
+            }
+            else if (shouldReconnect) {
+                const delay = Math.min(1000 * 2 ** this.reconnectAttempts, 30000);
+                process.stderr.write(`[QQ:${this.name}] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}${this.maxReconnectAttempts > 0 ? `/${this.maxReconnectAttempts}` : ''})\n`);
+                if (!this.isReconnecting) {
+                    this.reconnectTimer = setTimeout(() => this.reconnectWithRetry(), delay);
+                    this.reconnectTimer.unref();
+                }
+            }
+            else if (this.maxReconnectAttempts > 0 &&
+                this.reconnectAttempts >= this.maxReconnectAttempts) {
+                process.stderr.write(`[QQ:${this.name}] FATAL: reconnect exhausted after ${this.maxReconnectAttempts} attempts. Bot is offline until daemon restart.\n`);
+                if (this.connectReject) {
+                    this.connectReject(new Error(`WebSocket closed (max reconnect attempts, code=${code})`));
+                    this.connectReject = null;
+                }
+            }
+            else {
+                if (this.connectReject) {
+                    this.connectReject(new Error(`WebSocket closed before READY (code=${code})`));
+                    this.connectReject = null;
+                }
+            }
+        });
+        this.ws.on('error', (e) => {
+            process.stderr.write(`[QQ:${this.name}] WebSocket error: ${sanitizeLogText(e.message, 200)}\n`);
+            if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+                reject(e);
+            }
+        });
+    }
+    /**
+     * Finalize READY state across cold-start and warm-reconnect paths.
+     * Extracted to eliminate triplication in the READY handler.
+     */
+    finalizeReady() {
+        if (!this.ws || this.disposed)
+            return;
+        this._ready = true;
+        this.reconnectAttempts = 0;
+        this.isReconnecting = false;
+        this.coldStart = false;
+        this.attachCronHandler();
+    }
+    handleGatewayMessage(msg, onReady) {
+        const op = msg['op'];
+        switch (op) {
+            case OpCode.HELLO: {
+                this.heartbeatInterval = Math.max(msg['d']?.['heartbeat_interval'] || 45000, 5000);
+                this.sendIdentify();
+                break;
+            }
+            case OpCode.DISPATCH: {
+                const t = msg['t'];
+                const s = msg['s'];
+                if (s !== undefined)
+                    this.seq = s;
+                if (t === 'READY') {
+                    this.reconnectAttempts = 0;
+                    this.isReconnecting = false;
+                    if (this.readyTimeout) {
+                        clearTimeout(this.readyTimeout);
+                        this.readyTimeout = null;
+                    }
+                    this.sessionId =
+                        msg['d']?.['session_id'] || '';
+                    this.tryResume = true;
+                    this.connectReject = null;
+                    this.startHeartbeat();
+                    if (this.coldStart) {
+                        this.restoreGlobalSessions();
+                        if (!this.restoreQQState()) {
+                            process.stderr.write(`[QQ:${this.name}] WARNING: QQ state restore failed — routing maps are empty, group messages may be misrouted\n`);
+                        }
+                        this.router
+                            .restoreSessions()
+                            .then(() => {
+                            this.fixRestoredSessions();
+                            const all = this.router.getAll?.();
+                            const count = all?.length ?? 0;
+                            process.stderr.write(`[QQ:${this.name}] Ready (${count} sessions)\n`);
+                            this.finalizeReady();
+                            this._checkGroupAllPolicyRequireMention();
+                            onReady();
+                        })
+                            .catch(() => {
+                            this.fixRestoredSessions();
+                            process.stderr.write(`[QQ:${this.name}] WARNING: router session restore failed — cron messages will be dropped until sessions re-establish\n`);
+                            this.finalizeReady();
+                            this._checkGroupAllPolicyRequireMention();
+                            onReady();
+                        });
+                    }
+                    else {
+                        process.stderr.write(`[QQ:${this.name}] Ready (warm reconnect, skipping state restore)\n`);
+                        this.finalizeReady();
+                        this._checkGroupAllPolicyRequireMention();
+                        onReady();
+                    }
+                }
+                else if (t === 'C2C_MESSAGE_CREATE') {
+                    this.handleC2C(msg['d']);
+                }
+                else if (t === 'GROUP_AT_MESSAGE_CREATE') {
+                    this.handleGroup(msg['d']);
+                }
+                else if (t === 'GROUP_MESSAGE_CREATE') {
+                    this.handleGroupAll(msg['d']);
+                }
+                else if (t === 'GROUP_ADD_ROBOT') {
+                    this.handleGroupAddRobot(msg['d']);
+                }
+                else if (t === 'GROUP_DEL_ROBOT') {
+                    this.handleGroupDelRobot(msg['d']);
+                }
+                else if (t === 'GROUP_MSG_REJECT') {
+                    this.handleGroupMsgToggle(msg['d'], false);
+                }
+                else if (t === 'GROUP_MSG_RECEIVE') {
+                    this.handleGroupMsgToggle(msg['d'], true);
+                }
+                else if (t === 'RESUMED') {
+                    // RESUME success — the process did NOT restart, all in-memory
+                    // session state, QQ routing state, and global sessions.json are
+                    // still intact. Calling restoreSessions() would drop and re-attach
+                    // every session, aborting in-flight LLM prompts.
+                    if (this.readyTimeout) {
+                        clearTimeout(this.readyTimeout);
+                        this.readyTimeout = null;
+                    }
+                    this.connectReject = null;
+                    this.finalizeReady();
+                    this.startHeartbeat();
+                    onReady();
+                }
+                break;
+            }
+            case OpCode.HEARTBEAT_ACK:
+                this.lastHeartbeatAck = Date.now();
+                break;
+            case OpCode.RECONNECT:
+                this.serverRequestedReconnect = true;
+                this.ws?.close(4000);
+                break;
+            case OpCode.INVALID_SESSION:
+                process.stderr.write(`[QQ:${this.name}] Server sent INVALID_SESSION, falling back to IDENTIFY\n`);
+                this.tryResume = false;
+                // Cancel any pending debounced save to prevent a TOCTOU race
+                // between saveQQState and the coldStart restore on the next READY.
+                if (this.saveTimer) {
+                    clearTimeout(this.saveTimer);
+                    this.saveTimer = null;
+                }
+                // Flush state first to persist any debounced updates before
+                // coldStart=true triggers a full restore on the next READY.
+                this.flushQQState();
+                // Mark not ready to prevent concurrent processors from calling
+                // saveQQState() during the INVALID_SESSION recovery window.
+                this._ready = false;
+                // Trigger full state restore on the next READY — the gateway
+                // assigned a new session_id, so in-memory routing state
+                // (chatTypeMap, replyMsgId, msgSeqMap) must be reloaded.
+                this.coldStart = true;
+                // Note: intentionally NOT refreshing token here. The server's
+                // INVALID_SESSION is more likely from gateway-side session reset
+                // than from token expiry. If the token IS expired, the re-IDENTIFY
+                // will fail with a WS close, and the reconnect path will refresh
+                // the token before the next attempt.
+                this.sendIdentify();
+                // Guard the re-IDENTIFY READY with a fresh timeout. The initial
+                // readyTimeout was cleared by the first READY handler; without this,
+                // an INVALID_SESSION re-IDENTIFY that never gets a response will
+                // hang forever with no timeout to trigger a reconnect.
+                if (this.readyTimeout) {
+                    clearTimeout(this.readyTimeout);
+                    this.readyTimeout = null;
+                }
+                this.readyTimeout = setTimeout(() => {
+                    if (this.ws &&
+                        (this.ws.readyState === WebSocket.OPEN ||
+                            this.ws.readyState === WebSocket.CONNECTING)) {
+                        this.ws.close(4002);
+                        if (this.connectReject) {
+                            this.connectReject(new Error('Timed out waiting for READY'));
+                            this.connectReject = null;
+                        }
+                    }
+                }, 30_000);
+                this.readyTimeout.unref?.();
+                break;
+            default:
+                break;
+        }
+    }
+    sendIdentify() {
+        if (!this.ws)
+            return;
+        if (this.tryResume && this.sessionId) {
+            process.stderr.write(`[QQ:${this.name}] Sending RESUME (session: ${this.sessionId})\n`);
+            this.ws.send(JSON.stringify({
+                op: OpCode.RESUME,
+                d: {
+                    token: `QQBot ${this.accessToken}`,
+                    session_id: this.sessionId,
+                    seq: this.seq,
+                },
+            }));
+            return;
+        }
+        // Include GROUP_MESSAGE intent when groupAllPolicy requires it
+        const needsGroupMsg = this.qqConfig.groupAllPolicy === 'keyword' ||
+            this.qqConfig.groupAllPolicy === 'all' ||
+            this.qqConfig.groupAllPolicy === 'log';
+        this.ws.send(JSON.stringify({
+            op: OpCode.IDENTIFY,
+            d: {
+                token: `QQBot ${this.accessToken}`,
+                intents: Intent.C2C_MESSAGE |
+                    Intent.GROUP_AT_MESSAGE |
+                    (needsGroupMsg ? Intent.GROUP_MESSAGE : 0),
+                shard: [0, 1],
+                properties: {},
+            },
+        }));
+    }
+    /**
+     * Reconnect loop with retry on gateway fetch failures.
+     * Refreshes token before each attempt, and retries GW HTTP failures
+     * with exponential backoff. Keeps retrying until success.
+     */
+    async reconnectWithRetry() {
+        if (this.disposed)
+            return;
+        if (this.isReconnecting)
+            return;
+        this.isReconnecting = true;
+        try {
+            const myReconnectId = this._reconnectId;
+            const maxGwRetries = this.qqConfig.maxGwRetries ?? 5;
+            const unlimitedRetries = maxGwRetries <= 0;
+            for (let attempt = 0; unlimitedRetries || attempt < maxGwRetries; attempt++) {
+                if (this.disposed || this._reconnectId !== myReconnectId)
+                    return;
+                this.reconnectAttempts++;
+                if (this.maxReconnectAttempts > 0 &&
+                    this.reconnectAttempts >= this.maxReconnectAttempts) {
+                    process.stderr.write(`[QQ:${this.name}] RC: reconnect attempts exhausted, giving up\n`);
+                    return;
+                }
+                try {
+                    try {
+                        await this.fetchToken();
+                    }
+                    catch {
+                        process.stderr.write(`[QQ:${this.name}] RC: token refresh failed, retrying...\n`);
+                        await this.sleep(2000);
+                        if (this.disposed)
+                            return;
+                        continue;
+                    }
+                    await this.connectGateway();
+                    this.startReplyMsgIdCleanup();
+                    return;
+                }
+                catch (e) {
+                    const msg = e instanceof Error ? e.message : String(e);
+                    const backoff = Math.min(1000 * 2 ** (attempt + 1), 30000);
+                    process.stderr.write(`[QQ:${this.name}] RC: ${sanitizeLogText(msg, 200)} (retry in ${backoff}ms, attempt ${attempt + 1}${unlimitedRetries ? '' : `/${maxGwRetries}`})\n`);
+                    if (unlimitedRetries || attempt < maxGwRetries - 1)
+                        await this.sleep(backoff);
+                }
+            }
+            process.stderr.write(`[QQ:${this.name}] RC: exhausted ${unlimitedRetries ? '∞' : maxGwRetries} reconnect retries, will retry in 60s\n`);
+            this.tryResume = false;
+        }
+        finally {
+            this.isReconnecting = false;
+        }
+        this.reconnectTimer = setTimeout(() => this.reconnectWithRetry(), 60000);
+        this.reconnectTimer.unref();
+    }
+    sleep(ms) {
+        return new Promise((r) => {
+            const t = setTimeout(r, ms);
+            t.unref?.();
+        });
+    }
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.lastHeartbeatAck = Date.now();
+        this.heartbeatTimer = setInterval(() => {
+            if (this.ws?.readyState !== WebSocket.OPEN)
+                return;
+            const elapsed = Date.now() - this.lastHeartbeatAck;
+            if (elapsed > this.heartbeatInterval * 2) {
+                process.stderr.write(`[QQ:${this.name}] Heartbeat ACK timeout (${elapsed}ms), forcing reconnect\n`);
+                this.ws?.close(4001);
+                return;
+            }
+            this.ws.send(JSON.stringify({ op: OpCode.HEARTBEAT, d: this.seq }));
+        }, this.heartbeatInterval);
+        this.heartbeatTimer.unref();
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    // ── Bot OpenID extraction ──────────────────────────────────────
+    extractBotOpenId(mentions, chatId) {
+        const selfMention = mentions?.find((m) => m.is_you);
+        if (!selfMention)
+            return '';
+        const botOpenId = selfMention.member_openid || selfMention.id || '';
+        if (!/^[A-F0-9]{32}$/i.test(botOpenId)) {
+            process.stderr.write(`[QQ:${this.name}] Invalid botOpenId format: ${sanitizeLogText(botOpenId, 64)}\n`);
+            return '';
+        }
+        if (chatId) {
+            this.botOpenIdByGroup.set(chatId, botOpenId);
+            this.saveQQState();
+        }
+        return botOpenId;
+    }
+    // ── Message Handlers ───────────────────────────────────────────
+    /** Check if a message ID was already processed (reconnect replay dedup). */
+    isDuplicate(eventId) {
+        if (this.seenMessages.has(eventId))
+            return true;
+        const now = Date.now();
+        this.seenMessages.set(eventId, now);
+        if (!this.seenCleanupTimer) {
+            this.seenCleanupTimer = setInterval(() => {
+                const cutoff = Date.now() - QQChannel.REPLY_MSG_ID_TTL_MS;
+                for (const [id, ts] of this.seenMessages) {
+                    if (ts < cutoff)
+                        this.seenMessages.delete(id);
+                }
+                if (this.seenMessages.size === 0) {
+                    clearInterval(this.seenCleanupTimer);
+                    this.seenCleanupTimer = null;
+                }
+            }, 60_000).unref();
+        }
+        return false;
+    }
+    /**
+     * Extract common group-message fields shared by handleGroup and handleGroupAll.
+     * Returns null when the message has no meaningful text after @-tag stripping.
+     */
+    prepareGroupMessage(event, chatId, { forceAtMention } = {}) {
+        const senderName = event.author?.username ||
+            event.author?.id ||
+            event.author?.member_openid ||
+            'QQ User';
+        const safeName = sanitizeSenderName(senderName);
+        const senderOpenId = event.author?.member_openid || event.author?.user_openid || '';
+        const content = (event.content || '').trim();
+        const cleanText = content.replace(/<@[^>]{1,64}>/g, '').trim();
+        // Strip trusted tags that could be forged by users
+        const safeContent = content
+            .replace(/\[atMention=[^\]]*]/g, '')
+            .replace(/\[botOpenId:[^\]]*]/g, '')
+            .replace(/\[bot]/g, '');
+        const safeCleanText = cleanText
+            .replace(/\[atMention=[^\]]*]/g, '')
+            .replace(/\[botOpenId:[^\]]*]/g, '')
+            .replace(/\[bot]/g, '')
+            .trim();
+        const isAtBot = event.mentions?.some((m) => m.is_you) ?? false;
+        // Extract bot's own OPENID from mentions (per-group) — must come
+        // BEFORE the cleanText guard so pure @-bot messages still populate
+        // the per-group OPENID cache.
+        if (isAtBot && !this.botOpenIdByGroup.has(chatId)) {
+            this.extractBotOpenId(event.mentions, chatId);
+        }
+        if (!cleanText)
+            return null;
+        const effectiveIsAtBot = forceAtMention ?? isAtBot;
+        const isSlash = effectiveIsAtBot && safeCleanText.startsWith('/');
+        // Deliberately NOT hard-blocking bot messages — QQ Bot API may deliver
+        // self-echoes or other bot messages. Instead, tag with [bot] prefix so the
+        // model can judge relevance and decide whether to respond. Hard-blocking
+        // would prevent intentional bot-to-bot interactions that the operator
+        // explicitly configures. The [bot] prefix gives the model enough context
+        // to ignore irrelevant bot traffic.
+        // NOTE: Both callers (handleGroup, handleGroupAll) guard against bot
+        // messages before reaching prepareGroupMessage, so isBot is always false
+        // here. The check is retained as defense-in-depth in case a future
+        // caller skips the guard.
+        const groupBotOpenId = this.botOpenIdByGroup.get(chatId);
+        const openIdSuffix = this.qqConfig.allowMention !== false && groupBotOpenId
+            ? ` [botOpenId:${groupBotOpenId}]`
+            : '';
+        const suffixFromBotOpenId = this.qqConfig.allowMention !== false && groupBotOpenId
+            ? `\n机器人 OPENID: ${groupBotOpenId}`
+            : '';
+        const text = isSlash
+            ? sanitizePromptText(safeCleanText)
+            : `[atMention=${effectiveIsAtBot}]${openIdSuffix} [${safeName}${senderOpenId && /^[A-F0-9]+$/i.test(senderOpenId) ? `(${senderOpenId.slice(0, 8)}\u2026)` : ''}]: ${sanitizePromptText(this.qqConfig.allowMention !== false ? safeContent : safeCleanText)}${suffixFromBotOpenId}`;
+        return {
+            isAtBot: effectiveIsAtBot,
+            isSlash,
+            safeName,
+            cleanText,
+            text,
+            senderName,
+        };
+    }
+    handleC2C(event) {
+        if (this.isDuplicate(event.id))
+            return;
+        if (!event.content?.trim())
+            return;
+        if (!event.author) {
+            process.stderr.write(`[QQ:${this.name}] C2C message dropped: missing author\n`);
+            return;
+        }
+        if (event.author.bot) {
+            process.stderr.write(`[QQ:${this.name}] Bot C2C message dropped\n`);
+            return;
+        }
+        const chatId = event.author.user_openid || event.author.id;
+        if (!chatId) {
+            process.stderr.write(`[QQ:${this.name}] C2C message dropped: no chatId for author\n`);
+            return;
+        }
+        if (!isValidChatId(chatId)) {
+            process.stderr.write(`[QQ:${this.name}] C2C message dropped: invalid chatId (length=${chatId.length})\n`);
+            return;
+        }
+        this.chatTypeMap.set(chatId, 'c2c');
+        this.setReplyMsgId(chatId, event.id);
+        const senderName = event.author.username || event.author.id || 'QQ User';
+        const safeName = sanitizeSenderName(senderName);
+        const cleanText = event.content.trim();
+        // Strip system-reserved tags that could be forged by users
+        const safeContent = cleanText
+            .replace(/\[atMention=[^\]]*]/g, '')
+            .replace(/\[botOpenId:[^\]]*]/g, '')
+            .replace(/\[bot]/g, '');
+        const isSlash = safeContent.startsWith('/');
+        const text = isSlash
+            ? sanitizePromptText(safeContent)
+            : `[atMention=true] [${safeName}]: ${sanitizePromptText(safeContent)}`;
+        this.handleInbound({
+            channelName: this.name,
+            senderId: chatId,
+            senderName,
+            chatId,
+            text,
+            messageId: event.id,
+            isGroup: false,
+            isMentioned: true,
+            isReplyToBot: false,
+            ...(isSlash ? {} : { alreadyPrefixed: true }),
+        }).catch((e) => process.stderr.write(`[QQ:${this.name}] C2C handler error: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}\n`));
+    }
+    handleGroup(event) {
+        if (!event.group_openid) {
+            process.stderr.write(`[QQ:${this.name}] Group message dropped: missing group_openid\n`);
+            return;
+        }
+        if (!event.author) {
+            process.stderr.write(`[QQ:${this.name}] Group message dropped: missing author\n`);
+            return;
+        }
+        if (event.author.bot) {
+            process.stderr.write(`[QQ:${this.name}] Bot message dropped in group ${sanitizeLogText(event.group_openid, 64)}\n`);
+            return;
+        }
+        const chatId = event.group_openid;
+        if (!isValidChatId(chatId)) {
+            process.stderr.write(`[QQ:${this.name}] Group message dropped: invalid group_openid\n`);
+            return;
+        }
+        const isNewGroup = !this.chatTypeMap.has(chatId);
+        this.chatTypeMap.set(chatId, 'group');
+        if (isNewGroup)
+            this.saveQQState();
+        // Deduplicate after prepareGroupMessage so side effects
+        // (extractBotOpenId) always run, even for replayed duplicates.
+        // Only skip handleInbound on duplicates — this prevents silent
+        // drops when GROUP_MESSAGE_CREATE fires before GROUP_AT_MESSAGE_CREATE
+        // for the same message.
+        const result = this.prepareGroupMessage(event, chatId, {
+            forceAtMention: true,
+        });
+        if (!result)
+            return;
+        const { isSlash, text, senderName, safeName, cleanText } = result;
+        // Deduplicate before handleInbound — prepareGroupMessage already ran
+        // so side effects (extractBotOpenId) are applied regardless of dedup.
+        if (this.isDuplicate(event.id))
+            return;
+        if (isSlash) {
+            process.stderr.write(`[QQ:${this.name}] Slash cmd from ${sanitizeLogText(safeName, 64)} (${sanitizeLogText(chatId, 64)}): ${sanitizeLogText(cleanText.split(/\s/)[0], 64)}\n`);
+        }
+        // GROUP_AT_MESSAGE_CREATE always has finalIsAtBot=true, so @-bot
+        // messages are always delivered. Log when active messages are disabled.
+        if (this.groupActiveMsgEnabled.get(chatId) === false) {
+            process.stderr.write(`[QQ:${this.name}] handleGroup: active messages disabled but @-bot allowed through (passive)\n`);
+        }
+        const senderId = event.author.user_openid || event.author.id || event.author.member_openid;
+        if (!senderId) {
+            process.stderr.write(`[QQ:${this.name}] Group message dropped: no senderId for author\n`);
+            return;
+        }
+        this.setReplyMsgId(chatId, event.id);
+        this.handleInbound({
+            channelName: this.name,
+            senderId,
+            senderName,
+            chatId,
+            text,
+            messageId: event.id,
+            isGroup: true,
+            isMentioned: true,
+            isReplyToBot: true,
+            ...(isSlash ? {} : { alreadyPrefixed: true }),
+        }).catch((e) => process.stderr.write(`[QQ:${this.name}] Group handler error: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}\n`));
+    }
+    handleGroupAll(event) {
+        if (!event.group_openid) {
+            process.stderr.write(`[QQ:${this.name}] Group all-message dropped: missing group_openid\n`);
+            return;
+        }
+        if (!event.author) {
+            process.stderr.write(`[QQ:${this.name}] Group all-message dropped: missing author\n`);
+            return;
+        }
+        if (event.author.bot) {
+            process.stderr.write(`[QQ:${this.name}] Bot message dropped in group ${sanitizeLogText(event.group_openid, 64)}\n`);
+            return;
+        }
+        const chatId = event.group_openid;
+        if (!isValidChatId(chatId)) {
+            process.stderr.write(`[QQ:${this.name}] Group all-message dropped: invalid group_openid\n`);
+            return;
+        }
+        const isNewGroup = !this.chatTypeMap.has(chatId);
+        this.chatTypeMap.set(chatId, 'group');
+        if (isNewGroup)
+            this.saveQQState();
+        const result = this.prepareGroupMessage(event, chatId);
+        if (!result)
+            return;
+        const { isSlash, text, senderName, isAtBot, safeName, cleanText } = result;
+        // @-bot messages always pass through (passive reply).
+        // Non-@-bot messages are subject to active-message and keyword policies.
+        if (!isAtBot) {
+            if (this.groupActiveMsgEnabled.get(chatId) === false) {
+                process.stderr.write(`[QQ:${this.name}] handleGroupAll blocked: active messages disabled for ${sanitizeLogText(chatId, 64)}\n`);
+                return;
+            }
+            const rawPolicy = this.qqConfig.groupAllPolicy;
+            const policy = rawPolicy === 'keyword' || rawPolicy === 'all' ? rawPolicy : 'log';
+            if (policy === 'log') {
+                process.stderr.write(`[QQ:${this.name}] Group ${sanitizeLogText(chatId, 64)}: log policy — message from ${sanitizeLogText(senderName, 64)} not forwarded\n`);
+                return;
+            }
+            if (policy === 'keyword') {
+                if (!this._keywordTriggerCache) {
+                    this._keywordTriggerCache = (this.qqConfig.keywordTriggers ?? [])
+                        .filter((kw) => kw.length > 0)
+                        .map((kw) => {
+                        const normalized = kw.normalize('NFC');
+                        const escaped = normalized.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                        const firstIsAscii = /^[A-Za-z0-9_]/.test(normalized);
+                        const lastIsAscii = /[A-Za-z0-9_]$/.test(normalized);
+                        const lb = firstIsAscii ? '(?:^|[^\\w])' : '';
+                        const la = lastIsAscii ? '(?:[^\\w]|$)' : '';
+                        return new RegExp(`${lb}${escaped}${la}`, 'i');
+                    });
+                }
+                if (this._keywordTriggerCache.length === 0) {
+                    process.stderr.write(`[QQ:${this.name}] Group ${sanitizeLogText(chatId, 64)}: keyword policy — no keywords configured, message from ${sanitizeLogText(senderName, 64)} not forwarded\n`);
+                    return;
+                }
+                const keywordText = result.cleanText.normalize('NFC');
+                const matched = this._keywordTriggerCache.some((re) => re.test(keywordText));
+                if (!matched) {
+                    const now = Date.now();
+                    const lastLog = this._lastKeywordNoMatchLog.get(chatId) ?? 0;
+                    if (now - lastLog >= 60000) {
+                        this._lastKeywordNoMatchLog.set(chatId, now);
+                        process.stderr.write(`[QQ:${this.name}] Group ${sanitizeLogText(chatId, 64)}: keyword policy — no match for message from ${sanitizeLogText(senderName, 64)}\n`);
+                    }
+                    return;
+                }
+            }
+        }
+        else if (this.groupActiveMsgEnabled.get(chatId) === false) {
+            process.stderr.write(`[QQ:${this.name}] handleGroupAll: @-bot message allowed through (passive) despite active messages disabled for ${sanitizeLogText(chatId, 64)}\n`);
+        }
+        // isDuplicate handles reconnect replay protection (same event.id).
+        if (this.isDuplicate(event.id))
+            return;
+        if (isSlash) {
+            process.stderr.write(`[QQ:${this.name}] Slash cmd from ${sanitizeLogText(safeName, 64)} (${sanitizeLogText(chatId, 64)}): ${sanitizeLogText(cleanText.split(/\s/)[0], 64)}\n`);
+        }
+        // Non-@-bot messages pass isMentioned:false, which causes GroupGate.requireMention
+        // to silently drop them before they reach the LLM. This is by core design:
+        // non-@-bot group messages should flow through cron/log only, not trigger AI.
+        // Thread #17's fix (setting isMentioned=true for non-@-bot keyword/all matches)
+        // was intentionally reverted — it violated principle #1.
+        // Users must set requireMention: false in group config
+        // (e.g., `groups: { '*': { requireMention: false } }`) to allow
+        // non-@-bot keyword/all messages to reach the AI.
+        const senderId = event.author.user_openid || event.author.id || event.author.member_openid;
+        if (!senderId) {
+            process.stderr.write(`[QQ:${this.name}] Group all-message dropped: no senderId for author\n`);
+            return;
+        }
+        // Set replyMsgId for all messages that pass the policy gate,
+        // not just @-bot ones.
+        this.setReplyMsgId(chatId, event.id);
+        this.handleInbound({
+            channelName: this.name,
+            chatId,
+            text,
+            senderId,
+            senderName,
+            messageId: event.id,
+            isGroup: true,
+            isMentioned: isAtBot,
+            isReplyToBot: isAtBot,
+            ...(isSlash ? {} : { alreadyPrefixed: true }),
+        }).catch((e) => {
+            process.stderr.write(`[QQ:${this.name}] handleGroupAll error: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}\n`);
+        });
+    }
+    // ── Group management events ────────────────────────────────────
+    handleGroupAddRobot(event) {
+        const groupId = event.group_openid;
+        if (!groupId) {
+            process.stderr.write(`[QQ:${this.name}] handleGroupAddRobot: missing group_openid\n`);
+            return;
+        }
+        if (!isValidChatId(groupId)) {
+            process.stderr.write(`[QQ:${this.name}] handleGroupAddRobot: invalid group_openid (length=${groupId.length})\n`);
+            return;
+        }
+        this.chatTypeMap.set(groupId, 'group');
+        this.saveQQState();
+        process.stderr.write(`[QQ:${this.name}] Added to group ${sanitizeLogText(groupId, 64)} by ${sanitizeLogText(event.op_member_openid, 64)}\n`);
+    }
+    handleGroupDelRobot(event) {
+        const groupId = event.group_openid;
+        if (!groupId) {
+            process.stderr.write(`[QQ:${this.name}] handleGroupDelRobot: missing group_openid\n`);
+            return;
+        }
+        if (!isValidChatId(groupId)) {
+            process.stderr.write(`[QQ:${this.name}] handleGroupDelRobot: invalid group_openid (length=${groupId.length})\n`);
+            return;
+        }
+        this.chatTypeMap.delete(groupId);
+        this.groupActiveMsgEnabled.delete(groupId);
+        // msgSeqMap is keyed by message ID, not group_openid — get the
+        // message ID from replyMsgId before deleting the reply entry.
+        const replyEntry = this.replyMsgId.get(groupId);
+        if (replyEntry)
+            this.msgSeqMap.delete(replyEntry.msgId);
+        this.replyMsgId.delete(groupId);
+        this.botOpenIdByGroup.delete(groupId);
+        this._lastKeywordNoMatchLog.delete(groupId);
+        // Clean up cron buffers targeting this group (always, regardless of config flag)
+        let cleanedCron = 0;
+        for (const [sid, entry] of this.cronBuffer) {
+            const state = this.streamState.get(sid);
+            if (state?.chatId === groupId) {
+                if (entry.timer)
+                    clearTimeout(entry.timer);
+                this.cronBuffer.delete(sid);
+                cleanedCron++;
+            }
+        }
+        // Clean up active streamState sessions targeting this group.
+        // Cancel pending idle-flush timers before deleting entries so
+        // setTimeout callbacks don't fire and attempt to send to the
+        // removed group.
+        let cleanedStreams = 0;
+        for (const [sid, state] of this.streamState) {
+            if (state.chatId === groupId) {
+                if (state.timer)
+                    clearTimeout(state.timer);
+                this.flushingSessions.delete(sid);
+                this.pendingStreamDelete.delete(sid);
+                this.flushedSessions.delete(sid);
+                this.streamState.delete(sid);
+                if (this.config.sessionScope !== 'single') {
+                    this.onSessionDied(sid);
+                }
+                cleanedStreams++;
+            }
+        }
+        this.saveQQState();
+        process.stderr.write(`[QQ:${this.name}] Removed from group ${sanitizeLogText(groupId, 64)} by ${sanitizeLogText(event.op_member_openid, 64)}, cleaned ${cleanedStreams} stream(s) and ${cleanedCron} cron buffer(s)\n`);
+    }
+    handleGroupMsgToggle(event, enabled) {
+        if (!event.group_openid) {
+            process.stderr.write(`[QQ:${this.name}] Group msg toggle dropped: missing group_openid\n`);
+            return;
+        }
+        if (!isValidChatId(event.group_openid)) {
+            process.stderr.write(`[QQ:${this.name}] Group msg toggle dropped: invalid group_openid\n`);
+            return;
+        }
+        this.groupActiveMsgEnabled.set(event.group_openid, enabled);
+        this.saveQQState();
+        process.stderr.write(`[QQ:${this.name}] Active msg ${enabled ? 'enabled' : 'disabled'} for group ${sanitizeLogText(event.group_openid, 64)}\n`);
+    }
+}
+//# sourceMappingURL=QQChannel.js.map