npm - @openclaw-china/qqbot - Versions diffs - 2026.3.12 → 2026.3.16 - Mend

@openclaw-china/qqbot 2026.3.12 → 2026.3.16

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/index.d.ts +84 -0
package/dist/index.js +1325 -160
package/dist/index.js.map +1 -1
package/openclaw.plugin.json +67 -0
package/package.json +4 -3
package/skills/qqbot-contact-send/SKILL.md +112 -0
package/skills/qqbot-contact-send/scripts/prepare_send.py +141 -0
package/skills/qqbot-contact-send/scripts/resolve_known_target.py +74 -0

package/dist/index.js CHANGED Viewed

@@ -4223,12 +4223,17 @@ var optionalCoercedString = external_exports.preprocess(
   (value) => toTrimmedString(value),
   external_exports.string().min(1).optional()
 );
+var displayAliasesSchema = external_exports.record(
+  external_exports.preprocess((value) => toTrimmedString(value), external_exports.string().min(1))
+).optional();
 var QQBotC2CMarkdownDeliveryModeSchema = external_exports.enum(["passive", "proactive-table-only", "proactive-all"]).optional().default("proactive-table-only");
+var QQBotC2CMarkdownChunkStrategySchema = external_exports.enum(["markdown-block", "length"]).optional().default("markdown-block");
 var QQBotAccountSchema = external_exports.object({
   name: external_exports.string().optional(),
   enabled: external_exports.boolean().optional(),
   appId: optionalCoercedString,
   clientSecret: optionalCoercedString,
+  displayAliases: displayAliasesSchema,
   asr: external_exports.object({
     enabled: external_exports.boolean().optional().default(false),
     appId: optionalCoercedString,
@@ -4237,6 +4242,7 @@ var QQBotAccountSchema = external_exports.object({
   }).optional(),
   markdownSupport: external_exports.boolean().optional().default(true),
   c2cMarkdownDeliveryMode: QQBotC2CMarkdownDeliveryModeSchema,
+  c2cMarkdownChunkStrategy: QQBotC2CMarkdownChunkStrategySchema,
   dmPolicy: external_exports.enum(["open", "pairing", "allowlist"]).optional().default("open"),
   groupPolicy: external_exports.enum(["open", "allowlist", "disabled"]).optional().default("open"),
   requireMention: external_exports.boolean().optional().default(true),
@@ -4261,6 +4267,21 @@ QQBotAccountSchema.extend({
 var DEFAULT_INBOUND_MEDIA_DIR = join(homedir(), ".openclaw", "media", "qqbot", "inbound");
 var DEFAULT_INBOUND_MEDIA_KEEP_DAYS = 7;
 var DEFAULT_INBOUND_MEDIA_TEMP_DIR = join(tmpdir(), "qqbot-media");
+function normalizeDisplayAliasesMap(raw) {
+  if (!raw || typeof raw !== "object") {
+    return {};
+  }
+  const aliases = {};
+  for (const [rawKey, rawValue] of Object.entries(raw)) {
+    const key = rawKey.trim();
+    const value = toTrimmedString(rawValue);
+    if (!key || !value) {
+      continue;
+    }
+    aliases[key] = value;
+  }
+  return aliases;
+}
 function resolveInboundMediaDir(config) {
   return String(config?.inboundMedia?.dir ?? "").trim() || DEFAULT_INBOUND_MEDIA_DIR;
 }
@@ -4301,7 +4322,15 @@ function mergeQQBotAccountConfig(cfg, accountId) {
   const base = cfg.channels?.qqbot ?? {};
   const { accounts: _ignored, defaultAccount: _ignored2, ...baseConfig } = base;
   const account = resolveAccountConfig(cfg, accountId) ?? {};
-  return { ...baseConfig, ...account };
+  const mergedDisplayAliases = {
+    ...normalizeDisplayAliasesMap(baseConfig.displayAliases),
+    ...normalizeDisplayAliasesMap(account.displayAliases)
+  };
+  return {
+    ...baseConfig,
+    ...account,
+    ...Object.keys(mergedDisplayAliases).length > 0 ? { displayAliases: mergedDisplayAliases } : {}
+  };
 }
 function resolveQQBotCredentials(config) {
   const appId = toTrimmedString(config?.appId);
@@ -6518,6 +6547,7 @@ var CHANNEL_ORDER = [
   "qqbot",
   "wecom",
   "wecom-app",
+  "wecom-kf",
   "feishu-china"
 ];
 var CHANNEL_DISPLAY_LABELS = {
@@ -6525,6 +6555,7 @@ var CHANNEL_DISPLAY_LABELS = {
   "feishu-china": "Feishu\uFF08\u98DE\u4E66\uFF09",
   wecom: "WeCom\uFF08\u4F01\u4E1A\u5FAE\u4FE1-\u667A\u80FD\u673A\u5668\u4EBA\uFF09",
   "wecom-app": "WeCom App\uFF08\u81EA\u5EFA\u5E94\u7528-\u53EF\u63A5\u5165\u5FAE\u4FE1\uFF09",
+  "wecom-kf": "WeCom KF\uFF08\u5FAE\u4FE1\u5BA2\u670D\uFF09",
   qqbot: "QQBot\uFF08QQ \u673A\u5668\u4EBA\uFF09"
 };
 var CHANNEL_GUIDE_LINKS = {
@@ -6532,6 +6563,7 @@ var CHANNEL_GUIDE_LINKS = {
   "feishu-china": "https://github.com/BytePioneer-AI/openclaw-china/blob/main/README.md",
   wecom: `${GUIDES_BASE}/wecom/configuration.md`,
   "wecom-app": `${GUIDES_BASE}/wecom-app/configuration.md`,
+  "wecom-kf": "https://github.com/BytePioneer-AI/openclaw-china/blob/main/extensions/wecom-kf/README.md",
   qqbot: `${GUIDES_BASE}/qqbot/configuration.md`
 };
 var CHINA_CLI_STATE_KEY = /* @__PURE__ */ Symbol.for("@openclaw-china/china-cli-state");
@@ -6740,6 +6772,8 @@ function isChannelConfigured(cfg, channelId) {
       return hasWecomWsCredentialPair(channelCfg);
     case "wecom-app":
       return hasTokenPair(channelCfg);
+    case "wecom-kf":
+      return hasNonEmptyString(channelCfg.corpId) && hasNonEmptyString(channelCfg.corpSecret) && hasNonEmptyString(channelCfg.token) && hasNonEmptyString(channelCfg.encodingAESKey);
     default:
       return false;
   }
@@ -6996,6 +7030,55 @@ async function configureWecomApp(prompter, cfg) {
   patch.asr = asr;
   return mergeChannelConfig(cfg, "wecom-app", patch);
 }
+async function configureWecomKf(prompter, cfg) {
+  section("\u914D\u7F6E WeCom KF\uFF08\u5FAE\u4FE1\u5BA2\u670D\uFF09");
+  showGuideLink("wecom-kf");
+  const existing = getChannelConfig(cfg, "wecom-kf");
+  const webhookPath = await prompter.askText({
+    label: "Webhook \u8DEF\u5F84\uFF08\u9ED8\u8BA4 /wecom-kf\uFF09",
+    defaultValue: toTrimmedString2(existing.webhookPath) ?? "/wecom-kf",
+    required: true
+  });
+  const token = await prompter.askSecret({
+    label: "\u5FAE\u4FE1\u5BA2\u670D\u56DE\u8C03 Token",
+    existingValue: toTrimmedString2(existing.token),
+    required: true
+  });
+  const encodingAESKey = await prompter.askSecret({
+    label: "\u5FAE\u4FE1\u5BA2\u670D\u56DE\u8C03 EncodingAESKey",
+    existingValue: toTrimmedString2(existing.encodingAESKey),
+    required: true
+  });
+  const corpId = await prompter.askText({
+    label: "corpId",
+    defaultValue: toTrimmedString2(existing.corpId),
+    required: true
+  });
+  const corpSecret = await prompter.askSecret({
+    label: "\u5FAE\u4FE1\u5BA2\u670D Secret",
+    existingValue: toTrimmedString2(existing.corpSecret),
+    required: true
+  });
+  const openKfId = await prompter.askText({
+    label: "open_kfid",
+    defaultValue: toTrimmedString2(existing.openKfId),
+    required: true
+  });
+  const welcomeText = await prompter.askText({
+    label: "\u6B22\u8FCE\u8BED\uFF08\u53EF\u9009\uFF09",
+    defaultValue: toTrimmedString2(existing.welcomeText),
+    required: false
+  });
+  return mergeChannelConfig(cfg, "wecom-kf", {
+    webhookPath,
+    token,
+    encodingAESKey,
+    corpId,
+    corpSecret,
+    openKfId,
+    welcomeText: welcomeText || void 0
+  });
+}
 async function configureQQBot(prompter, cfg) {
   section("\u914D\u7F6E QQBot\uFF08QQ \u673A\u5668\u4EBA\uFF09");
   showGuideLink("qqbot");
@@ -7052,6 +7135,8 @@ async function configureSingleChannel(channel, prompter, cfg) {
       return configureWecom(prompter, cfg);
     case "wecom-app":
       return configureWecomApp(prompter, cfg);
+    case "wecom-kf":
+      return configureWecomKf(prompter, cfg);
     case "qqbot":
       return configureQQBot(prompter, cfg);
     default:
@@ -7192,6 +7277,7 @@ var SUPPORTED_CHANNELS = [
   "feishu-china",
   "wecom",
   "wecom-app",
+  "wecom-kf",
   "qqbot"
 ];
 var CHINA_INSTALL_HINT_SHOWN_KEY = /* @__PURE__ */ Symbol.for("@openclaw-china/china-install-hint-shown");
@@ -8015,21 +8101,22 @@ async function readMediaWithConfig(source, options) {
 // src/outbound.ts
 function stripPrefix(value, prefix) {
-  return value.startsWith(prefix) ? value.slice(prefix.length) : value;
+  return value.slice(0, prefix.length).toLowerCase() === prefix ? value.slice(prefix.length) : value;
 }
 function parseTarget(to) {
   let raw = to.trim();
   raw = stripPrefix(raw, "qqbot:");
-  if (raw.startsWith("group:")) {
+  const normalizedRaw = raw.toLowerCase();
+  if (normalizedRaw.startsWith("group:")) {
     return { kind: "group", id: raw.slice("group:".length) };
   }
-  if (raw.startsWith("channel:")) {
+  if (normalizedRaw.startsWith("channel:")) {
     return { kind: "channel", id: raw.slice("channel:".length) };
   }
-  if (raw.startsWith("user:")) {
+  if (normalizedRaw.startsWith("user:")) {
     return { kind: "c2c", id: raw.slice("user:".length) };
   }
-  if (raw.startsWith("c2c:")) {
+  if (normalizedRaw.startsWith("c2c:")) {
     return { kind: "c2c", id: raw.slice("c2c:".length) };
   }
   return { kind: "c2c", id: raw };
@@ -9077,6 +9164,51 @@ function getQQBotRuntime() {
   return runtime;
 }
 var sessionDispatchQueue = /* @__PURE__ */ new Map();
+var QQBOT_ABORT_TRIGGERS = /* @__PURE__ */ new Set([
+  "stop",
+  "esc",
+  "abort",
+  "wait",
+  "exit",
+  "interrupt",
+  "detente",
+  "deten",
+  "det\xE9n",
+  "arrete",
+  "arr\xEAte",
+  "\u505C\u6B62",
+  "\u3084\u3081\u3066",
+  "\u6B62\u3081\u3066",
+  "\u0930\u0941\u0915\u094B",
+  "\u062A\u0648\u0642\u0641",
+  "\u0441\u0442\u043E\u043F",
+  "\u043E\u0441\u0442\u0430\u043D\u043E\u0432\u0438\u0441\u044C",
+  "\u043E\u0441\u0442\u0430\u043D\u043E\u0432\u0438",
+  "\u043E\u0441\u0442\u0430\u043D\u043E\u0432\u0438\u0442\u044C",
+  "\u043F\u0440\u0435\u043A\u0440\u0430\u0442\u0438",
+  "halt",
+  "anhalten",
+  "aufh\xF6ren",
+  "hoer auf",
+  "stopp",
+  "pare",
+  "stop openclaw",
+  "openclaw stop",
+  "stop action",
+  "stop current action",
+  "stop run",
+  "stop current run",
+  "stop agent",
+  "stop the agent",
+  "stop don't do anything",
+  "stop dont do anything",
+  "stop do not do anything",
+  "stop doing anything",
+  "do not do that",
+  "please stop",
+  "stop please"
+]);
+var QQBOT_ABORT_TRAILING_PUNCTUATION_RE = /[.!?…,，。;；:：'"’”)\]}]+$/u;
 function resolveQQBotRouteSessionKey(route) {
   const effectiveSessionKey = route.effectiveSessionKey?.trim();
   if (effectiveSessionKey) {
@@ -9088,6 +9220,100 @@ function buildSessionDispatchQueueKey(route) {
   const accountId = route.accountId?.trim() || DEFAULT_ACCOUNT_ID;
   return `${accountId}:${resolveQQBotRouteSessionKey(route)}`;
 }
+function createSessionDispatchState() {
+  return {
+    queue: [],
+    processing: false,
+    immediateActiveCount: 0,
+    waiters: [],
+    abortGeneration: 0
+  };
+}
+function getSessionDispatchState(queueKey) {
+  const existing = sessionDispatchQueue.get(queueKey);
+  if (existing) {
+    return existing;
+  }
+  const created = createSessionDispatchState();
+  sessionDispatchQueue.set(queueKey, created);
+  return created;
+}
+function signalSessionDispatchState(state) {
+  const waiters = state.waiters.splice(0, state.waiters.length);
+  for (const resolve3 of waiters) {
+    resolve3();
+  }
+}
+function waitForSessionDispatchState(state) {
+  return new Promise((resolve3) => {
+    state.waiters.push(resolve3);
+  });
+}
+function cleanupSessionDispatchState(queueKey, state) {
+  if (state.processing || state.immediateActiveCount > 0 || state.queue.length > 0 || state.waiters.length > 0) {
+    return;
+  }
+  if (sessionDispatchQueue.get(queueKey) === state) {
+    sessionDispatchQueue.delete(queueKey);
+  }
+}
+function hasSessionDispatchBacklog(queueKey) {
+  const state = sessionDispatchQueue.get(queueKey);
+  return Boolean(
+    state && (state.processing || state.immediateActiveCount > 0 || state.queue.length > 0)
+  );
+}
+async function processSerializedSessionDispatchQueue(queueKey) {
+  const state = sessionDispatchQueue.get(queueKey);
+  if (!state || state.processing) {
+    return;
+  }
+  state.processing = true;
+  try {
+    for (; ; ) {
+      if (state.immediateActiveCount > 0) {
+        await waitForSessionDispatchState(state);
+        continue;
+      }
+      const next = state.queue.shift();
+      if (!next) {
+        break;
+      }
+      try {
+        await next.task();
+        next.resolve();
+      } catch (err) {
+        next.reject(err);
+      }
+    }
+  } finally {
+    state.processing = false;
+    if (state.queue.length > 0) {
+      void processSerializedSessionDispatchQueue(queueKey);
+      return;
+    }
+    cleanupSessionDispatchState(queueKey, state);
+  }
+}
+function dropQueuedSessionDispatches(queueKey) {
+  const state = sessionDispatchQueue.get(queueKey);
+  if (!state || state.queue.length === 0) {
+    return 0;
+  }
+  const dropped = state.queue.splice(0, state.queue.length);
+  for (const item of dropped) {
+    item.resolve();
+  }
+  signalSessionDispatchState(state);
+  cleanupSessionDispatchState(queueKey, state);
+  return dropped.length;
+}
+function markSessionDispatchAbort(queueKey) {
+  const state = getSessionDispatchState(queueKey);
+  state.abortGeneration += 1;
+  signalSessionDispatchState(state);
+  return state.abortGeneration;
+}
 function normalizeQQBotSessionKeyPart(value) {
   const trimmed = value.trim();
   return trimmed ? trimmed.toLowerCase() : "unknown";
@@ -9123,22 +9349,163 @@ function normalizeQQBotReplyTarget(value) {
   return /^(user|group|channel):/i.test(trimmed) ? trimmed : void 0;
 }
 async function runSerializedSessionDispatch(queueKey, task) {
-  const previous = sessionDispatchQueue.get(queueKey) ?? Promise.resolve();
-  const run = previous.catch(() => void 0).then(task);
-  const cleanup = run.then(() => void 0, () => void 0);
-  sessionDispatchQueue.set(queueKey, cleanup);
+  const state = getSessionDispatchState(queueKey);
+  return new Promise((resolve3, reject) => {
+    let settled = false;
+    state.queue.push({
+      task: async () => {
+        if (settled) {
+          return;
+        }
+        try {
+          const result = await task();
+          if (!settled) {
+            settled = true;
+            resolve3(result);
+          }
+        } catch (err) {
+          if (!settled) {
+            settled = true;
+            reject(err);
+          }
+        }
+      },
+      resolve: () => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        resolve3(void 0);
+      },
+      reject: (err) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        reject(err);
+      }
+    });
+    signalSessionDispatchState(state);
+    void processSerializedSessionDispatchQueue(queueKey);
+  });
+}
+async function runImmediateSessionDispatch(queueKey, task) {
+  const state = getSessionDispatchState(queueKey);
+  state.immediateActiveCount += 1;
+  signalSessionDispatchState(state);
   try {
-    return await run;
+    return await task();
   } finally {
-    if (sessionDispatchQueue.get(queueKey) === cleanup) {
-      sessionDispatchQueue.delete(queueKey);
+    state.immediateActiveCount = Math.max(0, state.immediateActiveCount - 1);
+    signalSessionDispatchState(state);
+    if (state.queue.length > 0) {
+      void processSerializedSessionDispatchQueue(queueKey);
     }
+    cleanupSessionDispatchState(queueKey, state);
   }
 }
+function normalizeQQBotAbortTriggerText(text) {
+  return text.trim().toLowerCase().replace(/[’`]/g, "'").replace(/\s+/g, " ").replace(QQBOT_ABORT_TRAILING_PUNCTUATION_RE, "").trim();
+}
+function isQQBotAbortTrigger(text) {
+  if (!text) {
+    return false;
+  }
+  return QQBOT_ABORT_TRIGGERS.has(normalizeQQBotAbortTriggerText(text));
+}
+function isQQBotFastAbortCommandText(text) {
+  if (!text) {
+    return false;
+  }
+  const normalized = text.trim();
+  if (!normalized) {
+    return false;
+  }
+  const lower = normalized.toLowerCase();
+  return lower === "/stop" || normalizeQQBotAbortTriggerText(lower) === "/stop" || isQQBotAbortTrigger(lower);
+}
 function toString(value) {
   if (typeof value === "string" && value.trim()) return value;
   return void 0;
 }
+function asRecord(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  return value;
+}
+function normalizeQQBotDisplayAliasesMap(raw) {
+  if (!raw || typeof raw !== "object") {
+    return {};
+  }
+  const aliases = {};
+  for (const [rawKey, rawValue] of Object.entries(raw)) {
+    const key = rawKey.trim();
+    const value = toString(rawValue);
+    if (!key || !value) {
+      continue;
+    }
+    aliases[key] = value;
+  }
+  return aliases;
+}
+function resolveQQBotDisplayAliasMaps(cfg, accountId) {
+  const qqbot = cfg?.channels?.qqbot;
+  return {
+    globalAliases: normalizeQQBotDisplayAliasesMap(qqbot?.displayAliases),
+    accountAliases: normalizeQQBotDisplayAliasesMap(qqbot?.accounts?.[accountId]?.displayAliases)
+  };
+}
+function resolveQQBotSenderName(params) {
+  const { inbound, cfg, accountId } = params;
+  const stableId = inbound.c2cOpenid?.trim() || inbound.senderId.trim();
+  const { globalAliases, accountAliases } = resolveQQBotDisplayAliasMaps(cfg, accountId);
+  if (inbound.type === "direct") {
+    const knownTarget = stableId ? getKnownQQBotTarget({ accountId, target: `user:${stableId}` }) : void 0;
+    const knownTargetDisplayName = knownTarget?.displayName?.trim();
+    if (knownTargetDisplayName) {
+      return {
+        displayName: knownTargetDisplayName,
+        persistentDisplayName: knownTargetDisplayName,
+        source: "known-target",
+        knownTargetDisplayName
+      };
+    }
+    const aliasKeys = [...new Set([`user:${stableId}`, stableId, inbound.senderId.trim()].filter(Boolean))];
+    for (const aliasKey of aliasKeys) {
+      const alias = accountAliases[aliasKey];
+      if (alias) {
+        return {
+          displayName: alias,
+          persistentDisplayName: alias,
+          source: "account-alias",
+          matchedAliasKey: aliasKey
+        };
+      }
+    }
+    for (const aliasKey of aliasKeys) {
+      const alias = globalAliases[aliasKey];
+      if (alias) {
+        return {
+          displayName: alias,
+          persistentDisplayName: alias,
+          source: "global-alias",
+          matchedAliasKey: aliasKey
+        };
+      }
+    }
+  }
+  return {
+    displayName: stableId,
+    source: "stable-id"
+  };
+}
+function logQQBotSenderNameResolution(params) {
+  const { logger, inbound, accountId, resolution } = params;
+  logger.debug?.(
+    `[display-name] accountId=${accountId} type=${inbound.type} senderId=${inbound.senderId} knownTarget=${resolution.knownTargetDisplayName ?? "-"} alias=${resolution.matchedAliasKey ?? "-"} final=${JSON.stringify(resolution.displayName)} source=${resolution.source}`
+  );
+}
 function toNumber2(value) {
   if (typeof value === "number" && Number.isFinite(value)) return value;
   if (typeof value === "string") {
@@ -9522,14 +9889,13 @@ function parseC2CMessage(data, fallbackEventId) {
   const id = toString(payload.id);
   const eventId = resolveEventId(payload, fallbackEventId);
   const timestamp = toNumber2(payload.timestamp) ?? Date.now();
-  const author = payload.author ?? {};
+  const author = asRecord(payload.author) ?? {};
   const senderId = toString(author.user_openid);
   if (!text && attachments.length === 0 || !id || !senderId) return null;
   return {
     type: "direct",
     senderId,
     c2cOpenid: senderId,
-    senderName: toString(author.username),
     content: text,
     attachments: attachments.length > 0 ? attachments : void 0,
     messageId: id,
@@ -9546,13 +9912,12 @@ function parseGroupMessage(data, fallbackEventId) {
   const eventId = resolveEventId(payload, fallbackEventId);
   const timestamp = toNumber2(payload.timestamp) ?? Date.now();
   const groupOpenid = toString(payload.group_openid);
-  const author = payload.author ?? {};
+  const author = asRecord(payload.author) ?? {};
   const senderId = toString(author.member_openid);
   if (!text && attachments.length === 0 || !id || !senderId || !groupOpenid) return null;
   return {
     type: "group",
     senderId,
-    senderName: toString(author.nickname) ?? toString(author.username),
     content: text,
     attachments: attachments.length > 0 ? attachments : void 0,
     messageId: id,
@@ -9570,13 +9935,12 @@ function parseChannelMessage(data, fallbackEventId) {
   const timestamp = toNumber2(payload.timestamp) ?? Date.now();
   const channelId = toString(payload.channel_id);
   const guildId = toString(payload.guild_id);
-  const author = payload.author ?? {};
+  const author = asRecord(payload.author) ?? {};
   const senderId = toString(author.id);
   if (!text && attachments.length === 0 || !id || !senderId || !channelId) return null;
   return {
     type: "channel",
     senderId,
-    senderName: toString(author.username),
     content: text,
     attachments: attachments.length > 0 ? attachments : void 0,
     messageId: id,
@@ -9594,13 +9958,12 @@ function parseDirectMessage(data, fallbackEventId) {
   const eventId = resolveEventId(payload, fallbackEventId);
   const timestamp = toNumber2(payload.timestamp) ?? Date.now();
   const guildId = toString(payload.guild_id);
-  const author = payload.author ?? {};
+  const author = asRecord(payload.author) ?? {};
   const senderId = toString(author.id);
   if (!text && attachments.length === 0 || !id || !senderId) return null;
   return {
     type: "direct",
     senderId,
-    senderName: toString(author.username),
     content: text,
     attachments: attachments.length > 0 ? attachments : void 0,
     messageId: id,
@@ -9675,7 +10038,7 @@ function resolveEnvelopeFrom(event) {
   return event.senderName?.trim() || event.senderId;
 }
 function resolveKnownQQBotTargetFromInbound(params) {
-  const { inbound, accountId } = params;
+  const { inbound, accountId, persistentDisplayName } = params;
   if (inbound.type === "direct") {
     if (!inbound.c2cOpenid?.trim()) {
       return void 0;
@@ -9684,7 +10047,7 @@ function resolveKnownQQBotTargetFromInbound(params) {
       accountId,
       kind: "user",
       target: `user:${inbound.c2cOpenid}`,
-      displayName: inbound.senderName,
+      ...persistentDisplayName ? { displayName: persistentDisplayName } : {},
       sourceChatType: "direct",
       firstSeenAt: inbound.timestamp,
       lastSeenAt: inbound.timestamp
@@ -9695,7 +10058,7 @@ function resolveKnownQQBotTargetFromInbound(params) {
       accountId,
       kind: "group",
       target: `group:${inbound.groupOpenid}`,
-      displayName: inbound.senderName,
+      ...persistentDisplayName ? { displayName: persistentDisplayName } : {},
       sourceChatType: "group",
       firstSeenAt: inbound.timestamp,
       lastSeenAt: inbound.timestamp
@@ -9706,7 +10069,7 @@ function resolveKnownQQBotTargetFromInbound(params) {
       accountId,
       kind: "channel",
       target: `channel:${inbound.channelId}`,
-      displayName: inbound.senderName,
+      ...persistentDisplayName ? { displayName: persistentDisplayName } : {},
       sourceChatType: "channel",
       firstSeenAt: inbound.timestamp,
       lastSeenAt: inbound.timestamp
@@ -9821,6 +10184,14 @@ var DIRECTIVE_TAG_RE = /\[\[\s*(?:reply_to_current|reply_to\s*:[^\]]+|audio_as_v
 var VOICE_EMOTION_TAG_RE = /\[(?:happy|excited|calm|sad|angry|frustrated|softly|whispers|loudly|cheerfully|deadpan|sarcastically|laughs|sighs|chuckles|gasps|pause|slowly|rushed|hesitates|playfully|warmly|gently)\]/gi;
 var TTS_LIKE_RAW_TEXT_RE = /\[\[\s*(?:tts(?::text)?|\/tts(?::text)?|audio_as_voice|reply_to_current|reply_to\s*:)/i;
 var MARKDOWN_TABLE_SEPARATOR_RE = /^\|?(?:\s*:?-{3,}:?\s*\|)+(?:\s*:?-{3,}:?)?\|?$/;
+var MARKDOWN_THEMATIC_BREAK_RE = /^\s{0,3}(?:(?:-\s*){3,}|(?:_\s*){3,}|(?:\*\s*){3,})$/;
+var MARKDOWN_ATX_HEADING_RE = /^\s{0,3}#{1,6}\s+\S/;
+var MARKDOWN_BLOCKQUOTE_RE = /^\s{0,3}>\s?/;
+var MARKDOWN_FENCE_RE = /^\s*(`{3,}|~{3,})(.*)$/;
+var MARKDOWN_LIST_ITEM_RE = /^\s*(?:[-+*]|\d+\.)\s+/;
+var MARKDOWN_LIST_CONTINUATION_RE = /^\s{2,}\S/;
+var MARKDOWN_INLINE_STRUCTURE_RE = /(?:\*\*[^*\n]+\*\*|__[^_\n]+__|`[^`\n]+`|~~[^~\n]+~~|\*[^*\n]+\*)/;
+var MARKDOWN_BOUNDARY_GUARD_RE = /[`*_~|]/;
 var EXPLICIT_MARKDOWN_FENCE_RE = /(^|\n)(`{3,}|~{3,})\s*(?:markdown|md)\s*\n([\s\S]*?)\n\2(?=\n|$)/gi;
 var GENERIC_MARKDOWN_FENCE_RE = /(^|\n)(`{3,}|~{3,})\s*\n([\s\S]*?)\n\2(?=\n|$)/g;
 function extractFinalBlocks(text) {
@@ -9889,8 +10260,9 @@ function evaluateReplyFinalOnlyDelivery(params) {
 }
 function isQQBotC2CTarget(to) {
   const trimmed = to.trim();
-  const raw = trimmed.startsWith("qqbot:") ? trimmed.slice("qqbot:".length) : trimmed;
-  return !raw.startsWith("group:") && !raw.startsWith("channel:");
+  const raw = trimmed.slice(0, "qqbot:".length).toLowerCase() === "qqbot:" ? trimmed.slice("qqbot:".length) : trimmed;
+  const normalizedRaw = raw.toLowerCase();
+  return !normalizedRaw.startsWith("group:") && !normalizedRaw.startsWith("channel:");
 }
 function splitQQBotMarkdownTransportMediaUrls(mediaUrls) {
   const markdownImageUrls = [];
@@ -9992,10 +10364,592 @@ function normalizeQQBotRenderedMarkdown(text) {
   );
   return changed ? next.trim() : text.trim();
 }
+function normalizeQQBotMarkdownSegment(text) {
+  return text.replace(/\r\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function isBlankQQBotMarkdownLine(line) {
+  return line.trim().length === 0;
+}
+function resolveQQBotFenceDelimiter(line) {
+  const match = line.match(MARKDOWN_FENCE_RE);
+  return match?.[1];
+}
+function isQQBotFenceClosingLine(line, delimiter) {
+  const escapedDelimiter = delimiter.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const closingRe = new RegExp(`^\\s*${escapedDelimiter}${delimiter[0]}*\\s*$`);
+  return closingRe.test(line);
+}
+function joinQQBotMarkdownPieces(parts) {
+  return parts.filter(Boolean).join("\n\n").trim();
+}
+function isQQBotMarkdownTableStart(lines, index) {
+  const header = lines[index]?.trim() ?? "";
+  const separator = lines[index + 1]?.trim() ?? "";
+  return Boolean(header.includes("|") && MARKDOWN_TABLE_SEPARATOR_RE.test(separator));
+}
+function collectQQBotFencedCodeBlock(lines, startIndex) {
+  const openingLine = lines[startIndex] ?? "";
+  const delimiter = resolveQQBotFenceDelimiter(openingLine) ?? "```";
+  let index = startIndex + 1;
+  while (index < lines.length) {
+    if (isQQBotFenceClosingLine(lines[index] ?? "", delimiter)) {
+      index += 1;
+      break;
+    }
+    index += 1;
+  }
+  return {
+    block: {
+      kind: "code",
+      text: lines.slice(startIndex, index).join("\n").trimEnd()
+    },
+    nextIndex: index
+  };
+}
+function collectQQBotMarkdownTableBlock(lines, startIndex) {
+  let index = startIndex + 2;
+  while (index < lines.length) {
+    const line = lines[index] ?? "";
+    if (isBlankQQBotMarkdownLine(line) || !line.includes("|")) {
+      break;
+    }
+    index += 1;
+  }
+  return {
+    block: {
+      kind: "table",
+      text: lines.slice(startIndex, index).join("\n").trimEnd()
+    },
+    nextIndex: index
+  };
+}
+function collectQQBotBlockquoteBlock(lines, startIndex) {
+  const collected = [];
+  let index = startIndex;
+  while (index < lines.length) {
+    const line = lines[index] ?? "";
+    if (MARKDOWN_BLOCKQUOTE_RE.test(line)) {
+      collected.push(line);
+      index += 1;
+      continue;
+    }
+    if (isBlankQQBotMarkdownLine(line) && index + 1 < lines.length && MARKDOWN_BLOCKQUOTE_RE.test(lines[index + 1] ?? "")) {
+      collected.push(line);
+      index += 1;
+      continue;
+    }
+    break;
+  }
+  return {
+    block: {
+      kind: "blockquote",
+      text: collected.join("\n").trimEnd()
+    },
+    nextIndex: index
+  };
+}
+function collectQQBotListBlock(lines, startIndex) {
+  const collected = [];
+  let index = startIndex;
+  while (index < lines.length) {
+    const line = lines[index] ?? "";
+    if (isBlankQQBotMarkdownLine(line)) {
+      break;
+    }
+    if (MARKDOWN_FENCE_RE.test(line) || MARKDOWN_BLOCKQUOTE_RE.test(line) || MARKDOWN_ATX_HEADING_RE.test(line) || MARKDOWN_THEMATIC_BREAK_RE.test(line) || isQQBotMarkdownTableStart(lines, index)) {
+      break;
+    }
+    if (collected.length > 0 && !MARKDOWN_LIST_ITEM_RE.test(line) && !MARKDOWN_LIST_CONTINUATION_RE.test(line)) {
+      collected.push(line);
+      index += 1;
+      continue;
+    }
+    collected.push(line);
+    index += 1;
+  }
+  return {
+    block: {
+      kind: "list",
+      text: collected.join("\n").trimEnd()
+    },
+    nextIndex: index
+  };
+}
+function collectQQBotParagraphBlock(lines, startIndex) {
+  const collected = [];
+  let index = startIndex;
+  while (index < lines.length) {
+    const line = lines[index] ?? "";
+    if (isBlankQQBotMarkdownLine(line)) {
+      break;
+    }
+    if (collected.length > 0 && (MARKDOWN_FENCE_RE.test(line) || MARKDOWN_BLOCKQUOTE_RE.test(line) || MARKDOWN_ATX_HEADING_RE.test(line) || MARKDOWN_THEMATIC_BREAK_RE.test(line) || MARKDOWN_LIST_ITEM_RE.test(line) || isQQBotMarkdownTableStart(lines, index))) {
+      break;
+    }
+    collected.push(line);
+    index += 1;
+  }
+  return {
+    block: {
+      kind: "paragraph",
+      text: collected.join("\n").trimEnd()
+    },
+    nextIndex: index
+  };
+}
+function parseQQBotMarkdownBlocks(text) {
+  const lines = text.replace(/\r\n/g, "\n").split("\n");
+  const blocks = [];
+  let index = 0;
+  while (index < lines.length) {
+    while (index < lines.length && isBlankQQBotMarkdownLine(lines[index] ?? "")) {
+      index += 1;
+    }
+    if (index >= lines.length) {
+      break;
+    }
+    const line = lines[index] ?? "";
+    if (MARKDOWN_FENCE_RE.test(line)) {
+      const result2 = collectQQBotFencedCodeBlock(lines, index);
+      blocks.push(result2.block);
+      index = result2.nextIndex;
+      continue;
+    }
+    if (isQQBotMarkdownTableStart(lines, index)) {
+      const result2 = collectQQBotMarkdownTableBlock(lines, index);
+      blocks.push(result2.block);
+      index = result2.nextIndex;
+      continue;
+    }
+    if (MARKDOWN_THEMATIC_BREAK_RE.test(line)) {
+      blocks.push({ kind: "thematic-break", text: line.trim() });
+      index += 1;
+      continue;
+    }
+    if (MARKDOWN_BLOCKQUOTE_RE.test(line)) {
+      const result2 = collectQQBotBlockquoteBlock(lines, index);
+      blocks.push(result2.block);
+      index = result2.nextIndex;
+      continue;
+    }
+    if (MARKDOWN_ATX_HEADING_RE.test(line)) {
+      blocks.push({ kind: "heading", text: line.trimEnd() });
+      index += 1;
+      continue;
+    }
+    if (MARKDOWN_LIST_ITEM_RE.test(line)) {
+      const result2 = collectQQBotListBlock(lines, index);
+      blocks.push(result2.block);
+      index = result2.nextIndex;
+      continue;
+    }
+    const result = collectQQBotParagraphBlock(lines, index);
+    blocks.push(result.block);
+    index = result.nextIndex;
+  }
+  return blocks;
+}
+function hasQQBotBoundaryGuard(text) {
+  return MARKDOWN_BOUNDARY_GUARD_RE.test(text);
+}
+function isQQBotSafeMarkdownBoundary(text, index) {
+  const left = text.slice(Math.max(0, index - 3), index).replace(/\s+/g, "");
+  const right = text.slice(index, Math.min(text.length, index + 3)).replace(/\s+/g, "");
+  const leftEdge = left.slice(-1);
+  const rightEdge = right.slice(0, 1);
+  return !hasQQBotBoundaryGuard(leftEdge) && !hasQQBotBoundaryGuard(rightEdge);
+}
+function findQQBotRegexBoundary(text, limit, pattern) {
+  const scopedText = text.slice(0, Math.min(limit + 1, text.length));
+  const regex = new RegExp(pattern.source, pattern.flags);
+  let match = regex.exec(scopedText);
+  let lastBoundary;
+  while (match) {
+    const boundary = match.index + match[0].length;
+    if (boundary > 0 && boundary <= limit && isQQBotSafeMarkdownBoundary(text, boundary)) {
+      lastBoundary = boundary;
+    }
+    match = regex.exec(scopedText);
+  }
+  return lastBoundary;
+}
+function findQQBotFallbackBoundary(text, limit) {
+  const minIndex = Math.max(1, limit - 120);
+  for (let index = limit; index >= minIndex; index -= 1) {
+    if (isQQBotSafeMarkdownBoundary(text, index)) {
+      return index;
+    }
+  }
+  return limit;
+}
+function findQQBotSafeSplitIndex(text, limit) {
+  const boundaryPatterns = [
+    /\n\n+/g,
+    /\n/g,
+    /[。！？.!?；;:：](?:\s+|$)/g,
+    /[,，](?:\s+|$)/g,
+    /\s+/g
+  ];
+  for (const pattern of boundaryPatterns) {
+    const boundary = findQQBotRegexBoundary(text, limit, pattern);
+    if (boundary && boundary > 0) {
+      return boundary;
+    }
+  }
+  return findQQBotFallbackBoundary(text, limit);
+}
+function splitQQBotHardText(text, limit) {
+  if (limit <= 0 || text.length <= limit) {
+    return [text];
+  }
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > limit) {
+    chunks.push(remaining.slice(0, limit));
+    remaining = remaining.slice(limit);
+  }
+  if (remaining) {
+    chunks.push(remaining);
+  }
+  return chunks;
+}
+function splitQQBotTextSafely(text, limit, options) {
+  if (limit <= 0 || text.length <= limit) {
+    return [text];
+  }
+  const trimLeading = options?.trimLeading ?? true;
+  const trimTrailing = options?.trimTrailing ?? true;
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > limit) {
+    const splitIndex = findQQBotSafeSplitIndex(remaining, limit);
+    let nextChunk = remaining.slice(0, splitIndex);
+    let nextRemaining = remaining.slice(splitIndex);
+    if (trimTrailing) {
+      nextChunk = nextChunk.trimEnd();
+    }
+    if (trimLeading) {
+      nextRemaining = nextRemaining.trimStart();
+    }
+    if (!nextChunk) {
+      const hardChunk = remaining.slice(0, limit);
+      chunks.push(hardChunk);
+      remaining = remaining.slice(hardChunk.length);
+      continue;
+    }
+    chunks.push(nextChunk);
+    remaining = nextRemaining;
+  }
+  const finalChunk = trimTrailing ? remaining.trimEnd() : remaining;
+  if (finalChunk) {
+    chunks.push(finalChunk);
+  }
+  return chunks;
+}
+function splitQQBotMarkdownLineBlock(text, limit) {
+  if (limit <= 0 || text.length <= limit) {
+    return [text];
+  }
+  const lines = text.split("\n");
+  const chunks = [];
+  let currentLines = [];
+  const flushCurrent = () => {
+    if (currentLines.length === 0) {
+      return;
+    }
+    const chunk = currentLines.join("\n").trimEnd();
+    if (chunk) {
+      chunks.push(chunk);
+    }
+    currentLines = [];
+  };
+  for (const line of lines) {
+    const candidate = currentLines.length > 0 ? `${currentLines.join("\n")}
+${line}` : line;
+    if (candidate.length <= limit) {
+      currentLines.push(line);
+      continue;
+    }
+    flushCurrent();
+    if (line.length <= limit) {
+      currentLines.push(line);
+      continue;
+    }
+    for (const piece of splitQQBotTextSafely(line, limit, {
+      trimLeading: false,
+      trimTrailing: false
+    })) {
+      if (piece) {
+        chunks.push(piece);
+      }
+    }
+  }
+  flushCurrent();
+  return chunks;
+}
+function splitQQBotMarkdownTableBlock(text, limit) {
+  if (limit <= 0 || text.length <= limit) {
+    return [text];
+  }
+  const lines = text.split("\n");
+  const header = lines[0] ?? "";
+  const separator = lines[1] ?? "";
+  const rows = lines.slice(2);
+  const tablePrefix = `${header}
+${separator}`;
+  const chunks = [];
+  let currentRows = [];
+  const flushCurrent = () => {
+    if (currentRows.length === 0) {
+      return;
+    }
+    chunks.push(`${tablePrefix}
+${currentRows.join("\n")}`);
+    currentRows = [];
+  };
+  for (const row of rows) {
+    const candidate = currentRows.length > 0 ? `${tablePrefix}
+${currentRows.join("\n")}
+${row}` : `${tablePrefix}
+${row}`;
+    if (candidate.length <= limit) {
+      currentRows.push(row);
+      continue;
+    }
+    flushCurrent();
+    if (`${tablePrefix}
+${row}`.length <= limit) {
+      currentRows.push(row);
+      continue;
+    }
+    const maxRowLength = Math.max(16, limit - tablePrefix.length - 1);
+    for (const rowPiece of splitQQBotTextSafely(row, maxRowLength, {
+      trimLeading: false,
+      trimTrailing: false
+    })) {
+      chunks.push(`${tablePrefix}
+${rowPiece}`);
+    }
+  }
+  flushCurrent();
+  return chunks.length > 0 ? chunks : [text];
+}
+function splitQQBotMarkdownCodeFence(text, limit) {
+  if (limit <= 0 || text.length <= limit) {
+    return [text];
+  }
+  const lines = text.split("\n");
+  const openingLine = lines[0] ?? "```";
+  const delimiter = resolveQQBotFenceDelimiter(openingLine) ?? "```";
+  const hasClosingFence = lines.length > 1 && isQQBotFenceClosingLine(lines[lines.length - 1] ?? "", delimiter);
+  const closingLine = hasClosingFence ? lines[lines.length - 1] ?? delimiter : delimiter;
+  const codeLines = lines.slice(1, hasClosingFence ? -1 : lines.length);
+  const fixedOverhead = openingLine.length + closingLine.length + 2;
+  const availableLineLength = Math.max(1, limit - fixedOverhead);
+  const chunks = [];
+  let currentCodeLines = [];
+  const flushCurrent = () => {
+    if (currentCodeLines.length === 0) {
+      return;
+    }
+    chunks.push(`${openingLine}
+${currentCodeLines.join("\n")}
+${closingLine}`);
+    currentCodeLines = [];
+  };
+  for (const codeLine of codeLines) {
+    const candidate = currentCodeLines.length > 0 ? `${openingLine}
+${currentCodeLines.join("\n")}
+${codeLine}
+${closingLine}` : `${openingLine}
+${codeLine}
+${closingLine}`;
+    if (candidate.length <= limit) {
+      currentCodeLines.push(codeLine);
+      continue;
+    }
+    flushCurrent();
+    if (`${openingLine}
+${codeLine}
+${closingLine}`.length <= limit) {
+      currentCodeLines.push(codeLine);
+      continue;
+    }
+    for (const linePiece of splitQQBotHardText(codeLine, availableLineLength)) {
+      chunks.push(`${openingLine}
+${linePiece}
+${closingLine}`);
+    }
+  }
+  flushCurrent();
+  return chunks.length > 0 ? chunks : [text];
+}
+function splitQQBotMarkdownBlock(block, limit) {
+  if (limit <= 0 || block.text.length <= limit) {
+    return [block.text];
+  }
+  switch (block.kind) {
+    case "table":
+      return splitQQBotMarkdownTableBlock(block.text, limit);
+    case "code":
+      return splitQQBotMarkdownCodeFence(block.text, limit);
+    case "blockquote":
+      return splitQQBotMarkdownLineBlock(block.text, limit);
+    case "list":
+      return splitQQBotMarkdownLineBlock(block.text, limit);
+    case "paragraph":
+    case "heading":
+      return splitQQBotTextSafely(block.text, limit);
+    case "thematic-break":
+      return [block.text];
+    default:
+      return [block.text];
+  }
+}
+function chunkQQBotStructuredMarkdown(text, limit) {
+  const blocks = parseQQBotMarkdownBlocks(text);
+  if (blocks.length === 0 || limit <= 0) {
+    return [text.trim()];
+  }
+  const chunks = [];
+  let currentPieces = [];
+  let pendingPrefixPieces = [];
+  const flushCurrent = () => {
+    if (currentPieces.length === 0) {
+      return;
+    }
+    const chunk = joinQQBotMarkdownPieces(currentPieces);
+    if (chunk) {
+      chunks.push(chunk);
+    }
+    currentPieces = [];
+  };
+  const appendPiece = (piece) => {
+    if (!piece) {
+      return;
+    }
+    const pieces = piece.length > limit ? splitQQBotTextSafely(piece, limit) : [piece];
+    for (const nextPiece of pieces) {
+      const normalizedPiece = nextPiece.trim();
+      if (!normalizedPiece) {
+        continue;
+      }
+      const candidate = joinQQBotMarkdownPieces([...currentPieces, normalizedPiece]);
+      if (currentPieces.length === 0 || candidate.length <= limit) {
+        currentPieces.push(normalizedPiece);
+        continue;
+      }
+      flushCurrent();
+      currentPieces.push(normalizedPiece);
+    }
+  };
+  const consumePendingPrefix = (piece) => {
+    if (pendingPrefixPieces.length === 0) {
+      return piece;
+    }
+    const prefixed = joinQQBotMarkdownPieces([...pendingPrefixPieces, piece]);
+    pendingPrefixPieces = [];
+    return prefixed;
+  };
+  for (let index = 0; index < blocks.length; index += 1) {
+    const block = blocks[index];
+    if (!block) {
+      continue;
+    }
+    if (block.kind === "thematic-break") {
+      if (currentPieces.length > 0) {
+        const candidate = joinQQBotMarkdownPieces([...currentPieces, block.text]);
+        if (candidate.length <= limit) {
+          currentPieces.push(block.text);
+          continue;
+        }
+        flushCurrent();
+      }
+      pendingPrefixPieces.push(block.text);
+      continue;
+    }
+    if (block.kind === "heading") {
+      const headingText = consumePendingPrefix(block.text);
+      const nextBlock = blocks[index + 1];
+      if (nextBlock && nextBlock.kind !== "thematic-break") {
+        const nextPieces = splitQQBotMarkdownBlock(nextBlock, limit);
+        const firstBodyPiece = nextPieces[0];
+        if (firstBodyPiece) {
+          const pairedText = joinQQBotMarkdownPieces([headingText, firstBodyPiece]);
+          const pairedCandidate = joinQQBotMarkdownPieces([
+            ...currentPieces,
+            headingText,
+            firstBodyPiece
+          ]);
+          if (pairedText.length <= limit && (currentPieces.length === 0 || pairedCandidate.length <= limit)) {
+            currentPieces.push(headingText, firstBodyPiece);
+            for (let pieceIndex = 1; pieceIndex < nextPieces.length; pieceIndex += 1) {
+              appendPiece(nextPieces[pieceIndex] ?? "");
+            }
+            index += 1;
+            continue;
+          }
+          if (currentPieces.length > 0 && pairedText.length <= limit) {
+            flushCurrent();
+            currentPieces.push(headingText, firstBodyPiece);
+            for (let pieceIndex = 1; pieceIndex < nextPieces.length; pieceIndex += 1) {
+              appendPiece(nextPieces[pieceIndex] ?? "");
+            }
+            index += 1;
+            continue;
+          }
+        }
+      }
+      appendPiece(headingText);
+      continue;
+    }
+    const blockText = consumePendingPrefix(block.text);
+    for (const piece of splitQQBotMarkdownBlock({ ...block, text: blockText }, limit)) {
+      appendPiece(piece);
+    }
+  }
+  if (pendingPrefixPieces.length > 0 && currentPieces.length > 0) {
+    const trailingCandidate = joinQQBotMarkdownPieces([...currentPieces, ...pendingPrefixPieces]);
+    if (trailingCandidate.length <= limit) {
+      currentPieces.push(...pendingPrefixPieces);
+    }
+  }
+  flushCurrent();
+  return chunks.length > 0 ? chunks : [text.trim()];
+}
+function looksLikeStructuredMarkdown(text) {
+  const normalized = normalizeQQBotMarkdownSegment(text);
+  if (!normalized) {
+    return false;
+  }
+  const lines = normalized.split("\n");
+  if (hasQQBotMarkdownTable(normalized)) {
+    return true;
+  }
+  return normalized.includes("\n\n") || lines.some((line) => MARKDOWN_ATX_HEADING_RE.test(line)) || lines.some((line) => MARKDOWN_BLOCKQUOTE_RE.test(line)) || lines.some((line) => MARKDOWN_FENCE_RE.test(line)) || lines.some((line) => MARKDOWN_THEMATIC_BREAK_RE.test(line)) || lines.some((line) => MARKDOWN_LIST_ITEM_RE.test(line)) || MARKDOWN_INLINE_STRUCTURE_RE.test(normalized);
+}
+function chunkC2CMarkdownText(params) {
+  const normalized = params.text.trim();
+  if (!normalized) {
+    return [];
+  }
+  const strategy = params.strategy ?? "markdown-block";
+  if (strategy === "length") {
+    return params.fallbackChunkText ? params.fallbackChunkText(normalized) : [normalized];
+  }
+  if (params.limit <= 0 || !looksLikeStructuredMarkdown(normalized)) {
+    return params.fallbackChunkText ? params.fallbackChunkText(normalized) : [normalized];
+  }
+  return chunkQQBotStructuredMarkdown(normalized, params.limit);
+}
 async function sendQQBotMediaWithFallback(params) {
   const { qqCfg, to, mediaQueue, replyToId, replyEventId, accountId, logger, onDelivered, onError } = params;
   const outbound = params.outbound ?? qqbotOutbound;
+  const shouldContinue = params.shouldContinue ?? (() => true);
   for (const mediaUrl of mediaQueue) {
+    if (!shouldContinue()) {
+      return;
+    }
     const result = await outbound.sendMedia({
       cfg: { channels: { qqbot: qqCfg } },
       to,
@@ -10011,6 +10965,9 @@ async function sendQQBotMediaWithFallback(params) {
       if (!fallback) {
         continue;
       }
+      if (!shouldContinue()) {
+        return;
+      }
       const fallbackResult = await outbound.sendText({
         cfg: { channels: { qqbot: qqCfg } },
         to,
@@ -10063,10 +11020,17 @@ async function dispatchToAgent(params) {
   const { inbound, cfg, qqCfg, accountId, logger, route } = params;
   const runtime2 = getQQBotRuntime();
   const routeSessionKey = resolveQQBotRouteSessionKey(route);
+  const queueKey = buildSessionDispatchQueueKey(route);
+  const isFastAbortCommand = isQQBotFastAbortCommandText(inbound.content);
+  const dispatchAbortGeneration = getSessionDispatchState(queueKey).abortGeneration;
+  const shouldSuppressVisibleReplies = () => {
+    const currentAbortGeneration = sessionDispatchQueue.get(queueKey)?.abortGeneration ?? dispatchAbortGeneration;
+    return currentAbortGeneration !== dispatchAbortGeneration;
+  };
   const target = resolveChatTarget(inbound);
   const outboundAccountId = route.accountId ?? accountId;
   let typingRefIdx;
-  if (inbound.c2cOpenid) {
+  if (inbound.c2cOpenid && !isFastAbortCommand && !shouldSuppressVisibleReplies()) {
     const typing = await qqbotOutbound.sendTyping({
       cfg: { channels: { qqbot: qqCfg } },
       to: `user:${inbound.c2cOpenid}`,
@@ -10103,7 +11067,7 @@ async function dispatchToAgent(params) {
     delayMs: qqCfg.longTaskNoticeDelayMs ?? DEFAULT_LONG_TASK_NOTICE_DELAY_MS,
     logger,
     sendNotice: async () => {
-      if (groupMessageInterfaceBlocked) return;
+      if (groupMessageInterfaceBlocked || isFastAbortCommand || shouldSuppressVisibleReplies()) return;
       const result = await qqbotOutbound.sendText({
         cfg: { channels: { qqbot: qqCfg } },
         to: target.to,
@@ -10137,6 +11101,9 @@ async function dispatchToAgent(params) {
       logger
     });
     if (qqCfg.asr?.enabled && resolvedAttachmentResult.hasVoiceAttachment && !resolvedAttachmentResult.hasVoiceTranscript) {
+      if (shouldSuppressVisibleReplies()) {
+        return;
+      }
       const fallback = await qqbotOutbound.sendText({
         cfg: { channels: { qqbot: qqCfg } },
         to: target.to,
@@ -10246,29 +11213,43 @@ async function dispatchToAgent(params) {
       }
       finalCtx.BodyForAgent = appendCronHiddenPrompt(agentBody);
     }
-    if (storePath && sessionApi?.recordInboundSession) {
-      try {
-        const mainSessionKeyRaw = route.mainSessionKey;
-        const mainSessionKey = typeof mainSessionKeyRaw === "string" && mainSessionKeyRaw.trim() ? mainSessionKeyRaw.trim() : void 0;
-        const isGroup = inbound.type === "group" || inbound.type === "channel";
-        const updateLastRoute = !isGroup ? {
-          sessionKey: mainSessionKey ?? route.sessionKey,
-          channel: "qqbot",
-          to: stableTo,
-          accountId: outboundAccountId
-        } : void 0;
-        const recordSessionKey = typeof finalCtx.SessionKey === "string" && finalCtx.SessionKey.trim() ? finalCtx.SessionKey : routeSessionKey;
-        await sessionApi.recordInboundSession({
-          storePath,
-          sessionKey: recordSessionKey,
-          ctx: finalCtx,
-          updateLastRoute,
-          onRecordError: (err) => {
-            logger.warn(`failed to record inbound session: ${String(err)}`);
-          }
-        });
-      } catch (err) {
-        logger.warn(`failed to record inbound session: ${String(err)}`);
+    if (storePath) {
+      const mainSessionKeyRaw = route.mainSessionKey;
+      const mainSessionKey = typeof mainSessionKeyRaw === "string" && mainSessionKeyRaw.trim() ? mainSessionKeyRaw.trim() : void 0;
+      const isGroup = inbound.type === "group" || inbound.type === "channel";
+      const updateLastRoute = !isGroup ? {
+        sessionKey: mainSessionKey ?? route.sessionKey,
+        channel: "qqbot",
+        to: stableTo,
+        accountId: outboundAccountId
+      } : void 0;
+      const recordSessionKey = typeof finalCtx.SessionKey === "string" && finalCtx.SessionKey.trim() ? finalCtx.SessionKey : routeSessionKey;
+      if (sessionApi?.recordInboundSession) {
+        try {
+          await sessionApi.recordInboundSession({
+            storePath,
+            sessionKey: recordSessionKey,
+            ctx: finalCtx,
+            updateLastRoute,
+            onRecordError: (err) => {
+              logger.warn(`failed to record inbound session: ${String(err)}`);
+            }
+          });
+        } catch (err) {
+          logger.warn(`failed to record inbound session: ${String(err)}`);
+        }
+      }
+      if (sessionApi?.recordSessionMetaFromInbound) {
+        try {
+          await sessionApi.recordSessionMetaFromInbound({
+            storePath,
+            sessionKey: recordSessionKey,
+            ctx: finalCtx,
+            createIfMissing: true
+          });
+        } catch (err) {
+          logger.warn(`failed to record inbound session meta: ${String(err)}`);
+        }
       }
     }
     const textApi = runtime2.channel?.text;
@@ -10296,10 +11277,13 @@ async function dispatchToAgent(params) {
     const replyFinalOnly = qqCfg.replyFinalOnly ?? false;
     const markdownSupport = qqCfg.markdownSupport ?? true;
     const c2cMarkdownDeliveryMode = qqCfg.c2cMarkdownDeliveryMode ?? "proactive-table-only";
-    const useC2CMarkdownTransport = markdownSupport && isQQBotC2CTarget(target.to);
+    const c2cMarkdownChunkStrategy = qqCfg.c2cMarkdownChunkStrategy ?? "markdown-block";
+    const isC2CTarget = isQQBotC2CTarget(target.to);
+    const useC2CMarkdownTransport = markdownSupport && isC2CTarget;
     let bufferedC2CMarkdownTexts = [];
     let bufferedC2CMarkdownMediaUrls = [];
     const bufferedC2CMarkdownMediaSeen = /* @__PURE__ */ new Set();
+    const hasBufferedC2CMarkdownReply = () => bufferedC2CMarkdownTexts.length > 0 || bufferedC2CMarkdownMediaUrls.length > 0;
     const bufferC2CMarkdownMedia = (url) => {
       const next = url?.trim();
       if (!next || bufferedC2CMarkdownMediaSeen.has(next)) return;
@@ -10307,12 +11291,18 @@ async function dispatchToAgent(params) {
       bufferedC2CMarkdownMediaUrls.push(next);
     };
     const sendC2CMarkdownTransportPayload = async (params2) => {
+      if (shouldSuppressVisibleReplies()) {
+        return;
+      }
       const normalizedText = normalizeQQBotRenderedMarkdown(params2.text);
       const { markdownImageUrls, mediaQueue } = splitQQBotMarkdownTransportMediaUrls(params2.mediaUrls);
       const finalMarkdownText = await normalizeQQBotMarkdownImages({
         text: normalizedText,
         appendImageUrls: markdownImageUrls
       });
+      if (shouldSuppressVisibleReplies()) {
+        return;
+      }
       const textReplyRefs = resolveQQBotTextReplyRefs({
         to: target.to,
         text: finalMarkdownText || normalizedText,
@@ -10321,52 +11311,59 @@ async function dispatchToAgent(params) {
         replyToId: inbound.messageId,
         replyEventId: inbound.eventId
       });
-      const textSegments = finalMarkdownText ? [finalMarkdownText] : [];
+      const textChunks = finalMarkdownText ? chunkC2CMarkdownText({
+        text: finalMarkdownText,
+        limit,
+        strategy: c2cMarkdownChunkStrategy,
+        fallbackChunkText: chunkText
+      }) : [];
       const deliveryLabel = textReplyRefs.forceProactive ? "c2c-markdown-proactive" : "c2c-markdown-passive";
       logger.info(
-        `delivery=${deliveryLabel} to=${target.to} segments=${textSegments.length} media=${mediaQueue.length} replyToId=${textReplyRefs.replyToId ? "yes" : "no"} replyEventId=${textReplyRefs.replyEventId ? "yes" : "no"} phase=${params2.phase} tableMode=${String(resolvedTableMode)} chunkMode=${String(chunkMode ?? "default")}`
+        `delivery=${deliveryLabel} to=${target.to} chunks=${textChunks.length} media=${mediaQueue.length} replyToId=${textReplyRefs.replyToId ? "yes" : "no"} replyEventId=${textReplyRefs.replyEventId ? "yes" : "no"} phase=${params2.phase} tableMode=${String(resolvedTableMode)} chunkMode=${String(chunkMode ?? "default")} chunkStrategy=${c2cMarkdownChunkStrategy}`
       );
-      await sendQQBotMediaWithFallback({
-        qqCfg,
-        to: target.to,
-        mediaQueue,
-        replyToId: textReplyRefs.replyToId,
-        replyEventId: textReplyRefs.replyEventId,
-        accountId: outboundAccountId,
-        logger,
-        onDelivered: () => {
-          markReplyDelivered();
-        },
-        onError: (error) => {
-          markGroupMessageInterfaceBlocked(error);
-        }
-      });
+      if (!shouldSuppressVisibleReplies()) {
+        await sendQQBotMediaWithFallback({
+          qqCfg,
+          to: target.to,
+          mediaQueue,
+          replyToId: textReplyRefs.replyToId,
+          replyEventId: textReplyRefs.replyEventId,
+          accountId: outboundAccountId,
+          logger,
+          onDelivered: () => {
+            markReplyDelivered();
+          },
+          onError: (error) => {
+            markGroupMessageInterfaceBlocked(error);
+          },
+          shouldContinue: () => !shouldSuppressVisibleReplies()
+        });
+      }
       if (!finalMarkdownText) {
         return;
       }
-      for (let segmentIndex = 0; segmentIndex < textSegments.length; segmentIndex += 1) {
-        const segment = textSegments[segmentIndex] ?? "";
-        const chunks = chunkText(segment);
-        for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex += 1) {
-          const chunk = chunks[chunkIndex] ?? "";
-          logger.info(
-            `delivery=${deliveryLabel} segment=${segmentIndex + 1}/${textSegments.length} chunk=${chunkIndex + 1}/${chunks.length} phase=${params2.phase} preview=${formatQQBotOutboundPreview(chunk)}`
-          );
-          const result = await qqbotOutbound.sendText({
-            cfg: { channels: { qqbot: qqCfg } },
-            to: target.to,
-            text: chunk,
-            replyToId: textReplyRefs.replyToId,
-            replyEventId: textReplyRefs.replyEventId,
-            accountId: outboundAccountId
-          });
-          if (result.error) {
-            logger.error(`send QQ markdown reply failed: ${result.error}`);
-            markGroupMessageInterfaceBlocked(result.error);
-          } else {
-            logger.info(`sent QQ markdown reply (phase=${params2.phase}, len=${chunk.length})`);
-            markReplyDelivered();
-          }
+      for (let chunkIndex = 0; chunkIndex < textChunks.length; chunkIndex += 1) {
+        if (shouldSuppressVisibleReplies()) {
+          return;
+        }
+        const chunk = textChunks[chunkIndex] ?? "";
+        logger.info(
+          `delivery=${deliveryLabel} segment=1/1 chunk=${chunkIndex + 1}/${textChunks.length} phase=${params2.phase} preview=${formatQQBotOutboundPreview(chunk)}`
+        );
+        const result = await qqbotOutbound.sendText({
+          cfg: { channels: { qqbot: qqCfg } },
+          to: target.to,
+          text: chunk,
+          replyToId: textReplyRefs.replyToId,
+          replyEventId: textReplyRefs.replyEventId,
+          accountId: outboundAccountId
+        });
+        if (result.error) {
+          logger.error(`send QQ markdown reply failed: ${result.error}`);
+          markGroupMessageInterfaceBlocked(result.error);
+        } else {
+          logger.info(`sent QQ markdown reply (phase=${params2.phase}, len=${chunk.length})`);
+          markReplyDelivered();
         }
       }
     };
@@ -10377,6 +11374,12 @@ async function dispatchToAgent(params) {
         bufferedC2CMarkdownMediaSeen.clear();
         return;
       }
+      if (shouldSuppressVisibleReplies()) {
+        bufferedC2CMarkdownTexts = [];
+        bufferedC2CMarkdownMediaUrls = [];
+        bufferedC2CMarkdownMediaSeen.clear();
+        return;
+      }
       const combinedText = bufferedC2CMarkdownTexts.join("\n\n").trim();
       const combinedMediaUrls = [...bufferedC2CMarkdownMediaUrls];
       bufferedC2CMarkdownTexts = [];
@@ -10389,6 +11392,9 @@ async function dispatchToAgent(params) {
       });
     };
     const deliver = async (payload, info) => {
+      if (shouldSuppressVisibleReplies()) {
+        return;
+      }
       const typed = payload;
       const extractedTextMedia = extractQQBotReplyMedia({
         text: typed?.text ?? "",
@@ -10420,7 +11426,8 @@ async function dispatchToAgent(params) {
       const textToSend = suppressText ? "" : cleanedText;
       if (useC2CMarkdownTransport) {
         const shouldBufferFinalOnlyPayload = replyFinalOnly && (!info?.kind || info.kind === "final");
-        if (shouldBufferFinalOnlyPayload) {
+        const shouldBufferStructuredMarkdownPayload = !replyFinalOnly && c2cMarkdownChunkStrategy === "markdown-block" && info?.kind !== "tool" && looksLikeStructuredMarkdown(textToSend);
+        if (shouldBufferFinalOnlyPayload || shouldBufferStructuredMarkdownPayload) {
           if (textToSend) {
             bufferedC2CMarkdownTexts = appendQQBotBufferedText(bufferedC2CMarkdownTexts, textToSend);
           }
@@ -10429,6 +11436,12 @@ async function dispatchToAgent(params) {
           }
           return;
         }
+        if (hasBufferedC2CMarkdownReply()) {
+          await flushBufferedC2CMarkdownReply();
+          if (shouldSuppressVisibleReplies()) {
+            return;
+          }
+        }
         await sendC2CMarkdownTransportPayload({
           text: textToSend,
           mediaUrls: mediaQueue,
@@ -10448,6 +11461,9 @@ async function dispatchToAgent(params) {
         });
         const chunks = chunkText(converted);
         for (const chunk of chunks) {
+          if (shouldSuppressVisibleReplies()) {
+            return;
+          }
           const result = await qqbotOutbound.sendText({
             cfg: { channels: { qqbot: qqCfg } },
             to: target.to,
@@ -10464,6 +11480,9 @@ async function dispatchToAgent(params) {
           }
         }
       }
+      if (shouldSuppressVisibleReplies()) {
+        return;
+      }
       await sendQQBotMediaWithFallback({
         qqCfg,
         to: target.to,
@@ -10477,12 +11496,38 @@ async function dispatchToAgent(params) {
         },
         onError: (error) => {
           markGroupMessageInterfaceBlocked(error);
-        }
+        },
+        shouldContinue: () => !shouldSuppressVisibleReplies()
       });
     };
     const humanDelay = replyApi.resolveHumanDelayConfig?.(cfg, route.agentId);
+    const dispatchDirect = replyApi.dispatchReplyWithDispatcher;
     const dispatchBuffered = replyApi.dispatchReplyWithBufferedBlockDispatcher;
-    if (dispatchBuffered) {
+    const streamingReplyOptions = isC2CTarget && !replyFinalOnly ? {
+      disableBlockStreaming: false
+    } : void 0;
+    if (isC2CTarget && !replyFinalOnly && dispatchDirect) {
+      logger.debug(`[dispatch] mode=direct session=${routeSessionKey} to=${target.to}`);
+      await dispatchDirect({
+        ctx: finalCtx,
+        cfg,
+        dispatcherOptions: {
+          deliver,
+          humanDelay,
+          onError: (err, info) => {
+            logger.error(`${info.kind} reply failed: ${String(err)}`);
+          },
+          onSkip: (_payload, info) => {
+            if (info.reason !== "silent") {
+              logger.info(`reply skipped: ${info.reason}`);
+            }
+          }
+        },
+        replyOptions: streamingReplyOptions
+      });
+      await flushBufferedC2CMarkdownReply();
+    } else if (dispatchBuffered) {
+      logger.debug(`[dispatch] mode=buffered session=${routeSessionKey} to=${target.to}`);
       await dispatchBuffered({
         ctx: finalCtx,
         cfg,
@@ -10497,10 +11542,12 @@ async function dispatchToAgent(params) {
               logger.info(`reply skipped: ${info.reason}`);
             }
           }
-        }
+        },
+        replyOptions: streamingReplyOptions
       });
       await flushBufferedC2CMarkdownReply();
     } else {
+      logger.debug(`[dispatch] mode=legacy session=${routeSessionKey} to=${target.to}`);
       const dispatcherResult = replyApi.createReplyDispatcherWithTyping ? replyApi.createReplyDispatcherWithTyping({
         deliver,
         humanDelay,
@@ -10526,7 +11573,10 @@ async function dispatchToAgent(params) {
         ctx: finalCtx,
         cfg,
         dispatcher: dispatcherResult.dispatcher,
-        replyOptions: dispatcherResult.replyOptions
+        replyOptions: {
+          ...typeof dispatcherResult.replyOptions === "object" && dispatcherResult.replyOptions ? dispatcherResult.replyOptions : {},
+          ...streamingReplyOptions ?? {}
+        }
       });
       dispatcherResult.markDispatchIdle?.();
       await flushBufferedC2CMarkdownReply();
@@ -10535,7 +11585,7 @@ async function dispatchToAgent(params) {
       inbound,
       replyDelivered
     });
-    if (noReplyFallback && !groupMessageInterfaceBlocked) {
+    if (noReplyFallback && !groupMessageInterfaceBlocked && !isFastAbortCommand && !shouldSuppressVisibleReplies()) {
       logger.info("no visible reply generated for group mention; sending fallback text");
       const fallbackResult = await qqbotOutbound.sendText({
         cfg: { channels: { qqbot: qqCfg } },
@@ -10609,18 +11659,39 @@ async function handleQQBotDispatch(params) {
     logger.info("qqbot disabled, ignoring inbound message");
     return;
   }
-  const content = inbound.content.trim();
+  const senderNameResolution = resolveQQBotSenderName({
+    inbound,
+    cfg: params.cfg,
+    accountId
+  });
+  const resolvedInbound = {
+    ...inbound,
+    senderName: senderNameResolution.displayName
+  };
+  logQQBotSenderNameResolution({
+    logger,
+    inbound,
+    accountId,
+    resolution: senderNameResolution
+  });
+  const content = resolvedInbound.content.trim();
   const inboundLogContent = sanitizeInboundLogText(
     resolveInboundLogContent({
       content,
-      attachments: inbound.attachments
+      attachments: resolvedInbound.attachments
     })
   );
-  logger.info(`[inbound-user] accountId=${accountId} senderId=${inbound.senderId} content=${inboundLogContent}`);
-  if (!shouldHandleMessage(inbound, qqCfg, logger)) {
+  logger.info(
+    `[inbound-user] accountId=${accountId} senderId=${resolvedInbound.senderId} senderName=${JSON.stringify(resolvedInbound.senderName ?? resolvedInbound.senderId)} content=${inboundLogContent}`
+  );
+  if (!shouldHandleMessage(resolvedInbound, qqCfg, logger)) {
     return;
   }
-  const knownTarget = resolveKnownQQBotTargetFromInbound({ inbound, accountId });
+  const knownTarget = resolveKnownQQBotTargetFromInbound({
+    inbound: resolvedInbound,
+    accountId,
+    persistentDisplayName: senderNameResolution.persistentDisplayName
+  });
   if (knownTarget) {
     try {
       upsertKnownQQBotTarget({ target: knownTarget });
@@ -10628,7 +11699,7 @@ async function handleQQBotDispatch(params) {
       logger.warn(`failed to record known qqbot target: ${String(err)}`);
     }
   }
-  const attachmentCount = inbound.attachments?.length ?? 0;
+  const attachmentCount = resolvedInbound.attachments?.length ?? 0;
   if (attachmentCount > 0) {
     logger.info(`inbound message includes ${attachmentCount} attachment(s)`);
   }
@@ -10641,7 +11712,7 @@ async function handleQQBotDispatch(params) {
     logger.warn("routing API not available");
     return;
   }
-  const target = resolveChatTarget(inbound);
+  const target = resolveChatTarget(resolvedInbound);
   const route = routing({
     cfg: params.cfg,
     channel: "qqbot",
@@ -10649,7 +11720,7 @@ async function handleQQBotDispatch(params) {
     peer: { kind: target.peerKind, id: target.peerId }
   });
   const effectiveSessionKey = resolveQQBotEffectiveSessionKey({
-    inbound,
+    inbound: resolvedInbound,
     route,
     accountId
   });
@@ -10659,13 +11730,36 @@ async function handleQQBotDispatch(params) {
     effectiveSessionKey
   };
   const queueKey = buildSessionDispatchQueueKey(resolvedRoute);
-  if (sessionDispatchQueue.has(queueKey)) {
+  if (isQQBotFastAbortCommandText(content)) {
+    const routeSessionKey = resolveQQBotRouteSessionKey(resolvedRoute);
+    markSessionDispatchAbort(queueKey);
+    const droppedCount = dropQueuedSessionDispatches(queueKey);
+    logger.info(
+      `session fast-abort command detected; executing immediately sessionKey=${routeSessionKey}`
+    );
+    logger.info(
+      `session fast-abort command dropped ${droppedCount} queued messages sessionKey=${routeSessionKey}`
+    );
+    await runImmediateSessionDispatch(
+      queueKey,
+      async () => dispatchToAgent({
+        inbound: { ...resolvedInbound, content },
+        cfg: params.cfg,
+        qqCfg,
+        accountId,
+        logger,
+        route: resolvedRoute
+      })
+    );
+    return;
+  }
+  if (hasSessionDispatchBacklog(queueKey)) {
     logger.info(`session busy; queueing inbound dispatch sessionKey=${resolveQQBotRouteSessionKey(resolvedRoute)}`);
   }
   await runSerializedSessionDispatch(
     queueKey,
     async () => dispatchToAgent({
-      inbound: { ...inbound, content },
+      inbound: { ...resolvedInbound, content },
       cfg: params.cfg,
       qqCfg,
       accountId,
@@ -10693,6 +11787,10 @@ function formatGatewayConnectError(err) {
   }
   return String(err);
 }
+function isConnectionIdle(conn) {
+  if (!conn) return true;
+  return !conn.socket && !conn.promise && !conn.connecting;
+}
 var activeConnections = /* @__PURE__ */ new Map();
 function getOrCreateConnection(accountId) {
   let conn = activeConnections.get(accountId);
@@ -10722,7 +11820,10 @@ function clearTimers(conn) {
     conn.reconnectTimer = null;
   }
 }
-function cleanupSocket(conn) {
+function cleanupSocket(conn, expectedSocket) {
+  if (expectedSocket && conn.socket !== expectedSocket) {
+    return false;
+  }
   clearTimers(conn);
   if (conn.socket) {
     try {
@@ -10733,6 +11834,7 @@ function cleanupSocket(conn) {
     }
     conn.socket = null;
   }
+  return true;
 }
 async function monitorQQBotProvider(opts = {}) {
   const { config, runtime: runtime2, abortSignal, accountId = DEFAULT_ACCOUNT_ID, setStatus } = opts;
@@ -10740,11 +11842,16 @@ async function monitorQQBotProvider(opts = {}) {
     log: runtime2?.log,
     error: runtime2?.error
   });
-  const conn = getOrCreateConnection(accountId);
-  if (conn.socket) {
-    if (conn.promise) {
-      return conn.promise;
-    }
+  const existingConn = activeConnections.get(accountId);
+  if (!existingConn) ; else if (isConnectionIdle(existingConn)) {
+    activeConnections.delete(accountId);
+  }
+  const conn = activeConnections.get(accountId);
+  const existingPromise = conn?.promise;
+  if (existingPromise) {
+    return existingPromise;
+  }
+  if (conn?.socket) {
     throw new Error(`QQBot monitor state invalid for account ${accountId}: active socket without promise`);
   }
   const qqCfg = config ? mergeQQBotAccountConfig(config, accountId) : void 0;
@@ -10754,18 +11861,20 @@ async function monitorQQBotProvider(opts = {}) {
   if (!qqCfg.appId || !qqCfg.clientSecret) {
     throw new Error(`QQBot not configured for account ${accountId} (missing appId or clientSecret)`);
   }
-  conn.promise = new Promise((resolve3, reject) => {
+  const nextConn = conn ?? getOrCreateConnection(accountId);
+  nextConn.promise = new Promise((resolve3, reject) => {
     let stopped = false;
     const finish = (err) => {
       if (stopped) return;
       stopped = true;
       abortSignal?.removeEventListener("abort", onAbort);
-      cleanupSocket(conn);
-      conn.sessionId = null;
-      conn.lastSeq = null;
-      conn.promise = null;
-      conn.stop = null;
-      conn.reconnectAttempt = 0;
+      cleanupSocket(nextConn);
+      nextConn.connecting = false;
+      nextConn.sessionId = null;
+      nextConn.lastSeq = null;
+      nextConn.promise = null;
+      nextConn.stop = null;
+      nextConn.reconnectAttempt = 0;
       activeConnections.delete(accountId);
       {
         resolve3();
@@ -10775,33 +11884,33 @@ async function monitorQQBotProvider(opts = {}) {
       logger.info("abort signal received, stopping gateway");
       finish();
     };
-    conn.stop = () => {
+    nextConn.stop = () => {
       logger.info("stop requested");
       finish();
     };
     const scheduleReconnect = (reason) => {
       if (stopped) return;
-      if (conn.reconnectTimer) return;
-      const delay = RECONNECT_DELAYS_MS[Math.min(conn.reconnectAttempt, RECONNECT_DELAYS_MS.length - 1)];
-      conn.reconnectAttempt += 1;
+      if (nextConn.reconnectTimer) return;
+      const delay = RECONNECT_DELAYS_MS[Math.min(nextConn.reconnectAttempt, RECONNECT_DELAYS_MS.length - 1)];
+      nextConn.reconnectAttempt += 1;
       logger.warn(`[reconnect] ${reason}; retry in ${delay}ms`);
-      conn.reconnectTimer = setTimeout(() => {
-        conn.reconnectTimer = null;
+      nextConn.reconnectTimer = setTimeout(() => {
+        nextConn.reconnectTimer = null;
         void connect();
       }, delay);
     };
     const startHeartbeat = (intervalMs) => {
-      if (conn.heartbeatTimer) {
-        clearInterval(conn.heartbeatTimer);
+      if (nextConn.heartbeatTimer) {
+        clearInterval(nextConn.heartbeatTimer);
       }
-      conn.heartbeatTimer = setInterval(() => {
-        if (!conn.socket || conn.socket.readyState !== WebSocket.OPEN) return;
-        const payload = JSON.stringify({ op: 1, d: conn.lastSeq });
-        conn.socket.send(payload);
+      nextConn.heartbeatTimer = setInterval(() => {
+        if (!nextConn.socket || nextConn.socket.readyState !== WebSocket.OPEN) return;
+        const payload = JSON.stringify({ op: 1, d: nextConn.lastSeq });
+        nextConn.socket.send(payload);
       }, intervalMs);
     };
     const sendIdentify = (token) => {
-      if (!conn.socket || conn.socket.readyState !== WebSocket.OPEN) return;
+      if (!nextConn.socket || nextConn.socket.readyState !== WebSocket.OPEN) return;
       const payload = {
         op: 2,
         d: {
@@ -10810,10 +11919,10 @@ async function monitorQQBotProvider(opts = {}) {
           shard: [0, 1]
         }
       };
-      conn.socket.send(JSON.stringify(payload));
+      nextConn.socket.send(JSON.stringify(payload));
     };
     const sendResume = (token, session, seq) => {
-      if (!conn.socket || conn.socket.readyState !== WebSocket.OPEN) return;
+      if (!nextConn.socket || nextConn.socket.readyState !== WebSocket.OPEN) return;
       const payload = {
         op: 6,
         d: {
@@ -10822,11 +11931,14 @@ async function monitorQQBotProvider(opts = {}) {
           seq
         }
       };
-      conn.socket.send(JSON.stringify(payload));
+      nextConn.socket.send(JSON.stringify(payload));
     };
-    const handleGatewayPayload = async (payload) => {
+    const handleGatewayPayload = async (payload, activeSocket) => {
+      if (stopped || nextConn.socket !== activeSocket) {
+        return;
+      }
       if (typeof payload.s === "number") {
-        conn.lastSeq = payload.s;
+        nextConn.lastSeq = payload.s;
       }
       switch (payload.op) {
         case 10: {
@@ -10834,8 +11946,11 @@ async function monitorQQBotProvider(opts = {}) {
           const interval = hello?.heartbeat_interval ?? 3e4;
           startHeartbeat(interval);
           const token = await getAccessToken(qqCfg.appId, qqCfg.clientSecret);
-          if (conn.sessionId && typeof conn.lastSeq === "number") {
-            sendResume(token, conn.sessionId, conn.lastSeq);
+          if (stopped || nextConn.socket !== activeSocket) {
+            return;
+          }
+          if (nextConn.sessionId && typeof nextConn.lastSeq === "number") {
+            sendResume(token, nextConn.sessionId, nextConn.lastSeq);
           } else {
             sendIdentify(token);
           }
@@ -10845,14 +11960,18 @@ async function monitorQQBotProvider(opts = {}) {
           setStatus?.({ lastEventAt: Date.now() });
           return;
         case 7:
-          cleanupSocket(conn);
+          if (!cleanupSocket(nextConn, activeSocket)) {
+            return;
+          }
           scheduleReconnect("server requested reconnect");
           return;
         case 9:
-          conn.sessionId = null;
-          conn.lastSeq = null;
+          nextConn.sessionId = null;
+          nextConn.lastSeq = null;
           clearTokenCache(qqCfg.appId);
-          cleanupSocket(conn);
+          if (!cleanupSocket(nextConn, activeSocket)) {
+            return;
+          }
           scheduleReconnect("invalid session");
           return;
         case 0: {
@@ -10860,14 +11979,14 @@ async function monitorQQBotProvider(opts = {}) {
           if (eventType === "READY") {
             const ready = payload.d;
             if (ready?.session_id) {
-              conn.sessionId = ready.session_id;
+              nextConn.sessionId = ready.session_id;
             }
-            conn.reconnectAttempt = 0;
+            nextConn.reconnectAttempt = 0;
             logger.info("gateway ready");
             return;
           }
           if (eventType === "RESUMED") {
-            conn.reconnectAttempt = 0;
+            nextConn.reconnectAttempt = 0;
             logger.info("gateway resumed");
             return;
           }
@@ -10888,15 +12007,21 @@ async function monitorQQBotProvider(opts = {}) {
       }
     };
     const connect = async () => {
-      if (stopped || conn.connecting) return;
-      conn.connecting = true;
+      if (stopped || nextConn.connecting) return;
+      nextConn.connecting = true;
       try {
-        cleanupSocket(conn);
+        cleanupSocket(nextConn);
         const token = await getAccessToken(qqCfg.appId, qqCfg.clientSecret);
+        if (stopped) return;
         const gatewayUrl = await getGatewayUrl(token);
+        if (stopped) return;
         logger.info(`connecting gateway: ${gatewayUrl}`);
         const ws = new WebSocket(gatewayUrl);
-        conn.socket = ws;
+        nextConn.socket = ws;
+        if (stopped) {
+          cleanupSocket(nextConn, ws);
+          return;
+        }
         ws.on("open", () => {
           logger.info("gateway socket opened");
         });
@@ -10909,24 +12034,29 @@ async function monitorQQBotProvider(opts = {}) {
             logger.warn(`failed to parse gateway payload: ${String(err)}`);
             return;
           }
-          void handleGatewayPayload(payload).catch((err) => {
+          void handleGatewayPayload(payload, ws).catch((err) => {
             logger.error(`gateway dispatch error: ${String(err)}`);
           });
         });
         ws.on("close", (code, reason) => {
+          if (!cleanupSocket(nextConn, ws)) {
+            return;
+          }
           logger.warn(`gateway socket closed (${code}) ${String(reason)}`);
-          cleanupSocket(conn);
           scheduleReconnect("socket closed");
         });
         ws.on("error", (err) => {
+          if (stopped || nextConn.socket !== ws) {
+            return;
+          }
           logger.error(`gateway socket error: ${String(err)}`);
         });
       } catch (err) {
         logger.error(`gateway connect failed: ${formatGatewayConnectError(err)}`);
-        cleanupSocket(conn);
+        cleanupSocket(nextConn);
         scheduleReconnect("connect failed");
       } finally {
-        conn.connecting = false;
+        nextConn.connecting = false;
       }
     };
     if (abortSignal?.aborted) {
@@ -10936,7 +12066,7 @@ async function monitorQQBotProvider(opts = {}) {
     abortSignal?.addEventListener("abort", onAbort, { once: true });
     void connect();
   });
-  return conn.promise;
+  return nextConn.promise;
 }
 function stopQQBotMonitorForAccount(accountId = DEFAULT_ACCOUNT_ID) {
   const conn = activeConnections.get(accountId);
@@ -10973,7 +12103,8 @@ function resolveQQBotAccount(params) {
     configured,
     appId: credentials?.appId,
     markdownSupport: merged.markdownSupport ?? true,
-    c2cMarkdownDeliveryMode: merged.c2cMarkdownDeliveryMode ?? "proactive-table-only"
+    c2cMarkdownDeliveryMode: merged.c2cMarkdownDeliveryMode ?? "proactive-table-only",
+    c2cMarkdownChunkStrategy: merged.c2cMarkdownChunkStrategy ?? "markdown-block"
   };
 }
 var qqbotPlugin = {
@@ -11051,6 +12182,10 @@ var qqbotPlugin = {
         defaultAccount: { type: "string" },
         appId: { type: ["string", "number"] },
         clientSecret: { type: "string" },
+        displayAliases: {
+          type: "object",
+          additionalProperties: { type: "string" }
+        },
         asr: {
           type: "object",
           additionalProperties: false,
@@ -11066,6 +12201,10 @@ var qqbotPlugin = {
           type: "string",
           enum: ["passive", "proactive-table-only", "proactive-all"]
         },
+        c2cMarkdownChunkStrategy: {
+          type: "string",
+          enum: ["markdown-block", "length"]
+        },
         dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
         groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
         requireMention: { type: "boolean" },
@@ -11096,6 +12235,10 @@ var qqbotPlugin = {
               enabled: { type: "boolean" },
               appId: { type: ["string", "number"] },
               clientSecret: { type: "string" },
+              displayAliases: {
+                type: "object",
+                additionalProperties: { type: "string" }
+              },
               asr: {
                 type: "object",
                 additionalProperties: false,
@@ -11111,6 +12254,10 @@ var qqbotPlugin = {
                 type: "string",
                 enum: ["passive", "proactive-table-only", "proactive-all"]
               },
+              c2cMarkdownChunkStrategy: {
+                type: "string",
+                enum: ["markdown-block", "length"]
+              },
               dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
               groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
               requireMention: { type: "boolean" },
@@ -11262,7 +12409,9 @@ var qqbotPlugin = {
       ctx.log?.info(`[qqbot] starting gateway for account ${ctx.accountId}`);
       if (ctx.runtime) {
         const candidate = ctx.runtime;
-        if (candidate.channel?.routing?.resolveAgentRoute && candidate.channel?.reply?.dispatchReplyFromConfig) {
+        const hasRouting = Boolean(candidate.channel?.routing?.resolveAgentRoute);
+        const hasReply = Boolean(candidate.channel?.reply?.dispatchReplyWithDispatcher) || Boolean(candidate.channel?.reply?.dispatchReplyWithBufferedBlockDispatcher) || Boolean(candidate.channel?.reply?.dispatchReplyFromConfig);
+        if (hasRouting && hasReply) {
           setQQBotRuntime(ctx.runtime);
         }
       }
@@ -11298,6 +12447,10 @@ var plugin = {
       defaultAccount: { type: "string" },
       appId: { type: ["string", "number"] },
       clientSecret: { type: "string" },
+      displayAliases: {
+        type: "object",
+        additionalProperties: { type: "string" }
+      },
       asr: {
         type: "object",
         additionalProperties: false,
@@ -11313,6 +12466,10 @@ var plugin = {
         type: "string",
         enum: ["passive", "proactive-table-only", "proactive-all"]
       },
+      c2cMarkdownChunkStrategy: {
+        type: "string",
+        enum: ["markdown-block", "length"]
+      },
       dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
       groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
       requireMention: { type: "boolean" },
@@ -11343,6 +12500,10 @@ var plugin = {
             enabled: { type: "boolean" },
             appId: { type: ["string", "number"] },
             clientSecret: { type: "string" },
+            displayAliases: {
+              type: "object",
+              additionalProperties: { type: "string" }
+            },
             asr: {
               type: "object",
               additionalProperties: false,
@@ -11358,6 +12519,10 @@ var plugin = {
               type: "string",
               enum: ["passive", "proactive-table-only", "proactive-all"]
             },
+            c2cMarkdownChunkStrategy: {
+              type: "string",
+              enum: ["markdown-block", "length"]
+            },
             dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
             groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
             requireMention: { type: "boolean" },