@openclaw-china/qqbot 2026.3.12 → 2026.3.18

package/dist/index.js

@@ -4223,12 +4223,21 @@ 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 QQBotTypingHeartbeatModeSchema = external_exports.enum(["none", "idle", "always"]).optional().default("idle");
+var DEFAULT_QQBOT_TYPING_HEARTBEAT_MODE = "idle";
+var DEFAULT_QQBOT_TYPING_HEARTBEAT_INTERVAL_MS = 5e3;
+var DEFAULT_QQBOT_TYPING_INPUT_SECONDS = 60;
 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 +4246,14 @@ var QQBotAccountSchema = external_exports.object({
   }).optional(),
   markdownSupport: external_exports.boolean().optional().default(true),
   c2cMarkdownDeliveryMode: QQBotC2CMarkdownDeliveryModeSchema,
+  c2cMarkdownChunkStrategy: QQBotC2CMarkdownChunkStrategySchema,
+  typingHeartbeatMode: QQBotTypingHeartbeatModeSchema,
+  typingHeartbeatIntervalMs: external_exports.number().int().positive().optional().default(
+    DEFAULT_QQBOT_TYPING_HEARTBEAT_INTERVAL_MS
+  ),
+  typingInputSeconds: external_exports.number().int().positive().optional().default(
+    DEFAULT_QQBOT_TYPING_INPUT_SECONDS
+  ),
   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 +4278,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;
 }
@@ -4271,6 +4303,15 @@ function resolveInboundMediaKeepDays(config) {
 function resolveQQBotAutoSendLocalPathMedia(config) {
   return config?.autoSendLocalPathMedia ?? true;
 }
+function resolveQQBotTypingHeartbeatMode(config) {
+  return config?.typingHeartbeatMode ?? DEFAULT_QQBOT_TYPING_HEARTBEAT_MODE;
+}
+function resolveQQBotTypingHeartbeatIntervalMs(config) {
+  return config?.typingHeartbeatIntervalMs ?? DEFAULT_QQBOT_TYPING_HEARTBEAT_INTERVAL_MS;
+}
+function resolveQQBotTypingInputSeconds(config) {
+  return config?.typingInputSeconds ?? DEFAULT_QQBOT_TYPING_INPUT_SECONDS;
+}
 function resolveInboundMediaTempDir() {
   return DEFAULT_INBOUND_MEDIA_TEMP_DIR;
 }
@@ -4301,7 +4342,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 +6567,7 @@ var CHANNEL_ORDER = [
   "qqbot",
   "wecom",
   "wecom-app",
+  "wecom-kf",
   "feishu-china"
 ];
 var CHANNEL_DISPLAY_LABELS = {
@@ -6525,6 +6575,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 +6583,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 +6792,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 +7050,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 +7155,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 +7297,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 +8121,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 +9184,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 +9240,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 +9369,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") {
@@ -9256,6 +9643,37 @@ function startLongTaskNoticeTimer(params) {
     }
   };
 }
+function startQQBotTypingHeartbeat(params) {
+  const { intervalMs, renew, shouldRenew } = params;
+  let stopped = false;
+  let timer = null;
+  let renewalInFlight = false;
+  const clear = () => {
+    if (!timer) return;
+    clearInterval(timer);
+    timer = null;
+  };
+  const stop = () => {
+    if (stopped) return;
+    stopped = true;
+    clear();
+  };
+  if (intervalMs > 0) {
+    timer = setInterval(() => {
+      if (stopped || renewalInFlight) return;
+      if (shouldRenew && !shouldRenew()) return;
+      renewalInFlight = true;
+      void renew().catch(() => void 0).finally(() => {
+        renewalInFlight = false;
+      });
+    }, intervalMs);
+    timer.unref?.();
+  }
+  return {
+    stop,
+    dispose: stop
+  };
+}
 function isHttpUrl3(value) {
   return /^https?:\/\//i.test(value);
 }
