@qwen-code/qwen-code 0.19.8 → 0.19.9-preview.0

package/chunks/{dist-E6UANPIM.js → dist-U75JK3PF.js}

@@ -7,16 +7,16 @@ import {
   sanitizeLogText,
   sanitizePromptText,
   sanitizeSenderName
-} from "./chunk-IBY3Q3HG.js";
-import "./chunk-VRDMOSQS.js";
-import "./chunk-K5PGHDBN.js";
+} from "./chunk-AU4R7ACM.js";
+import "./chunk-UDXSXLER.js";
+import "./chunk-H6XPXXMH.js";
 import {
   wrapper_default
-} from "./chunk-H6BD2ELD.js";
-import "./chunk-5IFG2VC4.js";
+} from "./chunk-TYAMGABM.js";
+import "./chunk-FCMNKVXT.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __commonJS,
   __name,
@@ -1132,8 +1132,10 @@ var OpCode = {
 var Intent = {
   C2C_MESSAGE: 1 << 12,
   // C2C 消息
-  GROUP_AT_MESSAGE: 1 << 25
+  GROUP_AT_MESSAGE: 1 << 25,
   // 群聊 @ 消息事件
+  GROUP_MESSAGE: 1 << 26
+  // 群聊全量消息事件 (GROUP_MESSAGE_CREATE)
 };
 
 // packages/channels/qqbot/dist/accounts.js
@@ -1424,6 +1426,17 @@ async function sendQQMessage(base, path, accessToken, body) {
 __name(sendQQMessage, "sendQQMessage");
 
 // packages/channels/qqbot/dist/QQChannel.js
+var DeliveryError = class extends Error {
+  static {
+    __name(this, "DeliveryError");
+  }
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "DeliveryError";
+  }
+};
 function isValidChatId(id) {
   return /^[A-Za-z0-9_-]+$/.test(id) && id.length <= 128;
 }
@@ -1440,7 +1453,7 @@ var QQChannel = class _QQChannel extends ChannelBase {
   heartbeatInterval = 45e3;
   seq = 0;
   reconnectAttempts = 0;
-  maxReconnectAttempts = 20;
+  maxReconnectAttempts;
   /** QQ Bot session_id from READY, used for RESUME on reconnect. */
   sessionId = "";
   /** Whether this connection attempt should try RESUME first. */
@@ -1481,11 +1494,35 @@ var QQChannel = class _QQChannel extends ChannelBase {
   /** Idle-flush timeout: buffer is sent after this many ms of silence. */
   static IDLE_FLUSH_MS = 2e3;
   /** Max consecutive send failures before the stream is abandoned. */
-  static MAX_FLUSH_RETRIES = 3;
+  maxFlushRetries;
   /** Retry delay for subsequent attempts (backoff beyond first retry). */
   static IDLE_FLUSH_BACKOFF_MS = 4e3;
   /** 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ new Map();
+  /** Accumulation buffer for cron/non-prompt textChunk events. */
+  cronBuffer = /* @__PURE__ */ 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.
@@ -1509,14 +1546,13 @@ var QQChannel = class _QQChannel extends ChannelBase {
   streamState = /* @__PURE__ */ new Map();
   flushingSessions = /* @__PURE__ */ new Set();
   pendingStreamDelete = /* @__PURE__ */ new Set();
-  reconnectId = 0;
+  _reconnectId = 0;
   blockStreaming = false;
   flushedSessions = /* @__PURE__ */ new Set();
   qqStatePath;
   /**
-   * Path to the SessionRouter persistence file we back up before shutdown.
-   * start.ts passes a shared router; standalone QQChannel instances use a
-   * per-channel router file.
+   * 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. */
@@ -1526,30 +1562,243 @@ var QQChannel = class _QQChannel extends ChannelBase {
     const stateDir = join2(getGlobalQwenDir(), "channels");
     mkdirSync2(stateDir, { recursive: true });
     const sessionsPath = join2(stateDir, `${safeName}-sessions.json`);
-    const hasExternalRouter = Boolean(options?.router);
+    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.
+`);
+      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 ?? !hasExternalRouter
+      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 !== void 0 && (!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}
+`);
+      this.qqConfig.bufferFlushLength = _QQChannel.MAX_BUFFER_LENGTH;
+    }
     this.blockStreaming = this.config.blockStreaming === "on";
     this.qqStatePath = join2(stateDir, `${safeName}-state.json`);
-    this.globalSessionsPath = hasExternalRouter ? join2(stateDir, "sessions.json") : sessionsPath;
+    this.globalSessionsPath = options?.router ? join2(stateDir, "sessions.json") : sessionsPath;
     this.sessionsBackupPath = join2(stateDir, `${safeName}-sessions-backup.json`);
+    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)}
+`);
+        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 : 2e3;
+      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)}
+`);
+              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 = "";
+                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)}
+`);
+                  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)}
+`);
+                  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;
+                  }
+                  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)}
+`);
+                      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)}
+`);
+                      entry.pendingRetry = "";
+                      if (code2 === "RETRY_EXHAUSTED" || code2 === "ACTIVE_MSG_DISABLED" || code2 === "FALLBACK_FAILED") {
+                        this.cronBuffer.delete(sessionId);
+                        return;
+                      }
+                      process.stderr.write(`[QQ:${this.name}] Cron flush retries exhausted, dropped ${toFlush.length} chars for session ${sanitizeLogText(sessionId, 32)}
+`);
+                      this.cronBuffer.delete(sessionId);
+                    });
+                  }, entry.retryCount === 2 ? 1e4 : 5e3);
+                  entry.timer.unref();
+                });
+              }, 5e3);
+              entry.timer.unref();
+            });
+            return;
+          }
+        }
+        process.stderr.write(`[QQ:${this.name}] Cron flush dropped: no target for session ${sanitizeLogText(sessionId, 32)}, lost ${toFlush.length} chars
+`);
+        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() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this._reconnectId++;
     this.disposed = false;
-    this.reconnectId++;
+    this.reconnectAttempts = 0;
+    this.serverRequestedReconnect = false;
+    this.tryResume = false;
     if (!this.config.instructions) {
-      this.config.instructions = [
+      const parts = [
         "## QQ Bot Channel",
         "",
         "\u4F60\u662F\u901A\u8FC7 QQ Bot \u4E0E\u7528\u6237\u5BF9\u8BDD\u7684 AI \u52A9\u624B\u3002",
-        "\u56DE\u590D\u63A7\u5236\u5728 2000 \u5B57\u7B26\u4EE5\u5185\uFF0C\u652F\u6301 Markdown \u683C\u5F0F\u3002"
-      ].join("\n");
+        "\u652F\u6301 Markdown \u683C\u5F0F\uFF0C\u56DE\u590D\u81EA\u7136\u6D41\u7545\u5373\u53EF\u3002",
+        "\u6D88\u606F\u524D\u7F00 [atMention=true] \u8868\u793A\u8BE5\u6D88\u606F @\u4E86\u4F60\uFF0C[atMention=false] \u8868\u793A\u672A @\u4F60\u3002",
+        "\u4E0D\u60F3\u56DE\u590D\u65F6\u53EA\u8F93\u51FA <noreply> \u5373\u53EF\uFF0C\u6D88\u606F\u4E0D\u4F1A\u53D1\u51FA\u3002",
+        "",
+        "\u4EE5\u4E0B\u89C4\u5219\u4EC5\u9002\u7528\u4E8E\u7FA4\u804A\u6D88\u606F\u3002C2C \u79C1\u804A\u4E2D\u8BF7\u59CB\u7EC8\u6B63\u5E38\u56DE\u590D\u3002",
+        "## \u7FA4\u804A\u5524\u9192\u4E0E\u9759\u9ED8\u89C4\u5219",
+        "",
+        "### \u5F53 [atMention=false] \u2014 \u672A @\u4F60",
+        "\u7531\u4F60\u81EA\u4E3B\u5224\u65AD\u5F53\u524D\u804A\u5929\u6C1B\u56F4\u662F\u5426\u9002\u5408\u63D2\u5634\uFF1A",
+        "- \u95F2\u804A/\u8C03\u4F83/\u73A9\u6897 \u2192 \u53EF\u4EE5\u63A5\u832C\uFF0C\u98CE\u8DA3\u5373\u53EF",
+        "- \u4E25\u8083\u8BA8\u8BBA/\u4E8B\u52A1\u534F\u5546 \u2192 \u4FDD\u6301\u6C89\u9ED8",
+        "- \u4E0D\u786E\u5B9A \u2192 \u6C89\u9ED8",
+        "",
+        "### \u5F53 [atMention=true] \u2014 @\u4E86\u4F60",
+        "\u5148\u53BB\u6389 @\u6807\u7B7E\u548C\u4F60\u7684\u540D\u5B57\uFF0C\u5269\u4E0B\u7684\u5185\u5BB9\u662F\u5BF9\u4F60\u7684\u63D0\u95EE\u6216\u6307\u4EE4\u5417\uFF1F",
+        "",
+        "\u4EE5\u4E0B\u573A\u666F\u5373\u4F7F @\u4E86\u4F60\u4E5F\u5FC5\u987B\u6C89\u9ED8\uFF1A",
+        '1. \u7EAF\u63D0\u53CA/\u9648\u8FF0 \u2014 "QwenCode \u597D\u50CF\u53D8\u806A\u660E\u4E86"',
+        '2. \u8F6C\u8FF0/\u5F15\u7528 \u2014 "\u521A\u624D QwenCode \u7ED9\u7684\u65B9\u6848\u53EF\u4EE5"',
+        '3. \u95F4\u63A5\u547C\u53EB \u2014 "@\u674E\u56DB \u4F60\u8BA9 QwenCode \u67E5\u4E0B"',
+        '4. \u8C03\u4F83/\u8BD5\u63A2 \u2014 "\u8FD9\u4E8B QwenCode \u80AF\u5B9A\u4E0D\u77E5\u9053"',
+        "",
+        "### \u56DE\u590D\u51C6\u5219",
+        '- \u88AB\u5524\u9192\u540E\u76F4\u63A5\u505A\u4E8B\uFF0C\u7981\u6B62"\u6211\u5728"\u7B49\u5360\u4F4D\u56DE\u590D',
+        "- \u4E00\u6761\u6D88\u606F @\u591A\u4EBA\u65F6\uFF0C\u53EA\u6709\u660E\u786E\u6307\u6D3E\u7ED9\u4F60\u624D\u63A5",
+        "- \u4E0D\u786E\u8BA4\u65F6\u5148\u6C89\u9ED8",
+        "- \u5B8C\u6210\u5BF9\u8BDD\u540E\u7ACB\u523B\u56DE\u5F52\u9759\u9ED8"
+      ];
+      if (this.qqConfig.allowMention !== false) {
+        parts.push("", "## @\u63D0\u53CA\u683C\u5F0F", "", "\u6D88\u606F\u5185\u5BB9\u4E2D\u7684 <@OPENID> \u6807\u7B7E\u4EE3\u8868\u7FA4\u6210\u5458\u7684 QQ \u6807\u8BC6\u3002", "\u5F53\u5176\u4ED6\u7FA4\u6210\u5458 @\u4F60\uFF08\u673A\u5668\u4EBA\uFF09\u65F6\uFF0C\u6D88\u606F\u5185\u5BB9\u4E2D\u4F1A\u51FA\u73B0 <@\u4F60\u7684BotOPENID> \u6807\u7B7E\uFF0C\u8FD9\u4EE3\u8868\u8BE5\u6D88\u606F\u662F @\u7ED9\u4F60\u7684\u3002\u673A\u5668\u4EBA\u81EA\u5DF1\u7684 OPENID \u5C06\u5728\u8FDE\u63A5\u5EFA\u7ACB\u540E\u544A\u77E5\u3002", "\u4F60\u53EF\u4EE5\u5728\u56DE\u590D\u4E2D\u4F7F\u7528 <@OPENID> \u683C\u5F0F\u6765 @\u63D0\u53CA\u7279\u5B9A\u7684\u7FA4\u6210\u5458\u3002", '\u4F8B\u5982\uFF1A\u56DE\u590D "<@ABC123DEF456> \u4F60\u597D" \u4F1A\u5728\u7FA4\u91CC @\u8BE5\u6210\u5458\u3002');
+      }
+      this.config.instructions = parts.join("\n");
     }
     for (let attempt = 0; attempt < 3; attempt++) {
       try {
@@ -1592,24 +1841,33 @@ var QQChannel = class _QQChannel extends ChannelBase {
       this.replyMsgId.delete(chatId);
       this.saveQQState();
     }
+    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}
+`);
+      throw new DeliveryError("ACTIVE_MSG_DISABLED", `Active messages disabled for ${sanitizeLogText(chatId, 64)}`);
+    }
     let nextSeq = 0;
     let rollbackApplied = false;
     try {
-      const body = {
+      const passiveBody = {
         msg_type: 2,
         markdown: { content: text }
       };
       nextSeq = msgId ? (this.msgSeqMap.get(msgId) ?? 0) + 1 : 0;
       if (msgId) {
         this.msgSeqMap.set(msgId, nextSeq);
-        body["msg_id"] = msgId;
-        body["msg_seq"] = nextSeq;
+        passiveBody["msg_id"] = msgId;
+        passiveBody["msg_seq"] = nextSeq;
       }
-      const resp = await sendQQMessage(route.base, route.path, this.accessToken, body);
+      const resp = await sendQQMessage(route.base, route.path, this.accessToken, passiveBody);
       if (!resp.ok) {
-        const errBody = await resp.text().catch(() => "");
-        process.stderr.write(`[QQ:${this.name}] Send failed (HTTP ${resp.status}: ${sanitizeLogText(errBody, 200)})
+        const errBody = sanitizeLogText(await resp.text().catch(() => ""), 200);
+        if (resp.status !== 429) {
+          process.stderr.write(`[QQ:${this.name}] Send failed (HTTP ${resp.status}: ${errBody})
+
 `);
+        }
         if (resp.status === 429) {
           process.stderr.write(`[QQ:${this.name}] MESSAGE DROPPED: rate-limited (429) on markdown attempt for ${sanitizeLogText(chatId, 64)}
 `);
@@ -1617,41 +1875,61 @@ var QQChannel = class _QQChannel extends ChannelBase {
             this.msgSeqMap.set(msgId, nextSeq - 1);
             this.saveQQState();
           }
-          return;
+          throw new DeliveryError("RATE_LIMITED", `Message blocked by rate limit for ${sanitizeLogText(chatId, 64)}`);
         }
         if (msgId) {
           this.msgSeqMap.set(msgId, nextSeq - 1);
           rollbackApplied = true;
-          const activeBody = {
-            content: text,
-            msg_type: 0,
-            msg_id: msgId,
-            msg_seq: nextSeq
+          if (this.groupActiveMsgEnabled.get(chatId) === false) {
+            process.stderr.write(`[QQ:${this.name}] MESSAGE DROPPED: active messages disabled for ${sanitizeLogText(chatId, 64)}, cannot retry
+`);
+            this.saveQQState();
+            throw new DeliveryError("ACTIVE_MSG_DISABLED", `Active messages disabled for ${sanitizeLogText(chatId, 64)}`);
+          }
+          const activeMdBody = {
+            msg_type: 2,
+            markdown: { content: text }
           };
-          const activeResp = await sendQQMessage(route.base, route.path, this.accessToken, activeBody);
-          if (activeResp.ok) {
-            process.stderr.write(`[QQ:${this.name}] Active retry succeeded for ${sanitizeLogText(chatId, 64)}
+          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)}
 `);
-            const current = this.replyMsgId.get(chatId);
-            if (current?.msgId === msgId) {
-              this.msgSeqMap.set(msgId, nextSeq);
-            }
             this.saveQQState();
-            await activeResp.text().catch(() => "");
+            await activeMdResp.text().catch(() => "");
             return;
           }
-          process.stderr.write(`[QQ:${this.name}] Active retry also failed (HTTP ${activeResp.status}: ${sanitizeLogText(await activeResp.text().catch(() => ""), 200)})
+          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)}
 `);
-          if (activeResp.status === 429) {
-            process.stderr.write(`[QQ:${this.name}] MESSAGE DROPPED: active retry rate-limited (HTTP 429) for ${sanitizeLogText(chatId, 64)}
+            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)}
+`);
+          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)}
 `);
             this.saveQQState();
+            await activeTextResp.text().catch(() => "");
             return;
           }
-          process.stderr.write(`[QQ:${this.name}] MESSAGE DROPPED: both passive and active send failed for ${sanitizeLogText(chatId, 64)}
+          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)}
+`);
+            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)}
 `);
           this.saveQQState();