@@ -9522,14 +9940,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 +9963,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 +9986,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 +10009,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 +10089,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 +10098,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 +10109,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 +10120,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 +10235,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 +10311,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 +10415,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 +11016,9 @@ async function sendQQBotMediaWithFallback(params) {
       if (!fallback) {
         continue;
       }
+      if (!shouldContinue()) {
+        return;
+      }
       const fallbackResult = await outbound.sendText({
         cfg: { channels: { qqbot: qqCfg } },
         to,
@@ -10063,16 +11071,26 @@ 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;
+  const typingHeartbeatMode = resolveQQBotTypingHeartbeatMode(qqCfg);
+  const typingHeartbeatIntervalMs = resolveQQBotTypingHeartbeatIntervalMs(qqCfg);
+  const typingInputSeconds = resolveQQBotTypingInputSeconds(qqCfg);
   let typingRefIdx;
-  if (inbound.c2cOpenid) {
+  if (inbound.c2cOpenid && !isFastAbortCommand && !shouldSuppressVisibleReplies()) {
     const typing = await qqbotOutbound.sendTyping({
       cfg: { channels: { qqbot: qqCfg } },
       to: `user:${inbound.c2cOpenid}`,
       replyToId: inbound.messageId,
       replyEventId: inbound.eventId,
-      inputSecond: 60,
+      inputSecond: typingInputSeconds,
       accountId: outboundAccountId
     });
     if (typing.error) {
@@ -10088,10 +11106,15 @@ async function dispatchToAgent(params) {
   }
   let replyDelivered = false;
   let groupMessageInterfaceBlocked = false;
+  let lastVisibleOutboundAt = Date.now();
+  let typingHeartbeat = null;
   const markReplyDelivered = () => {
     replyDelivered = true;
     longTaskNotice.markReplyDelivered();
   };
+  const markVisibleOutboundStarted = () => {
+    lastVisibleOutboundAt = Date.now();
+  };
   const markGroupMessageInterfaceBlocked = (error) => {
     if (!isQQBotGroupMessageInterfaceBlocked(error)) return;
     if (!groupMessageInterfaceBlocked) {
@@ -10099,11 +11122,40 @@ async function dispatchToAgent(params) {
     }
     groupMessageInterfaceBlocked = true;
   };
+  if (inbound.c2cOpenid && typingHeartbeatMode !== "none" && !isFastAbortCommand && !shouldSuppressVisibleReplies()) {
+    typingHeartbeat = startQQBotTypingHeartbeat({
+      intervalMs: typingHeartbeatIntervalMs,
+      shouldRenew: () => {
+        if (shouldSuppressVisibleReplies()) {
+          return false;
+        }
+        if (typingHeartbeatMode === "always") {
+          return true;
+        }
+        return Date.now() - lastVisibleOutboundAt >= typingHeartbeatIntervalMs;
+      },
+      renew: async () => {
+        try {
+          const typing = await qqbotOutbound.sendTyping({
+            cfg: { channels: { qqbot: qqCfg } },
+            to: `user:${inbound.c2cOpenid}`,
+            replyToId: inbound.messageId,
+            replyEventId: inbound.eventId,
+            inputSecond: typingInputSeconds,
+            accountId: outboundAccountId
+          });
+          void typing;
+        } catch {
+        }
+      }
+    });
+  }
   const longTaskNotice = startLongTaskNoticeTimer({
     delayMs: qqCfg.longTaskNoticeDelayMs ?? DEFAULT_LONG_TASK_NOTICE_DELAY_MS,
     logger,
     sendNotice: async () => {
-      if (groupMessageInterfaceBlocked) return;
+      if (groupMessageInterfaceBlocked || isFastAbortCommand || shouldSuppressVisibleReplies()) return;
+      markVisibleOutboundStarted();
       const result = await qqbotOutbound.sendText({
         cfg: { channels: { qqbot: qqCfg } },
         to: target.to,
@@ -10116,7 +11168,7 @@ async function dispatchToAgent(params) {
         logger.warn(`send long-task notice failed: ${result.error}`);
         markGroupMessageInterfaceBlocked(result.error);
       } else {
-        replyDelivered = true;
+        markReplyDelivered();
       }
     }
   });
@@ -10137,6 +11189,10 @@ async function dispatchToAgent(params) {
       logger
     });
     if (qqCfg.asr?.enabled && resolvedAttachmentResult.hasVoiceAttachment && !resolvedAttachmentResult.hasVoiceTranscript) {
+      if (shouldSuppressVisibleReplies()) {
+        return;
+      }
+      markVisibleOutboundStarted();
       const fallback = await qqbotOutbound.sendText({
         cfg: { channels: { qqbot: qqCfg } },
         to: target.to,
@@ -10149,7 +11205,7 @@ async function dispatchToAgent(params) {
         logger.error(`sendText ASR fallback failed: ${fallback.error}`);
         markGroupMessageInterfaceBlocked(fallback.error);
       } else {
-        replyDelivered = true;
+        markReplyDelivered();
       }
       return;
     }
@@ -10246,29 +11302,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 +11366,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 +11380,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 +11400,63 @@ 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()) {
+        if (mediaQueue.length > 0) {
+          markVisibleOutboundStarted();
         }
-      });
+        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)}`
+        );
+        markVisibleOutboundStarted();
+        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 +11467,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 +11485,9 @@ async function dispatchToAgent(params) {
       });
     };
     const deliver = async (payload, info) => {
+      if (shouldSuppressVisibleReplies()) {
+        return;
+      }
       const typed = payload;
       const extractedTextMedia = extractQQBotReplyMedia({
         text: typed?.text ?? "",
@@ -10420,7 +11519,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 +11529,12 @@ async function dispatchToAgent(params) {
           }
           return;
         }
+        if (hasBufferedC2CMarkdownReply()) {
+          await flushBufferedC2CMarkdownReply();
+          if (shouldSuppressVisibleReplies()) {
+            return;
+          }
+        }
         await sendC2CMarkdownTransportPayload({
           text: textToSend,
           mediaUrls: mediaQueue,
@@ -10448,6 +11554,10 @@ async function dispatchToAgent(params) {
         });
         const chunks = chunkText(converted);
         for (const chunk of chunks) {
+          if (shouldSuppressVisibleReplies()) {
+            return;
+          }
+          markVisibleOutboundStarted();
           const result = await qqbotOutbound.sendText({
             cfg: { channels: { qqbot: qqCfg } },
             to: target.to,
@@ -10464,6 +11574,12 @@ async function dispatchToAgent(params) {
           }
         }
       }
+      if (shouldSuppressVisibleReplies()) {
+        return;
+      }
+      if (mediaQueue.length > 0) {
+        markVisibleOutboundStarted();
+      }
       await sendQQBotMediaWithFallback({
         qqCfg,
         to: target.to,
@@ -10477,12 +11593,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 +11639,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 +11670,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,8 +11682,9 @@ 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");
+      markVisibleOutboundStarted();
       const fallbackResult = await qqbotOutbound.sendText({
         cfg: { channels: { qqbot: qqCfg } },
         to: target.to,
@@ -10553,6 +11701,7 @@ async function dispatchToAgent(params) {
       }
     }
   } finally {
+    typingHeartbeat?.dispose();
     longTaskNotice.dispose();
     try {
       await pruneInboundMediaDir({
@@ -10609,18 +11758,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 +11798,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 +11811,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 +11819,7 @@ async function handleQQBotDispatch(params) {
     peer: { kind: target.peerKind, id: target.peerId }
   });
   const effectiveSessionKey = resolveQQBotEffectiveSessionKey({
-    inbound,
+    inbound: resolvedInbound,
     route,
     accountId
   });
@@ -10659,13 +11829,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 +11886,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 +11919,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 +11933,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 +11941,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 +11960,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 +11983,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 +12018,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 +12030,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 +12045,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 +12059,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 +12078,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 +12106,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 +12133,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 +12165,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 +12202,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 +12281,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 +12300,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 +12334,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 +12353,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 +12508,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 +12546,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 +12565,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 +12599,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 +12618,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" },