-          return;
+          throw new DeliveryError("FALLBACK_FAILED", `All delivery attempts exhausted for ${sanitizeLogText(chatId, 64)}`);
         }
         const plainBody = {
           content: text,
@@ -1663,11 +1941,11 @@ var QQChannel = class _QQChannel extends ChannelBase {
           if (fallbackRes.status === 429) {
             process.stderr.write(`[QQ:${this.name}] MESSAGE DROPPED: rate-limited (429) on plain-text fallback for ${sanitizeLogText(chatId, 64)}
 `);
-            return;
+            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)}
 `);
-          return;
+          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)}
 `);
@@ -1683,8 +1961,10 @@ var QQChannel = class _QQChannel extends ChannelBase {
       }
       if (msgId)
         this.saveQQState();
-      process.stderr.write(`[QQ:${this.name}] Send error: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}
+      if (!(e instanceof DeliveryError)) {
+        process.stderr.write(`[QQ:${this.name}] Send error: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}
 `);
+      }
       throw e;
     }
   }
@@ -1693,23 +1973,44 @@ var QQChannel = class _QQChannel extends ChannelBase {
    * sandbox detection, and C2C/group path selection. Returns null if any guard fails.
    */
   async resolveRoute(chatId) {
-    if (this.disposed)
+    if (this.disposed) {
+      process.stderr.write(`[QQ:${this.name}] resolveRoute: channel disposed, dropping message to ${sanitizeLogText(chatId, 64)}
+`);
       return null;
+    }
     if (Date.now() >= this.tokenExpiresAt) {
       try {
         await this.fetchToken();
-      } catch {
+      } 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)}
+`);
         return null;
       }
     }
-    if (!this.accessToken || !isValidChatId(chatId))
+    if (!this.accessToken) {
+      process.stderr.write(`[QQ:${this.name}] resolveRoute: accessToken is empty after fetchToken
+`);
+      return null;
+    }
+    if (!isValidChatId(chatId)) {
+      process.stderr.write(`[QQ:${this.name}] resolveRoute: invalid chatId rejected (length=${chatId.length})
+`);
       return null;
+    }
     const base = getApiBase(Boolean(this.qqConfig.sandbox));
-    const path = this.chatTypeMap.get(chatId) === "group" ? `/v2/groups/${chatId}/messages` : `/v2/users/${chatId}/messages`;
+    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
+`);
+      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();
@@ -1725,6 +2026,19 @@ var QQChannel = class _QQChannel extends ChannelBase {
       process.off("beforeExit", this.beforeExitHook);
       this.beforeExitHook = null;
     }
+    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)
+`);
+    }
+    this.cronBuffer.clear();
+    this._lastKeywordNoMatchLog.clear();
     this.flushQQState();
     this.backupGlobalSessions();
     if (this.readyTimeout) {
@@ -1739,9 +2053,19 @@ var QQChannel = class _QQChannel extends ChannelBase {
       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
+`);
+    }
+    this._inCronFlow = 0;
     for (const [, state] of this.streamState) {
       if (state.timer)
         clearTimeout(state.timer);
@@ -1750,8 +2074,6 @@ var QQChannel = class _QQChannel extends ChannelBase {
     this.flushingSessions.clear();
     this.pendingStreamDelete.clear();
     this.flushedSessions.clear();
-    this.seenMessages.clear();
-    this.reconnectId++;
   }
   /**
    * QQ Bot API V2 does not provide a typing indicator endpoint.
@@ -1776,21 +2098,29 @@ var QQChannel = class _QQChannel extends ChannelBase {
         clearTimeout(state.timer);
         state.timer = null;
       }
-      if (state.buffer.length >= _QQChannel.MAX_BUFFER_LENGTH) {
+      if (state.buffer.length >= (this.qqConfig.bufferFlushLength ?? _QQChannel.MAX_BUFFER_LENGTH)) {
         const buf = state.buffer;
         state.buffer = "";
+        if (this.flushingSessions.has(sessionId)) {
+          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;
+    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) {
+    if (this._reconnectId !== reconnectId) {
       process.stderr.write(`[QQ:${this.name}] idleFlush discarded (reconnect) session=${sanitizeLogText(sessionId, 32)}
 `);
       return;
@@ -1800,7 +2130,7 @@ var QQChannel = class _QQChannel extends ChannelBase {
       return;
     if (this.flushingSessions.has(sessionId)) {
       if (!state.timer) {
-        const retryReconnectId = this.reconnectId;
+        const retryReconnectId = this._reconnectId;
         state.timer = setTimeout(() => {
           this.idleFlush(sessionId, retryReconnectId);
         }, _QQChannel.IDLE_FLUSH_MS);
@@ -1830,7 +2160,7 @@ var QQChannel = class _QQChannel extends ChannelBase {
         this.pendingStreamDelete.delete(sessionId);
         const s2 = this.streamState.get(sessionId);
         if (s2 === state && s2.buffer) {
-          this.idleFlush(sessionId, this.reconnectId);
+          this.idleFlush(sessionId, this._reconnectId);
         }
       }
       const s = this.streamState.get(sessionId);
@@ -1838,6 +2168,19 @@ var QQChannel = class _QQChannel extends ChannelBase {
         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
+`);
+        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)}
 `);
       if (this.pendingStreamDelete.has(sessionId)) {
@@ -1846,8 +2189,8 @@ var QQChannel = class _QQChannel extends ChannelBase {
         if (current === state) {
           current.buffer = buffer;
           current.retryCount++;
-          if (current.retryCount < _QQChannel.MAX_FLUSH_RETRIES) {
-            const reconnectId = this.reconnectId;
+          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);
@@ -1864,13 +2207,21 @@ var QQChannel = class _QQChannel extends ChannelBase {
         const current = this.streamState.get(sessionId);
         if (current === state) {
           current.buffer = buffer + (current.buffer || "");
-          if (current.buffer.length >= _QQChannel.MAX_BUFFER_LENGTH) {
-            this.idleFlush(sessionId, this.reconnectId);
+          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)}
+`);
+            } else {
+              this.idleFlush(sessionId, this._reconnectId);
+            }
           } else {
             current.retryCount++;
-            if (current.retryCount < _QQChannel.MAX_FLUSH_RETRIES) {
+            if (this.maxFlushRetries <= 0 || current.retryCount < this.maxFlushRetries) {
               if (!current.timer) {
-                const reconnectId = this.reconnectId;
+                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);
@@ -1907,6 +2258,16 @@ var QQChannel = class _QQChannel extends ChannelBase {
     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) {
@@ -1939,22 +2300,27 @@ var QQChannel = class _QQChannel extends ChannelBase {
     super.onSessionDied(sessionId);
   }
   // ── State Persistence (cross-server context continuation) ──────
-  /** Debounced state persistence to avoid blocking event loop. */
+  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() {
     if (this.disposed)
       return;
     if (this.saveTimer)
       clearTimeout(this.saveTimer);
-    const tmpPath = this.qqStatePath + ".tmp";
     this.saveTimer = setTimeout(() => {
       if (this.disposed)
         return;
+      const tmpPath = this.qqStatePath + ".tmp";
       try {
-        writeFileSync2(tmpPath, JSON.stringify({
-          chatTypeMap: Array.from(this.chatTypeMap.entries()),
-          replyMsgId: Array.from(this.replyMsgId.entries()),
-          msgSeqMap: Array.from(this.msgSeqMap.entries())
-        }), { mode: 384 });
+        writeFileSync2(tmpPath, this.serializeQQState(), { mode: 384 });
         renameSync(tmpPath, this.qqStatePath);
       } catch (e) {
         try {
@@ -1962,11 +2328,43 @@ var QQChannel = class _QQChannel extends ChannelBase {
         } catch {
         }
         process.stderr.write(`[QQ:${this.name}] saveQQState write failed: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}
+
 `);
       }
     }, 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((g2) => g2.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.
+`);
+    }
+  }
+  /**
+   * 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) {
@@ -1975,11 +2373,7 @@ var QQChannel = class _QQChannel extends ChannelBase {
     }
     const tmpPath = this.qqStatePath + ".tmp";
     try {
-      writeFileSync2(tmpPath, JSON.stringify({
-        chatTypeMap: Array.from(this.chatTypeMap.entries()),
-        replyMsgId: Array.from(this.replyMsgId.entries()),
-        msgSeqMap: Array.from(this.msgSeqMap.entries())
-      }), { mode: 384 });
+      writeFileSync2(tmpPath, this.serializeQQState(), { mode: 384 });
       renameSync(tmpPath, this.qqStatePath);
     } catch (e) {
       try {
@@ -1987,14 +2381,16 @@ var QQChannel = class _QQChannel extends ChannelBase {
       } catch {
       }
       process.stderr.write(`[QQ:${this.name}] flushQQState write failed: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}
+
 `);
     }
   }
   /**
    * Restore QQ routing state from disk.
-   * Validates and filters every entry on restore — corrupt or unexpected
-   * entries (e.g. unknown chat types, oversized replyMsgIds, negative seqs)
-   * are silently dropped so they don't propagate into runtime routing.
+   *
+   * 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 {
@@ -2006,41 +2402,60 @@ var QQChannel = class _QQChannel extends ChannelBase {
 `);
         return false;
       }
-      if (raw.chatTypeMap && Array.isArray(raw.chatTypeMap)) {
-        const rawCT = raw.chatTypeMap;
-        this.chatTypeMap = new Map(rawCT.filter(([k, v]) => typeof k === "string" && k.length <= 256 && (v === "c2c" || v === "group")));
-        const dropped = rawCT.length - this.chatTypeMap.size;
-        if (dropped > 0)
-          process.stderr.write(`[QQ:${this.name}] Dropped ${dropped} invalid chatTypeMap entries during restore
-`);
-      }
-      if (raw.replyMsgId && Array.isArray(raw.replyMsgId)) {
-        const now = Date.now();
-        const rawRM = raw.replyMsgId;
-        this.replyMsgId = new Map(rawRM.map(([k, v]) => (
-          // Old format: string -> { msgId: v, timestamp: now }
-          // New format: { msgId, timestamp } -> pass through
-          typeof v === "string" ? [k, { msgId: v, timestamp: now }] : [k, v]
-        )).filter(([k, v]) => {
-          if (typeof k !== "string" || k.length > 256)
-            return false;
-          if (typeof v !== "object" || v === null)
+      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})
+`);
+        }
+      }
+      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 entry = v;
-          return typeof entry.msgId === "string" && entry.msgId.length <= 128 && typeof entry.timestamp === "number" && Number.isFinite(entry.timestamp) && entry.timestamp <= now + _QQChannel.REPLY_MSG_ID_TTL_MS;
-        }));
-        const dropped = rawRM.length - this.replyMsgId.size;
-        if (dropped > 0)
-          process.stderr.write(`[QQ:${this.name}] Dropped ${dropped} invalid replyMsgId entries during restore
+          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})
+`);
+        }
+      }
+      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})
 `);
+        }
+      }
+      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})
+`);
+        }
       }
-      if (raw.msgSeqMap && Array.isArray(raw.msgSeqMap)) {
-        const rawMS = raw.msgSeqMap;
-        this.msgSeqMap = new Map(rawMS.filter(([k, v]) => typeof k === "string" && k.length <= 256 && typeof v === "number" && Number.isSafeInteger(v) && v >= 0));
-        const dropped = rawMS.length - this.msgSeqMap.size;
-        if (dropped > 0)
-          process.stderr.write(`[QQ:${this.name}] Dropped ${dropped} invalid msgSeqMap entries during restore
+      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})
 `);
+        }
       }
       return true;
     } catch (e) {
@@ -2060,7 +2475,10 @@ var QQChannel = class _QQChannel extends ChannelBase {
         if (data.trim())
           writeFileSync2(this.sessionsBackupPath, data, { mode: 384 });
       }
-    } catch {
+    } catch (e) {
+      process.stderr.write(`[QQ:${this.name}] backupGlobalSessions failed: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}
+
+`);
     }
   }
   restoreGlobalSessions() {
@@ -2068,7 +2486,10 @@ var QQChannel = class _QQChannel extends ChannelBase {
       if (!existsSync2(this.globalSessionsPath) && existsSync2(this.sessionsBackupPath)) {
         writeFileSync2(this.globalSessionsPath, readFileSync2(this.sessionsBackupPath, "utf-8"), { mode: 384 });
       }
-    } catch {
+    } catch (e) {
+      process.stderr.write(`[QQ:${this.name}] restoreGlobalSessions failed: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}
+
+`);
     }
   }
   /**
@@ -2110,7 +2531,10 @@ var QQChannel = class _QQChannel extends ChannelBase {
           tc.set(correctId, entry.cwd || "");
         }
       }
-    } catch {
+    } catch (e) {
+      process.stderr.write(`[QQ:${this.name}] fixRestoredSessions failed: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}
+
+`);
     }
   }
   // ── ReplyMsgId helpers ────────────────────────────────────────
@@ -2189,33 +2613,55 @@ var QQChannel = class _QQChannel extends ChannelBase {
       return;
     this.stopTokenRefresh();
     const ttl = Math.max(0, this.tokenExpiresAt - Date.now());
-    const delay = Math.max(Math.min(ttl * 0.8, ttl - 6e4), 6e4);
+    const delay = Math.min(ttl * 0.8, Math.max(ttl - 3e4, 1e4));
     if (delay > 0) {
+      const tokenReconnectId = this._reconnectId;
       this.tokenRefreshTimer = setTimeout(() => {
         this.fetchToken().catch((e) => {
-          if (this.disposed)
+          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)}, retrying in 60s
+          process.stderr.write(`[QQ:${this.name}] Token refresh failed: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}, will retry
+
+`);
+          let retryCount = 0;
+          const retry = /* @__PURE__ */ __name(() => {
+            if (this.disposed || this._reconnectId !== tokenReconnectId)
+              return;
+            if (++retryCount > 10) {
+              process.stderr.write(`[QQ:${this.name}] FATAL: token refresh exhausted, reconnecting
+
+`);
+              this.isReconnecting = true;
+              this.disconnect();
+              const postDisconnectReconnectId = this._reconnectId;
+              this.reconnectTimer = setTimeout(() => {
+                if (this._reconnectId !== postDisconnectReconnectId)
+                  return;
+                this.isReconnecting = false;
+                this.disposed = false;
+                this.reconnectWithRetry();
+              }, 1e3);
+              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)}
+
 `);
-          this.scheduleTokenRefreshRetry();
+                retry();
+              });
+            }, 6e4);
+            this.tokenRefreshTimer.unref?.();
+          }, "retry");
+          retry();
         });
       }, delay);
+      this.tokenRefreshTimer.unref?.();
     }
   }
-  scheduleTokenRefreshRetry() {
-    if (this.disposed)
-      return;
-    this.stopTokenRefresh();
-    this.tokenRefreshTimer = setTimeout(() => {
-      this.fetchToken().catch((e) => {
-        if (this.disposed)
-          return;
-        process.stderr.write(`[QQ:${this.name}] Token refresh failed: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}, retrying in 60s
-`);
-        this.scheduleTokenRefreshRetry();
-      });
-    }, 6e4);
-  }
   stopTokenRefresh() {
     if (this.tokenRefreshTimer) {
       clearTimeout(this.tokenRefreshTimer);
@@ -2238,7 +2684,9 @@ var QQChannel = class _QQChannel extends ChannelBase {
     this.readyTimeout = setTimeout(() => {
       if (this.ws !== dialed)
         return;
-      this.ws.close(4002, "READY timeout");
+      process.stderr.write(`[QQ:${this.name}] READY timeout after 30s, closing
+`);
+      this.ws?.close(4002, "READY timeout");
       reject(new Error(`[QQ:${this.name}] READY timeout after 30s`));
     }, 3e4);
     this.readyTimeout.unref?.();
@@ -2266,21 +2714,26 @@ var QQChannel = class _QQChannel extends ChannelBase {
       }
       this.stopHeartbeat();
       this.ws = null;
-      const shouldReconnect = this.serverRequestedReconnect || code !== 1e3 && this.reconnectAttempts < this.maxReconnectAttempts;
+      this._ready = false;
+      const shouldReconnect = this.serverRequestedReconnect || code !== 1e3 && (this.maxReconnectAttempts <= 0 || this.reconnectAttempts < this.maxReconnectAttempts);
       this.serverRequestedReconnect = false;
+      if (code !== 1e3 && code !== 4e3) {
+        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) {
-        this.reconnectAttempts++;
         const delay = Math.min(1e3 * 2 ** this.reconnectAttempts, 3e4);
-        process.stderr.write(`[QQ:${this.name}] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})
+        process.stderr.write(`[QQ:${this.name}] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}${this.maxReconnectAttempts > 0 ? `/${this.maxReconnectAttempts}` : ""})
 `);
         if (!this.isReconnecting) {
           this.reconnectTimer = setTimeout(() => this.reconnectWithRetry(), delay);
           this.reconnectTimer.unref();
         }
-      } else if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      } 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.
 `);
         if (this.connectReject) {
@@ -2302,6 +2755,19 @@ var QQChannel = class _QQChannel extends ChannelBase {
       }
     });
   }
+  /**
+   * 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) {
@@ -2326,28 +2792,56 @@ var QQChannel = class _QQChannel extends ChannelBase {
           this.tryResume = true;
           this.connectReject = null;
           this.startHeartbeat();
-          this.restoreGlobalSessions();
-          this.restoreQQState();
-          this.router.restoreSessions().then(() => {
-            this.fixRestoredSessions();
-            const all = this.router.getAll?.();
-            const sessions = all?.map((e) => `${e.target?.chatId}:${e.sessionId}`).join(", ") || "none";
-            process.stderr.write(`[QQ:${this.name}] Ready (sessions: ${sessions})
+          if (this.coldStart) {
+            this.restoreGlobalSessions();
+            if (!this.restoreQQState()) {
+              process.stderr.write(`[QQ:${this.name}] WARNING: QQ state restore failed \u2014 routing maps are empty, group messages may be misrouted
+`);
+            }
+            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)
+`);
+              this.finalizeReady();
+              this._checkGroupAllPolicyRequireMention();
+              onReady();
+            }).catch(() => {
+              process.stderr.write(`[QQ:${this.name}] WARNING: router session restore failed \u2014 cron messages will be dropped until sessions re-establish
+`);
+              this.finalizeReady();
+              this._checkGroupAllPolicyRequireMention();
+              onReady();
+            });
+          } else {
+            process.stderr.write(`[QQ:${this.name}] Ready (warm reconnect, skipping state restore)
 `);
+            this.finalizeReady();
+            this._checkGroupAllPolicyRequireMention();
             onReady();
-          }).catch(() => 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") {
-          this.reconnectAttempts = 0;
-          this.isReconnecting = false;
           if (this.readyTimeout) {
             clearTimeout(this.readyTimeout);
             this.readyTimeout = null;
           }
           this.connectReject = null;
+          this.finalizeReady();
           this.startHeartbeat();
           onReady();
         }
@@ -2364,7 +2858,28 @@ var QQChannel = class _QQChannel extends ChannelBase {
         process.stderr.write(`[QQ:${this.name}] Server sent INVALID_SESSION, falling back to IDENTIFY
 `);
         this.tryResume = false;
+        if (this.saveTimer) {
+          clearTimeout(this.saveTimer);
+          this.saveTimer = null;
+        }
+        this.flushQQState();
+        this._ready = false;
+        this.coldStart = true;
         this.sendIdentify();
+        if (this.readyTimeout) {
+          clearTimeout(this.readyTimeout);
+          this.readyTimeout = null;
+        }
+        this.readyTimeout = setTimeout(() => {
+          if (this.ws && (this.ws.readyState === wrapper_default.OPEN || this.ws.readyState === wrapper_default.CONNECTING)) {
+            this.ws.close(4002);
+            if (this.connectReject) {
+              this.connectReject(new Error("Timed out waiting for READY"));
+              this.connectReject = null;
+            }
+          }
+        }, 3e4);
+        this.readyTimeout.unref?.();
         break;
       default:
         break;
@@ -2386,11 +2901,12 @@ var QQChannel = class _QQChannel extends ChannelBase {
       }));
       return;
     }
+    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,
+        intents: Intent.C2C_MESSAGE | Intent.GROUP_AT_MESSAGE | (needsGroupMsg ? Intent.GROUP_MESSAGE : 0),
         shard: [0, 1],
         properties: {}
       }
@@ -2407,47 +2923,56 @@ var QQChannel = class _QQChannel extends ChannelBase {
     if (this.isReconnecting)
       return;
     this.isReconnecting = true;
-    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-      process.stderr.write(`[QQ:${this.name}] RC: reconnect attempts exhausted, giving up
+    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
 `);
-      this.isReconnecting = false;
-      return;
-    }
-    const maxGwRetries = 5;
-    let gatewayAttempted = false;
-    for (let attempt = 0; attempt < maxGwRetries; attempt++) {
-      try {
+          return;
+        }
         try {
-          await this.fetchToken();
-        } catch {
-          process.stderr.write(`[QQ:${this.name}] RC: token refresh failed, retrying...
+          try {
+            await this.fetchToken();
+          } catch {
+            process.stderr.write(`[QQ:${this.name}] RC: token refresh failed, retrying...
 `);
-          await this.sleep(2e3);
-          continue;
-        }
-        gatewayAttempted = true;
-        await this.connectGateway();
-        return;
-      } catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        const backoff = Math.min(1e3 * 2 ** (attempt + 1), 3e4);
-        process.stderr.write(`[QQ:${this.name}] RC: ${sanitizeLogText(msg, 200)} (retry in ${backoff}ms, attempt ${attempt + 1}/${maxGwRetries})
+            await this.sleep(2e3);
+            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(1e3 * 2 ** (attempt + 1), 3e4);
+          process.stderr.write(`[QQ:${this.name}] RC: ${sanitizeLogText(msg, 200)} (retry in ${backoff}ms, attempt ${attempt + 1}${unlimitedRetries ? "" : `/${maxGwRetries}`})
 `);
-        if (attempt < maxGwRetries - 1)
-          await this.sleep(backoff);
+          if (unlimitedRetries || attempt < maxGwRetries - 1)
+            await this.sleep(backoff);
+        }
       }
-    }
-    process.stderr.write(`[QQ:${this.name}] RC: exhausted ${maxGwRetries} reconnect retries, will retry in 60s
+      process.stderr.write(`[QQ:${this.name}] RC: exhausted ${unlimitedRetries ? "\u221E" : maxGwRetries} reconnect retries, will retry in 60s
 `);
-    if (gatewayAttempted)
-      this.reconnectAttempts++;
-    this.tryResume = false;
-    this.isReconnecting = false;
+      this.tryResume = false;
+    } finally {
+      this.isReconnecting = false;
+    }
     this.reconnectTimer = setTimeout(() => this.reconnectWithRetry(), 6e4);
     this.reconnectTimer.unref();
   }
   sleep(ms) {
-    return new Promise((r) => setTimeout(r, ms));
+    return new Promise((r) => {
+      const t = setTimeout(r, ms);
+      t.unref?.();
+    });
   }
   startHeartbeat() {
     this.stopHeartbeat();
@@ -2472,6 +2997,23 @@ var QQChannel = class _QQChannel extends ChannelBase {
       this.heartbeatTimer = null;
     }
   }
+  // ── Bot OpenID extraction ──────────────────────────────────────
+  extractBotOpenId(mentions, chatId) {
+    const selfMention = mentions?.find((m3) => m3.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)}
+`);
+      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) {
@@ -2494,68 +3036,340 @@ var QQChannel = class _QQChannel extends ChannelBase {
     }
     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();
+    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((m3) => m3.is_you) ?? false;
+    if (isAtBot && !this.botOpenIdByGroup.has(chatId)) {
+      this.extractBotOpenId(event.mentions, chatId);
+    }
+    if (!cleanText)
+      return null;
+    const effectiveIsAtBot = forceAtMention ?? isAtBot;
+    const isSlash = effectiveIsAtBot && safeCleanText.startsWith("/");
+    const groupBotOpenId = this.botOpenIdByGroup.get(chatId);
+    const openIdSuffix = this.qqConfig.allowMention !== false && groupBotOpenId ? ` [botOpenId:${groupBotOpenId}]` : "";
+    const suffixFromBotOpenId = this.qqConfig.allowMention !== false && groupBotOpenId ? `
+\u673A\u5668\u4EBA 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)
+    if (!event.author) {
+      process.stderr.write(`[QQ:${this.name}] C2C message dropped: missing author
+`);
+      return;
+    }
+    if (event.author.bot) {
+      process.stderr.write(`[QQ:${this.name}] Bot C2C message dropped
+`);
       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
+`);
+      return;
+    }
+    if (!isValidChatId(chatId)) {
+      process.stderr.write(`[QQ:${this.name}] C2C message dropped: invalid chatId (length=${chatId.length})
+`);
+      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();
+    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: event.author.username || event.author.id || "QQ User",
+      senderName,
       chatId,
-      text: event.content,
+      text,
       messageId: event.id,
       isGroup: false,
       isMentioned: true,
-      isReplyToBot: false
+      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)}
 `));
   }
   handleGroup(event) {
-    if (this.isDuplicate(event.id))
-      return;
     if (!event.group_openid) {
       process.stderr.write(`[QQ:${this.name}] Group message dropped: missing group_openid
+`);
+      return;
+    }
+    if (!event.author) {
+      process.stderr.write(`[QQ:${this.name}] Group message dropped: missing author
+`);
+      return;
+    }
+    if (event.author.bot) {
+      process.stderr.write(`[QQ:${this.name}] Bot message dropped in group ${sanitizeLogText(event.group_openid, 64)}
 `);
       return;
     }
     const chatId = event.group_openid;
+    if (!isValidChatId(chatId)) {
+      process.stderr.write(`[QQ:${this.name}] Group message dropped: invalid group_openid
+`);
+      return;
+    }
+    const isNewGroup = !this.chatTypeMap.has(chatId);
     this.chatTypeMap.set(chatId, "group");
-    this.setReplyMsgId(chatId, event.id);
-    const senderName = event.author.username || event.author.id || "QQ User";
-    const cleanText = (event.content || "").replace(/<@[^>]{1,64}>/g, "").trim();
-    if (!cleanText)
+    if (isNewGroup)
+      this.saveQQState();
+    const result = this.prepareGroupMessage(event, chatId, {
+      forceAtMention: true
+    });
+    if (!result)
+      return;
+    const { isSlash, text, senderName, safeName, cleanText } = result;
+    if (this.isDuplicate(event.id))
       return;
-    const isSlash = cleanText.startsWith("/");
-    const safeName = sanitizeSenderName(senderName);
     if (isSlash) {
-      const loggedCmd = sanitizeLogText(cleanText, 80);
-      process.stderr.write(`[QQ:${this.name}] Slash cmd from ${safeName} (${chatId}): ${loggedCmd}
+      process.stderr.write(`[QQ:${this.name}] Slash cmd from ${sanitizeLogText(safeName, 64)} (${sanitizeLogText(chatId, 64)}): ${sanitizeLogText(cleanText.split(/\s/)[0], 64)}
+`);
+    }
+    if (this.groupActiveMsgEnabled.get(chatId) === false) {
+      process.stderr.write(`[QQ:${this.name}] handleGroup: active messages disabled but @-bot allowed through (passive)
+`);
+    }
+    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
 `);
+      return;
     }
-    const text = isSlash ? cleanText : `[${safeName}]: ${sanitizePromptText(cleanText)}`;
+    this.setReplyMsgId(chatId, event.id);
     this.handleInbound({
       channelName: this.name,
-      senderId: event.author.user_openid || event.author.id,
+      senderId,
       senderName,
       chatId,
       text,
       messageId: event.id,
       isGroup: true,
       isMentioned: true,
-      // QQ Bot only receives group messages when explicitly @mentioned, so
-      // every group message is semantically a reply to the bot.
       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)}
 `));
   }
+  handleGroupAll(event) {
+    if (!event.group_openid) {
+      process.stderr.write(`[QQ:${this.name}] Group all-message dropped: missing group_openid
+`);
+      return;
+    }
+    if (!event.author) {
+      process.stderr.write(`[QQ:${this.name}] Group all-message dropped: missing author
+`);
+      return;
+    }
+    if (event.author.bot) {
+      process.stderr.write(`[QQ:${this.name}] Bot message dropped in group ${sanitizeLogText(event.group_openid, 64)}
+`);
+      return;
+    }
+    const chatId = event.group_openid;
+    if (!isValidChatId(chatId)) {
+      process.stderr.write(`[QQ:${this.name}] Group all-message dropped: invalid group_openid
+`);
+      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;
+    if (!isAtBot) {
+      if (this.groupActiveMsgEnabled.get(chatId) === false) {
+        process.stderr.write(`[QQ:${this.name}] handleGroupAll blocked: active messages disabled for ${sanitizeLogText(chatId, 64)}
+`);
+        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 \u2014 message from ${sanitizeLogText(senderName, 64)} not forwarded
+`);
+        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 \u2014 no keywords configured, message from ${sanitizeLogText(senderName, 64)} not forwarded
+`);
+          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 >= 6e4) {
+            this._lastKeywordNoMatchLog.set(chatId, now);
+            process.stderr.write(`[QQ:${this.name}] Group ${sanitizeLogText(chatId, 64)}: keyword policy \u2014 no match for message from ${sanitizeLogText(senderName, 64)}
+`);
+          }
+          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)}
+`);
+    }
+    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)}
+`);
+    }
+    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
+`);
+      return;
+    }
+    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)}
+`);
+    });
+  }
+  // ── Group management events ────────────────────────────────────
+  handleGroupAddRobot(event) {
+    const groupId = event.group_openid;
+    if (!groupId) {
+      process.stderr.write(`[QQ:${this.name}] handleGroupAddRobot: missing group_openid
+`);
+      return;
+    }
+    if (!isValidChatId(groupId)) {
+      process.stderr.write(`[QQ:${this.name}] handleGroupAddRobot: invalid group_openid (length=${groupId.length})
+`);
+      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)}
+`);
+  }
+  handleGroupDelRobot(event) {
+    const groupId = event.group_openid;
+    if (!groupId) {
+      process.stderr.write(`[QQ:${this.name}] handleGroupDelRobot: missing group_openid
+`);
+      return;
+    }
+    if (!isValidChatId(groupId)) {
+      process.stderr.write(`[QQ:${this.name}] handleGroupDelRobot: invalid group_openid (length=${groupId.length})
+`);
+      return;
+    }
+    this.chatTypeMap.delete(groupId);
+    this.groupActiveMsgEnabled.delete(groupId);
+    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);
+    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++;
+      }
+    }
+    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)
+`);
+  }
+  handleGroupMsgToggle(event, enabled) {
+    if (!event.group_openid) {
+      process.stderr.write(`[QQ:${this.name}] Group msg toggle dropped: missing group_openid
+`);
+      return;
+    }
+    if (!isValidChatId(event.group_openid)) {
+      process.stderr.write(`[QQ:${this.name}] Group msg toggle dropped: invalid group_openid
+`);
+      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)}
+`);
+  }
 };
 
 // packages/channels/qqbot/dist/index.js