@openclaw-china/qqbot 2026.3.11 → 2026.3.16

package/dist/index.js

@@ -3,7 +3,7 @@ import { homedir, tmpdir } from 'os';
 import * as path2 from 'path';
 import { join, dirname } from 'path';
 import * as fs3 from 'fs';
-import { existsSync, readFileSync, rmSync, writeFileSync, mkdirSync } from 'fs';
+import { existsSync, readFileSync, rmSync, writeFileSync, renameSync, copyFileSync, mkdirSync, appendFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import * as fsPromises from 'fs/promises';
 import { createHmac } from 'crypto';
@@ -651,8 +651,8 @@ function getErrorMap() {
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path4, errorMaps, issueData } = params;
-  const fullPath = [...path4, ...issueData.path || []];
+  const { data, path: path5, errorMaps, issueData } = params;
+  const fullPath = [...path5, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -768,11 +768,11 @@ var errorUtil;
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path4, key) {
+  constructor(parent, value, path5, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path4;
+    this._path = path5;
     this._key = key;
   }
   get path() {
@@ -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);
@@ -4876,7 +4905,7 @@ function extractMediaFromText(text, options = {}) {
   const {
     removeFromText = true,
     checkExists = false,
-    existsSync: existsSync6,
+    existsSync: existsSync7,
     parseMediaLines = false,
     parseMarkdownImages = true,
     parseHtmlImages = true,
@@ -4891,7 +4920,7 @@ function extractMediaFromText(text, options = {}) {
     const key = media.localPath || media.source;
     if (seenSources.has(key)) return false;
     if (checkExists && media.isLocal && media.localPath) {
-      const exists = existsSync6 ? existsSync6(media.localPath) : fs3.existsSync(media.localPath);
+      const exists = existsSync7 ? existsSync7(media.localPath) : fs3.existsSync(media.localPath);
       if (!exists) return false;
     }
     seenSources.add(key);
@@ -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");
@@ -7380,8 +7466,8 @@ async function getAccessToken(appId, clientSecret, options) {
   tokenPromiseMap.set(normalizedAppId, promise);
   return promise;
 }
-async function apiGet(accessToken, path4, options) {
-  const url = `${API_BASE}${path4}`;
+async function apiGet(accessToken, path5, options) {
+  const url = `${API_BASE}${path5}`;
   return httpGet(url, {
     ...options,
     headers: {
@@ -7390,8 +7476,8 @@ async function apiGet(accessToken, path4, options) {
     }
   });
 }
-async function apiPost(accessToken, path4, body, options) {
-  const url = `${API_BASE}${path4}`;
+async function apiPost(accessToken, path5, body, options) {
+  const url = `${API_BASE}${path5}`;
   return httpPost(url, body, {
     ...options,
     headers: {
@@ -7490,7 +7576,7 @@ async function sendChannelMessage(params) {
   });
 }
 async function sendC2CInputNotify(params) {
-  await postPassiveMessage({
+  const response = await postPassiveMessage({
     accessToken: params.accessToken,
     path: `/v2/users/${params.openid}/messages`,
     sequenceKey: resolveMsgSeqKey(params.messageId, params.eventId),
@@ -7505,6 +7591,8 @@ async function sendC2CInputNotify(params) {
       ...params.messageId ? { msg_id: params.messageId } : params.eventId ? { event_id: params.eventId } : {}
     })
   });
+  const refIdx = response.ext_info?.ref_idx?.trim();
+  return refIdx ? { refIdx } : {};
 }
 async function uploadC2CMedia(params) {
   const body = {
@@ -7574,6 +7662,233 @@ async function sendGroupMediaMessage(params) {
     })
   });
 }
+var REF_INDEX_FILE = join(homedir(), ".openclaw", "qqbot", "data", "ref-index.jsonl");
+var MAX_CONTENT_LENGTH = 500;
+var MAX_ENTRIES = 5e4;
+var TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var COMPACT_THRESHOLD_RATIO = 2;
+var cache = null;
+var totalLinesOnDisk = 0;
+function normalizeRefIdx(refIdx) {
+  const next = refIdx.trim();
+  return next ? next : void 0;
+}
+function ensureStorageDir() {
+  mkdirSync(dirname(REF_INDEX_FILE), { recursive: true });
+}
+function truncateContent(content) {
+  return content.trim().slice(0, MAX_CONTENT_LENGTH);
+}
+function sanitizeAttachmentSummary(attachment) {
+  const type = attachment.type;
+  const filename = attachment.filename?.trim();
+  const contentType = attachment.contentType?.trim();
+  const localPath = attachment.localPath?.trim();
+  const url = attachment.url?.trim();
+  const transcript = attachment.transcript?.trim();
+  if (!filename && !contentType && !localPath && !url && !transcript && type === "unknown") {
+    return void 0;
+  }
+  return {
+    type,
+    ...filename ? { filename } : {},
+    ...contentType ? { contentType } : {},
+    ...localPath ? { localPath } : {},
+    ...url ? { url } : {},
+    ...transcript ? { transcript } : {},
+    ...transcript && attachment.transcriptSource ? { transcriptSource: attachment.transcriptSource } : {}
+  };
+}
+function sanitizeEntry(entry) {
+  const senderId = entry.senderId.trim() || "unknown";
+  const senderName = entry.senderName?.trim();
+  const timestamp = Number.isFinite(entry.timestamp) ? Math.trunc(entry.timestamp) : Date.now();
+  const attachments = entry.attachments?.map((attachment) => sanitizeAttachmentSummary(attachment)).filter((attachment) => Boolean(attachment));
+  return {
+    content: truncateContent(entry.content),
+    senderId,
+    ...senderName ? { senderName } : {},
+    timestamp,
+    ...entry.isBot ? { isBot: true } : {},
+    ...attachments && attachments.length > 0 ? { attachments } : {}
+  };
+}
+function shouldCompact() {
+  if (!cache) return false;
+  return totalLinesOnDisk > cache.size * COMPACT_THRESHOLD_RATIO && totalLinesOnDisk > 1e3;
+}
+function compactFile() {
+  if (!cache) return;
+  try {
+    ensureStorageDir();
+    const tempPath = `${REF_INDEX_FILE}.tmp`;
+    const lines = [];
+    for (const [key, entry] of cache.entries()) {
+      lines.push(
+        JSON.stringify({
+          k: key,
+          v: sanitizeEntry(entry),
+          t: entry._createdAt
+        })
+      );
+    }
+    writeFileSync(tempPath, lines.length > 0 ? `${lines.join("\n")}
+` : "", "utf8");
+    renameSync(tempPath, REF_INDEX_FILE);
+    totalLinesOnDisk = cache.size;
+  } catch {
+  }
+}
+function evictIfNeeded() {
+  if (!cache || cache.size < MAX_ENTRIES) return;
+  const now = Date.now();
+  for (const [key, entry] of cache.entries()) {
+    if (now - entry._createdAt > TTL_MS) {
+      cache.delete(key);
+    }
+  }
+  if (cache.size < MAX_ENTRIES) {
+    return;
+  }
+  const sorted = [...cache.entries()].sort((left, right) => left[1]._createdAt - right[1]._createdAt);
+  const removeCount = cache.size - MAX_ENTRIES + 1;
+  for (let index = 0; index < removeCount; index += 1) {
+    const key = sorted[index]?.[0];
+    if (key) {
+      cache.delete(key);
+    }
+  }
+}
+function loadCache() {
+  if (cache) {
+    return cache;
+  }
+  cache = /* @__PURE__ */ new Map();
+  totalLinesOnDisk = 0;
+  try {
+    if (!existsSync(REF_INDEX_FILE)) {
+      return cache;
+    }
+    const now = Date.now();
+    const raw = readFileSync(REF_INDEX_FILE, "utf8");
+    const lines = raw.split(/\r?\n/);
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      totalLinesOnDisk += 1;
+      try {
+        const parsed = JSON.parse(trimmed);
+        const key = typeof parsed.k === "string" ? normalizeRefIdx(parsed.k) : void 0;
+        const createdAt = typeof parsed.t === "number" && Number.isFinite(parsed.t) ? parsed.t : void 0;
+        if (!key || createdAt === void 0 || !parsed.v || typeof parsed.v !== "object") {
+          continue;
+        }
+        if (now - createdAt > TTL_MS) {
+          continue;
+        }
+        const entry = sanitizeEntry(parsed.v);
+        cache.set(key, {
+          ...entry,
+          _createdAt: createdAt
+        });
+      } catch {
+      }
+    }
+    if (shouldCompact()) {
+      compactFile();
+    }
+  } catch {
+    cache = /* @__PURE__ */ new Map();
+    totalLinesOnDisk = 0;
+  }
+  return cache;
+}
+function appendLine(line) {
+  try {
+    ensureStorageDir();
+    appendFileSync(REF_INDEX_FILE, `${JSON.stringify(line)}
+`, "utf8");
+    totalLinesOnDisk += 1;
+  } catch {
+  }
+}
+function restoreEntry(entry) {
+  const sanitized = sanitizeEntry(entry);
+  return {
+    content: sanitized.content,
+    senderId: sanitized.senderId,
+    ...sanitized.senderName ? { senderName: sanitized.senderName } : {},
+    timestamp: sanitized.timestamp,
+    ...sanitized.isBot ? { isBot: true } : {},
+    ...sanitized.attachments ? { attachments: sanitized.attachments } : {}
+  };
+}
+function formatAttachmentSummary(attachment) {
+  const sourceParts = [
+    attachment.localPath?.trim() ? `\u672C\u5730: ${attachment.localPath.trim()}` : void 0,
+    attachment.url?.trim() ? `\u94FE\u63A5: ${attachment.url.trim()}` : void 0
+  ].filter((value) => Boolean(value));
+  const sourceSuffix = sourceParts.length > 0 ? ` (${sourceParts.join(" | ")})` : "";
+  if (attachment.type === "image") {
+    return `[\u56FE\u7247${attachment.filename?.trim() ? `: ${attachment.filename.trim()}` : ""}]${sourceSuffix}`;
+  }
+  if (attachment.type === "voice") {
+    if (attachment.transcript?.trim()) {
+      const sourceLabel = attachment.transcriptSource === "asr" ? "\u5B98\u65B9\u8BC6\u522B" : attachment.transcriptSource === "stt" ? "\u672C\u5730\u8BC6\u522B" : attachment.transcriptSource === "tts" ? "TTS \u539F\u6587" : attachment.transcriptSource === "fallback" ? "\u515C\u5E95\u6587\u672C" : void 0;
+      return `[\u8BED\u97F3\u6D88\u606F: ${attachment.transcript.trim()}${sourceLabel ? ` (${sourceLabel})` : ""}]${sourceSuffix}`;
+    }
+    return `[\u8BED\u97F3\u6D88\u606F]${sourceSuffix}`;
+  }
+  if (attachment.type === "video") {
+    return `[\u89C6\u9891${attachment.filename?.trim() ? `: ${attachment.filename.trim()}` : ""}]${sourceSuffix}`;
+  }
+  if (attachment.type === "file") {
+    return `[\u6587\u4EF6${attachment.filename?.trim() ? `: ${attachment.filename.trim()}` : ""}]${sourceSuffix}`;
+  }
+  return `[\u9644\u4EF6${attachment.filename?.trim() ? `: ${attachment.filename.trim()}` : ""}]${sourceSuffix}`;
+}
+function setRefIndex(refIdx, entry) {
+  const key = normalizeRefIdx(refIdx);
+  if (!key) return;
+  const store = loadCache();
+  evictIfNeeded();
+  const nextEntry = sanitizeEntry(entry);
+  const createdAt = Date.now();
+  store.set(key, {
+    ...nextEntry,
+    _createdAt: createdAt
+  });
+  appendLine({
+    k: key,
+    v: nextEntry,
+    t: createdAt
+  });
+  if (shouldCompact()) {
+    compactFile();
+  }
+}
+function getRefIndex(refIdx) {
+  const key = normalizeRefIdx(refIdx);
+  if (!key) return null;
+  const store = loadCache();
+  const entry = store.get(key);
+  if (!entry) {
+    return null;
+  }
+  if (Date.now() - entry._createdAt > TTL_MS) {
+    store.delete(key);
+    return null;
+  }
+  return restoreEntry(entry);
+}
+function formatRefEntryForAgent(entry) {
+  const content = entry.content.trim();
+  const parts = content ? [content] : [];
+  for (const attachment of entry.attachments ?? []) {
+    parts.push(formatAttachmentSummary(attachment));
+  }
+  return parts.join("\n") || "[\u7A7A\u6D88\u606F]";
+}
 var require2 = createRequire(import.meta.url);
 function resolveQQBotMediaFileType(fileName) {
   const mediaType = detectMediaType(fileName);
@@ -7729,7 +8044,7 @@ async function sendFileQQBot(params) {
     }
   }
   try {
-    return await sendC2CMediaMessage({
+    const result = await sendC2CMediaMessage({
       accessToken,
       openid: target.id,
       fileInfo,
@@ -7737,6 +8052,12 @@ async function sendFileQQBot(params) {
       ...messageId ? { messageId } : {},
       ...eventId ? { eventId } : {}
     });
+    const refIdx = result.ext_info?.ref_idx?.trim();
+    return {
+      id: result.id,
+      timestamp: result.timestamp,
+      ...refIdx ? { refIdx } : {}
+    };
   } catch (err) {
     const message = formatQQBotError(err);
     throw new Error(`QQBot C2C media send failed: ${message}`);
@@ -7780,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 };
@@ -7853,6 +8175,85 @@ function shouldRetryWithEventId(err) {
 function shouldSendTextAsFollowupForMedia(mediaUrl) {
   return detectMediaType(stripTitleFromUrl(mediaUrl)) === "file";
 }
+function isHttpUrl2(value) {
+  return /^https?:\/\//i.test(value);
+}
+function resolveResponseRefIdx(response) {
+  if (!response || typeof response !== "object") {
+    return void 0;
+  }
+  const direct = response.refIdx;
+  if (typeof direct === "string" && direct.trim()) {
+    return direct.trim();
+  }
+  const extInfo = response.ext_info;
+  if (typeof extInfo?.ref_idx === "string" && extInfo.ref_idx.trim()) {
+    return extInfo.ref_idx.trim();
+  }
+  return void 0;
+}
+function resolveOutboundAttachmentType(mediaUrl) {
+  const detected = detectMediaType(stripTitleFromUrl(mediaUrl));
+  if (detected === "image") return "image";
+  if (detected === "video") return "video";
+  if (detected === "audio") return "voice";
+  if (detected === "file") return "file";
+  return "unknown";
+}
+function resolveOutboundAttachmentFileName(mediaUrl) {
+  const source = stripTitleFromUrl(mediaUrl).trim();
+  if (!source) return void 0;
+  if (isHttpUrl2(source)) {
+    try {
+      const base2 = path2.posix.basename(new URL(source).pathname);
+      return base2 && base2 !== "/" ? base2 : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  const base = path2.basename(source);
+  return base || void 0;
+}
+function buildOutboundAttachmentSummary(params) {
+  const source = stripTitleFromUrl(params.mediaUrl).trim();
+  const type = resolveOutboundAttachmentType(source);
+  const filename = resolveOutboundAttachmentFileName(source);
+  const text = params.text?.trim();
+  return {
+    type,
+    ...filename ? { filename } : {},
+    ...isHttpUrl2(source) ? { url: source } : { localPath: source },
+    ...type === "voice" && text ? {
+      transcript: text,
+      transcriptSource: "tts"
+    } : {}
+  };
+}
+function recordOutboundC2CRefIndex(params) {
+  const refIdx = params.refIdx?.trim();
+  if (!refIdx) return;
+  const text = params.text?.trim() ?? "";
+  const attachments = params.mediaUrl?.trim() ? [buildOutboundAttachmentSummary({ mediaUrl: params.mediaUrl, text })] : void 0;
+  if (!text && !attachments) {
+    return;
+  }
+  try {
+    const accountLabel = params.accountId?.trim() || DEFAULT_ACCOUNT_ID;
+    setRefIndex(refIdx, {
+      content: text,
+      senderId: accountLabel,
+      senderName: accountLabel,
+      timestamp: Date.now(),
+      isBot: true,
+      ...attachments ? { attachments } : {}
+    });
+    console.info(
+      `[qqbot] cached outbound ref_idx=${refIdx} accountId=${accountLabel} textLen=${text.length} media=${params.mediaUrl?.trim() ? "yes" : "no"}`
+    );
+  } catch (err) {
+    console.warn(`[qqbot] failed to cache outbound ref_idx=${refIdx}: ${String(err)}`);
+  }
+}
 function buildPassiveReplyRefs(params) {
   if (params.replyToId) {
     return { messageId: params.replyToId };
@@ -7998,7 +8399,14 @@ var qqbotOutbound = {
           content: text,
           markdown
         });
-        return { channel: "qqbot", messageId: result2.id, timestamp: result2.timestamp };
+        const refIdx2 = resolveResponseRefIdx(result2);
+        recordOutboundC2CRefIndex({ refIdx: refIdx2, accountId, text });
+        return {
+          channel: "qqbot",
+          messageId: result2.id,
+          timestamp: result2.timestamp,
+          ...refIdx2 ? { refIdx: refIdx2 } : {}
+        };
       }
       let result;
       try {
@@ -8065,7 +8473,14 @@ var qqbotOutbound = {
           throw retryErr;
         }
       }
-      return { channel: "qqbot", messageId: result.id, timestamp: result.timestamp };
+      const refIdx = resolveResponseRefIdx(result);
+      recordOutboundC2CRefIndex({ refIdx, accountId, text });
+      return {
+        channel: "qqbot",
+        messageId: result.id,
+        timestamp: result.timestamp,
+        ...refIdx ? { refIdx } : {}
+      };
     } catch (err) {
       const message = summarizeError(err);
       return { channel: "qqbot", error: message };
@@ -8174,7 +8589,21 @@ ${mediaUrl}` : mediaUrl;
           };
         }
       }
-      return { channel: "qqbot", messageId: result.id, timestamp: result.timestamp };
+      const refIdx = target.kind === "c2c" ? resolveResponseRefIdx(result) : void 0;
+      if (target.kind === "c2c") {
+        recordOutboundC2CRefIndex({
+          refIdx,
+          accountId,
+          text: sendTextAsFollowup ? void 0 : trimmedText,
+          mediaUrl
+        });
+      }
+      return {
+        channel: "qqbot",
+        messageId: result.id,
+        timestamp: result.timestamp,
+        ...refIdx ? { refIdx } : {}
+      };
     } catch (err) {
       const message = summarizeError(err);
       return { channel: "qqbot", error: message };
@@ -8193,8 +8622,9 @@ ${mediaUrl}` : mediaUrl;
     }
     try {
       const accessToken = await getAccessToken(credentials.appId, credentials.clientSecret);
+      let typingResult;
       try {
-        await sendC2CInputNotify({
+        typingResult = await sendC2CInputNotify({
           accessToken,
           openid: target.id,
           messageId: replyToId,
@@ -8216,7 +8646,7 @@ ${mediaUrl}` : mediaUrl;
           reason: summarizeError(err)
         });
         try {
-          await sendC2CInputNotify({
+          typingResult = await sendC2CInputNotify({
             accessToken,
             openid: target.id,
             eventId: replyEventId,
@@ -8245,7 +8675,10 @@ ${mediaUrl}` : mediaUrl;
           throw retryErr;
         }
       }
-      return { channel: "qqbot" };
+      return {
+        channel: "qqbot",
+        ...typingResult?.refIdx ? { refIdx: typingResult.refIdx } : {}
+      };
     } catch (err) {
       const message = summarizeError(err);
       return { channel: "qqbot", error: message };
@@ -8394,13 +8827,13 @@ async function replaceAsync(input2, pattern, replacer) {
   return result;
 }
 async function getResolvedImageSize(params) {
-  const { url, cache, resolveImageSize } = params;
-  const existing = cache.get(url);
+  const { url, cache: cache2, resolveImageSize } = params;
+  const existing = cache2.get(url);
   if (existing) {
     return existing;
   }
   const pending = resolveImageSize(url).then((size) => normalizeImageSize(size) ?? DEFAULT_QQBOT_MARKDOWN_IMAGE_SIZE).catch(() => DEFAULT_QQBOT_MARKDOWN_IMAGE_SIZE);
-  cache.set(url, pending);
+  cache2.set(url, pending);
   return pending;
 }
 async function normalizeTextSegment(params) {
@@ -8527,13 +8960,29 @@ async function normalizeQQBotMarkdownImages(params) {
 
 ${appendedImages.join("\n")}`;
 }
-var DEFAULT_KNOWN_TARGETS_PATH = join(homedir(), ".openclaw", "data", "qqbot", "known-targets.json");
+var DEFAULT_KNOWN_TARGETS_PATH = join(homedir(), ".openclaw", "qqbot", "data", "known-targets.json");
+var LEGACY_KNOWN_TARGETS_PATH = join(homedir(), ".openclaw", "data", "qqbot", "known-targets.json");
 function resolveKnownTargetsFilePath(options) {
   return options?.filePath?.trim() || DEFAULT_KNOWN_TARGETS_PATH;
 }
 function ensureKnownTargetsDir(filePath) {
   mkdirSync(dirname(filePath), { recursive: true });
 }
+function migrateLegacyKnownTargets(filePath) {
+  if (filePath !== DEFAULT_KNOWN_TARGETS_PATH) {
+    return;
+  }
+  if (existsSync(filePath) || !existsSync(LEGACY_KNOWN_TARGETS_PATH)) {
+    return;
+  }
+  ensureKnownTargetsDir(filePath);
+  try {
+    renameSync(LEGACY_KNOWN_TARGETS_PATH, filePath);
+  } catch {
+    copyFileSync(LEGACY_KNOWN_TARGETS_PATH, filePath);
+    rmSync(LEGACY_KNOWN_TARGETS_PATH, { force: true });
+  }
+}
 function compareTargetsByLastSeenDesc(a, b) {
   if (b.lastSeenAt !== a.lastSeenAt) {
     return b.lastSeenAt - a.lastSeenAt;
@@ -8569,6 +9018,7 @@ function parseKnownTargets(raw, filePath) {
 }
 function readKnownTargets(options) {
   const filePath = resolveKnownTargetsFilePath(options);
+  migrateLegacyKnownTargets(filePath);
   if (!existsSync(filePath)) {
     return [];
   }
@@ -8580,6 +9030,7 @@ function readKnownTargets(options) {
 }
 function writeKnownTargets(targets, options) {
   const filePath = resolveKnownTargetsFilePath(options);
+  migrateLegacyKnownTargets(filePath);
   if (targets.length === 0) {
     if (existsSync(filePath)) {
       rmSync(filePath, { force: true });
@@ -8713,84 +9164,433 @@ 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) {
+    return effectiveSessionKey;
+  }
+  return route.sessionKey;
+}
 function buildSessionDispatchQueueKey(route) {
   const accountId = route.accountId?.trim() || DEFAULT_ACCOUNT_ID;
-  return `${accountId}:${route.sessionKey}`;
+  return `${accountId}:${resolveQQBotRouteSessionKey(route)}`;
 }
-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);
+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 {
-    return await run;
+    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 {
-    if (sessionDispatchQueue.get(queueKey) === cleanup) {
-      sessionDispatchQueue.delete(queueKey);
+    state.processing = false;
+    if (state.queue.length > 0) {
+      void processSerializedSessionDispatchQueue(queueKey);
+      return;
     }
+    cleanupSessionDispatchState(queueKey, state);
   }
 }
-function toString(value) {
-  if (typeof value === "string" && value.trim()) return value;
-  return void 0;
-}
-function toNumber2(value) {
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  if (typeof value === "string") {
-    const parsed = Date.parse(value);
-    if (!Number.isNaN(parsed)) return parsed;
+function dropQueuedSessionDispatches(queueKey) {
+  const state = sessionDispatchQueue.get(queueKey);
+  if (!state || state.queue.length === 0) {
+    return 0;
   }
-  return void 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 toNonNegativeNumber(value) {
-  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
-  if (value < 0) return void 0;
-  return value;
+function markSessionDispatchAbort(queueKey) {
+  const state = getSessionDispatchState(queueKey);
+  state.abortGeneration += 1;
+  signalSessionDispatchState(state);
+  return state.abortGeneration;
 }
-function normalizeAttachmentUrl(value) {
-  if (typeof value !== "string") return void 0;
+function normalizeQQBotSessionKeyPart(value) {
   const trimmed = value.trim();
-  if (!trimmed) return void 0;
-  if (trimmed.startsWith("//")) return `https:${trimmed}`;
-  return trimmed;
+  return trimmed ? trimmed.toLowerCase() : "unknown";
 }
-function parseAttachments(payload) {
-  const raw = payload.attachments;
-  if (!Array.isArray(raw)) return [];
-  const items = [];
-  for (const entry of raw) {
-    if (!entry || typeof entry !== "object") continue;
-    const data = entry;
-    const url = normalizeAttachmentUrl(data.url);
-    if (!url) continue;
-    items.push({
-      url,
-      filename: toString(data.filename),
-      contentType: toString(data.content_type),
-      size: toNonNegativeNumber(data.size)
-    });
+function buildQQBotDirectSessionKey(params) {
+  const normalizedAccountId = normalizeQQBotSessionKeyPart(params.accountId);
+  const normalizedSenderId = normalizeQQBotSessionKeyPart(params.senderStableId);
+  const trimmedRouteSessionKey = params.routeSessionKey.trim();
+  if (!trimmedRouteSessionKey) {
+    return `agent:main:qqbot:dm:${normalizedAccountId}:${normalizedSenderId}`;
   }
-  return items;
-}
-function parseTextWithAttachments(payload) {
-  const rawContent = typeof payload.content === "string" ? payload.content : "";
-  const attachments = parseAttachments(payload);
-  return {
-    text: rawContent.trim(),
-    attachments
-  };
+  const qqAgentRouteMatch = trimmedRouteSessionKey.match(/^(agent:[^:]+:qqbot:)(?:direct|dm):.+$/i);
+  if (qqAgentRouteMatch?.[1]) {
+    return `${qqAgentRouteMatch[1]}dm:${normalizedAccountId}:${normalizedSenderId}`;
+  }
+  return `${trimmedRouteSessionKey}:dm:${normalizedAccountId}:${normalizedSenderId}`;
 }
-function resolveEventId(payload, fallbackEventId) {
-  return toString(payload.event_id) ?? toString(payload.eventId) ?? toString(fallbackEventId);
+function normalizeQQBotReplyTarget(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  let trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  if (/^qqbot:/i.test(trimmed)) {
+    trimmed = trimmed.slice("qqbot:".length).trim();
+  }
+  if (/^c2c:/i.test(trimmed)) {
+    const openid = trimmed.slice("c2c:".length).trim();
+    return openid ? `user:${openid}` : void 0;
+  }
+  return /^(user|group|channel):/i.test(trimmed) ? trimmed : void 0;
 }
-var VOICE_ASR_FALLBACK_TEXT = "\u5F53\u524D\u8BED\u97F3\u529F\u80FD\u672A\u542F\u52A8\u6216\u8BC6\u522B\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002";
-var VOICE_EXTENSIONS = [".silk", ".amr", ".mp3", ".wav", ".ogg", ".m4a", ".aac", ".speex"];
-var VOICE_ASR_ERROR_MAX_LENGTH = 500;
-var LONG_TASK_NOTICE_TEXT = "\u4EFB\u52A1\u5904\u7406\u65F6\u95F4\u8F83\u957F\uFF0C\u8BF7\u7A0D\u7B49\uFF0C\u6211\u8FD8\u5728\u7EE7\u7EED\u5904\u7406\u3002";
-var DEFAULT_LONG_TASK_NOTICE_DELAY_MS = 3e4;
-var QQ_GROUP_NO_REPLY_FALLBACK_TEXT = "\u6211\u5728\u3002\u4F60\u53EF\u4EE5\u76F4\u63A5\u8BF4\u5177\u4F53\u4E00\u70B9\u3002";
-function startLongTaskNoticeTimer(params) {
-  const { delayMs, logger, sendNotice } = params;
+async function runSerializedSessionDispatch(queueKey, task) {
+  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 task();
+  } finally {
+    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") {
+    const parsed = Date.parse(value);
+    if (!Number.isNaN(parsed)) return parsed;
+  }
+  return void 0;
+}
+function toNonNegativeNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+  if (value < 0) return void 0;
+  return value;
+}
+function normalizeAttachmentUrl(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  if (trimmed.startsWith("//")) return `https:${trimmed}`;
+  return trimmed;
+}
+function parseAttachments(payload) {
+  const raw = payload.attachments;
+  if (!Array.isArray(raw)) return [];
+  const items = [];
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object") continue;
+    const data = entry;
+    const url = normalizeAttachmentUrl(data.url);
+    if (!url) continue;
+    items.push({
+      url,
+      filename: toString(data.filename),
+      contentType: toString(data.content_type),
+      size: toNonNegativeNumber(data.size)
+    });
+  }
+  return items;
+}
+function parseTextWithAttachments(payload) {
+  const rawContent = typeof payload.content === "string" ? payload.content : "";
+  const attachments = parseAttachments(payload);
+  return {
+    text: rawContent.trim(),
+    attachments
+  };
+}
+function parseQQBotRefIndices(payload) {
+  const scene = payload.message_scene;
+  if (!scene || typeof scene !== "object") {
+    return {};
+  }
+  const ext = scene.ext;
+  if (!Array.isArray(ext)) {
+    return {};
+  }
+  let refMsgIdx;
+  let msgIdx;
+  for (const value of ext) {
+    const item = toString(value);
+    if (!item) continue;
+    if (item.startsWith("ref_msg_idx=")) {
+      refMsgIdx = toString(item.slice("ref_msg_idx=".length));
+      continue;
+    }
+    if (item.startsWith("msg_idx=")) {
+      msgIdx = toString(item.slice("msg_idx=".length));
+    }
+  }
+  return {
+    ...refMsgIdx ? { refMsgIdx } : {},
+    ...msgIdx ? { msgIdx } : {}
+  };
+}
+function resolveEventId(payload, fallbackEventId) {
+  return toString(payload.event_id) ?? toString(payload.eventId) ?? toString(fallbackEventId);
+}
+var VOICE_ASR_FALLBACK_TEXT = "\u5F53\u524D\u8BED\u97F3\u529F\u80FD\u672A\u542F\u52A8\u6216\u8BC6\u522B\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002";
+var VOICE_EXTENSIONS = [".silk", ".amr", ".mp3", ".wav", ".ogg", ".m4a", ".aac", ".speex"];
+var VOICE_ASR_ERROR_MAX_LENGTH = 500;
+var LONG_TASK_NOTICE_TEXT = "\u4EFB\u52A1\u5904\u7406\u65F6\u95F4\u8F83\u957F\uFF0C\u8BF7\u7A0D\u7B49\uFF0C\u6211\u8FD8\u5728\u7EE7\u7EED\u5904\u7406\u3002";
+var DEFAULT_LONG_TASK_NOTICE_DELAY_MS = 3e4;
+var QQ_GROUP_NO_REPLY_FALLBACK_TEXT = "\u6211\u5728\u3002\u4F60\u53EF\u4EE5\u76F4\u63A5\u8BF4\u5177\u4F53\u4E00\u70B9\u3002";
+var QQ_QUOTE_BODY_UNAVAILABLE_TEXT = "\u539F\u59CB\u5185\u5BB9\u4E0D\u53EF\u7528";
+function startLongTaskNoticeTimer(params) {
+  const { delayMs, logger, sendNotice } = params;
   let completed = false;
   let timer = null;
   const clear = () => {
@@ -8823,7 +9623,7 @@ function startLongTaskNoticeTimer(params) {
     }
   };
 }
-function isHttpUrl2(value) {
+function isHttpUrl3(value) {
   return /^https?:\/\//i.test(value);
 }
 function isImageAttachment(att) {
@@ -8896,7 +9696,7 @@ async function resolveInboundAttachmentsForAgent(params) {
   let asrErrorMessage;
   for (const att of list) {
     const next = { attachment: att };
-    if (isImageAttachment(att) && isHttpUrl2(att.url)) {
+    if (isImageAttachment(att) && isHttpUrl3(att.url)) {
       try {
         const downloaded = await downloadToTempFile(att.url, {
           timeout,
@@ -8925,7 +9725,7 @@ async function resolveInboundAttachmentsForAgent(params) {
         logger.info("voice attachment received but ASR is disabled");
       } else if (!asrCredentials) {
         logger.warn("voice ASR enabled but credentials are missing or invalid");
-      } else if (!isHttpUrl2(att.url)) {
+      } else if (!isHttpUrl3(att.url)) {
         logger.warn("voice ASR skipped: attachment URL is not an HTTP URL");
       } else {
         try {
@@ -8996,6 +9796,74 @@ function buildInboundContentWithAttachments(params) {
   parts.push(block);
   return parts.join("\n\n");
 }
+function resolveRefAttachmentType(attachment) {
+  const contentType = attachment.contentType?.trim().toLowerCase() ?? "";
+  if (contentType.startsWith("image/") || isImageAttachment(attachment)) {
+    return "image";
+  }
+  if (contentType === "voice" || contentType.startsWith("audio/") || isVoiceAttachment(attachment)) {
+    return "voice";
+  }
+  if (contentType.startsWith("video/")) {
+    return "video";
+  }
+  const mediaType = detectMediaType(attachment.filename?.trim() || attachment.url);
+  if (mediaType === "image") return "image";
+  if (mediaType === "audio") return "voice";
+  if (mediaType === "video") return "video";
+  if (mediaType === "file") return "file";
+  return "unknown";
+}
+function buildInboundRefAttachmentSummaries(attachments) {
+  if (attachments.length === 0) {
+    return void 0;
+  }
+  return attachments.map((item) => ({
+    type: resolveRefAttachmentType(item.attachment),
+    ...item.attachment.filename?.trim() ? { filename: item.attachment.filename.trim() } : {},
+    ...item.attachment.contentType?.trim() ? { contentType: item.attachment.contentType.trim() } : {},
+    ...item.localImagePath?.trim() ? { localPath: item.localImagePath.trim() } : {},
+    ...item.attachment.url?.trim() ? { url: item.attachment.url.trim() } : {},
+    ...item.voiceTranscript?.trim() ? {
+      transcript: item.voiceTranscript.trim(),
+      transcriptSource: "asr"
+    } : {}
+  }));
+}
+function buildQuotedAgentBody(params) {
+  const quoteBlock = `[\u5F15\u7528\u6D88\u606F\u5F00\u59CB]
+${params.replyToBody}
+[\u5F15\u7528\u6D88\u606F\u7ED3\u675F]`;
+  return params.baseBody ? `${quoteBlock}
+
+${params.baseBody}` : quoteBlock;
+}
+function resolveAgentBodyBase(ctx) {
+  if (typeof ctx.BodyForAgent === "string" && ctx.BodyForAgent.trim()) {
+    return ctx.BodyForAgent;
+  }
+  if (typeof ctx.RawBody === "string" && ctx.RawBody.trim()) {
+    return ctx.RawBody;
+  }
+  if (typeof ctx.Body === "string" && ctx.Body.trim()) {
+    return ctx.Body;
+  }
+  if (typeof ctx.CommandBody === "string" && ctx.CommandBody.trim()) {
+    return ctx.CommandBody;
+  }
+  return "";
+}
+function uniqueRefIndexKeys(...values) {
+  const keys = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    const next = value?.trim();
+    if (!next || seen.has(next)) continue;
+    seen.add(next);
+    keys.push(next);
+  }
+  return keys;
+}
 function resolveInboundLogContent(params) {
   const text = params.content.trim();
   if (text) return text;
@@ -9017,22 +9885,23 @@ function sanitizeInboundLogText(text) {
 function parseC2CMessage(data, fallbackEventId) {
   const payload = data;
   const { text, attachments } = parseTextWithAttachments(payload);
+  const refIndices = parseQQBotRefIndices(payload);
   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,
     eventId,
     timestamp,
+    ...refIndices,
     mentionedBot: false
   };
 }
@@ -9043,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,
@@ -9067,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,
@@ -9091,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,
@@ -9146,6 +10012,22 @@ function resolveChatTarget(event) {
     peerKind: "dm"
   };
 }
+function resolveQQBotEffectiveSessionKey(params) {
+  const { inbound, route, accountId } = params;
+  if (inbound.type !== "direct") {
+    return route.sessionKey;
+  }
+  const senderStableId = inbound.c2cOpenid?.trim() || inbound.senderId?.trim();
+  if (!senderStableId) {
+    return route.sessionKey;
+  }
+  const resolvedAccountId = route.accountId?.trim() || accountId.trim() || DEFAULT_ACCOUNT_ID;
+  return buildQQBotDirectSessionKey({
+    routeSessionKey: route.sessionKey,
+    accountId: resolvedAccountId,
+    senderStableId
+  });
+}
 function resolveEnvelopeFrom(event) {
   if (event.type === "group") {
     return `group:${(event.groupOpenid ?? "unknown").toLowerCase()}`;
@@ -9156,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;
@@ -9165,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
@@ -9176,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
@@ -9187,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
@@ -9302,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) {
@@ -9370,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 = [];
@@ -9453,36 +10344,619 @@ function normalizeQQBotRenderedMarkdown(text) {
       if (!normalizedInner) {
         return block;
       }
-      changed = true;
-      return `${leadingLineBreak}${normalizedInner}`;
+      changed = true;
+      return `${leadingLineBreak}${normalizedInner}`;
+    }
+  );
+  next = next.replace(
+    GENERIC_MARKDOWN_FENCE_RE,
+    (block, leadingLineBreak, _fence, inner) => {
+      const normalizedInner = inner.trim();
+      if (!normalizedInner) {
+        return block;
+      }
+      if (!hasQQBotMarkdownTable(normalizedInner)) {
+        return block;
+      }
+      changed = true;
+      return `${leadingLineBreak}${normalizedInner}`;
+    }
+  );
+  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);
     }
-  );
-  next = next.replace(
-    GENERIC_MARKDOWN_FENCE_RE,
-    (block, leadingLineBreak, _fence, inner) => {
-      const normalizedInner = inner.trim();
-      if (!normalizedInner) {
-        return block;
+  };
+  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();
       }
-      if (!hasQQBotMarkdownTable(normalizedInner)) {
-        return block;
+      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;
+          }
+        }
       }
-      changed = true;
-      return `${leadingLineBreak}${normalizedInner}`;
+      appendPiece(headingText);
+      continue;
     }
-  );
-  return changed ? next.trim() : text.trim();
+    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, logger, onDelivered, onError } = 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,
       mediaUrl,
       replyToId,
-      replyEventId
+      replyEventId,
+      accountId
     });
     if (result.error) {
       logger.error(`sendMedia failed: ${result.error}`);
@@ -9491,12 +10965,16 @@ async function sendQQBotMediaWithFallback(params) {
       if (!fallback) {
         continue;
       }
+      if (!shouldContinue()) {
+        return;
+      }
       const fallbackResult = await outbound.sendText({
         cfg: { channels: { qqbot: qqCfg } },
         to,
         text: fallback,
         replyToId,
-        replyEventId
+        replyEventId,
+        accountId
       });
       if (fallbackResult.error) {
         logger.error(`sendText fallback failed: ${fallbackResult.error}`);
@@ -9541,17 +11019,30 @@ function buildInboundContext(params) {
 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);
-  if (inbound.c2cOpenid) {
+  const outboundAccountId = route.accountId ?? accountId;
+  let typingRefIdx;
+  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: 60,
+      accountId: outboundAccountId
     });
     if (typing.error) {
       logger.warn(`sendTyping failed: ${typing.error}`);
+    } else {
+      typingRefIdx = typing.refIdx;
     }
   }
   const replyApi = runtime2.channel?.reply;
@@ -9576,13 +11067,14 @@ 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,
         text: LONG_TASK_NOTICE_TEXT,
         replyToId: inbound.messageId,
-        replyEventId: inbound.eventId
+        replyEventId: inbound.eventId,
+        accountId: outboundAccountId
       });
       if (result.error) {
         logger.warn(`send long-task notice failed: ${result.error}`);
@@ -9602,19 +11094,23 @@ async function dispatchToAgent(params) {
       { agentId: route.agentId }
     );
     const envelopeOptions = replyApi.resolveEnvelopeFormatOptions?.(cfg);
-    const previousTimestamp = storePath && sessionApi?.readSessionUpdatedAt ? sessionApi.readSessionUpdatedAt({ storePath, sessionKey: route.sessionKey }) : null;
+    const previousTimestamp = storePath && sessionApi?.readSessionUpdatedAt ? sessionApi.readSessionUpdatedAt({ storePath, sessionKey: routeSessionKey }) : null;
     const resolvedAttachmentResult = await resolveInboundAttachmentsForAgent({
       attachments: inbound.attachments,
       qqCfg,
       logger
     });
     if (qqCfg.asr?.enabled && resolvedAttachmentResult.hasVoiceAttachment && !resolvedAttachmentResult.hasVoiceTranscript) {
+      if (shouldSuppressVisibleReplies()) {
+        return;
+      }
       const fallback = await qqbotOutbound.sendText({
         cfg: { channels: { qqbot: qqCfg } },
         to: target.to,
         text: buildVoiceASRFallbackReply(resolvedAttachmentResult.asrErrorMessage),
         replyToId: inbound.messageId,
-        replyEventId: inbound.eventId
+        replyEventId: inbound.eventId,
+        accountId: outboundAccountId
       });
       if (fallback.error) {
         logger.error(`sendText ASR fallback failed: ${fallback.error}`);
@@ -9629,6 +11125,39 @@ async function dispatchToAgent(params) {
     if (localImageCount > 0) {
       logger.info(`prepared ${localImageCount} local image attachment(s) for agent`);
     }
+    let replyToId;
+    let replyToBody;
+    let replyToSender;
+    let replyToIsQuote = false;
+    if (inbound.c2cOpenid && inbound.refMsgIdx) {
+      replyToId = inbound.refMsgIdx;
+      replyToIsQuote = true;
+      const refEntry = getRefIndex(inbound.refMsgIdx);
+      if (refEntry) {
+        replyToBody = formatRefEntryForAgent(refEntry);
+        replyToSender = refEntry.senderName ?? refEntry.senderId;
+        logger.info(`quote context resolved refMsgIdx=${inbound.refMsgIdx}`);
+      } else {
+        replyToBody = QQ_QUOTE_BODY_UNAVAILABLE_TEXT;
+        logger.warn(`quote context missing refMsgIdx=${inbound.refMsgIdx}`);
+      }
+    }
+    const refAttachmentSummaries = buildInboundRefAttachmentSummaries(resolvedAttachments);
+    const currentRefIndexKeys = inbound.c2cOpenid ? uniqueRefIndexKeys(inbound.msgIdx, typingRefIdx) : [];
+    if (currentRefIndexKeys.length > 0) {
+      for (const currentRefIndexKey of currentRefIndexKeys) {
+        setRefIndex(currentRefIndexKey, {
+          content: inbound.content,
+          senderId: inbound.senderId,
+          ...inbound.senderName ? { senderName: inbound.senderName } : {},
+          timestamp: inbound.timestamp,
+          ...refAttachmentSummaries ? { attachments: refAttachmentSummaries } : {}
+        });
+      }
+      logger.info(
+        `cached inbound ref_idx keys=${currentRefIndexKeys.join(",")} msgIdx=${inbound.msgIdx ?? "-"} typingRefIdx=${typingRefIdx ?? "-"}`
+      );
+    }
     const rawBody = buildInboundContentWithAttachments({
       content: inbound.content,
       attachments: resolvedAttachments
@@ -9654,51 +11183,73 @@ async function dispatchToAgent(params) {
     }) : rawBody;
     const inboundCtx = buildInboundContext({
       event: inbound,
-      sessionKey: route.sessionKey,
-      accountId: route.accountId ?? accountId,
+      sessionKey: routeSessionKey,
+      accountId: outboundAccountId,
       body: inboundBody,
       rawBody,
       commandBody: rawBody
     });
     const finalizeInboundContext = replyApi?.finalizeInboundContext;
     const finalCtx = finalizeInboundContext ? finalizeInboundContext(inboundCtx) : inboundCtx;
-    let cronBase = "";
-    if (typeof finalCtx.RawBody === "string" && finalCtx.RawBody) {
-      cronBase = finalCtx.RawBody;
-    } else if (typeof finalCtx.Body === "string" && finalCtx.Body) {
-      cronBase = finalCtx.Body;
-    } else if (typeof finalCtx.CommandBody === "string" && finalCtx.CommandBody) {
-      cronBase = finalCtx.CommandBody;
-    }
-    if (cronBase) {
-      const nextCron = appendCronHiddenPrompt(cronBase);
-      if (nextCron !== cronBase) {
-        finalCtx.BodyForAgent = nextCron;
-      }
-    }
-    if (storePath && sessionApi?.recordInboundSession) {
-      try {
-        const mainSessionKeyRaw = route?.mainSessionKey;
-        const mainSessionKey = typeof mainSessionKeyRaw === "string" && mainSessionKeyRaw.trim() ? mainSessionKeyRaw : void 0;
-        const isGroup = inbound.type === "group" || inbound.type === "channel";
-        const updateLastRoute = !isGroup ? {
-          sessionKey: mainSessionKey ?? route.sessionKey,
-          channel: "qqbot",
-          to: finalCtx.OriginatingTo ?? finalCtx.To ?? `user:${inbound.senderId}`,
-          accountId: route.accountId ?? accountId
-        } : void 0;
-        const recordSessionKey = typeof finalCtx.SessionKey === "string" && finalCtx.SessionKey.trim() ? finalCtx.SessionKey : route.sessionKey;
-        await sessionApi.recordInboundSession({
-          storePath,
-          sessionKey: recordSessionKey,
-          ctx: finalCtx,
-          updateLastRoute,
-          onRecordError: (err) => {
-            logger.warn(`failed to record inbound session: ${String(err)}`);
-          }
+    const ctxTo = normalizeQQBotReplyTarget(finalCtx.To);
+    const ctxOriginatingTo = normalizeQQBotReplyTarget(finalCtx.OriginatingTo);
+    const stableTo = ctxOriginatingTo ?? ctxTo ?? target.to;
+    finalCtx.To = stableTo;
+    finalCtx.OriginatingTo = stableTo;
+    if (replyToId) {
+      finalCtx.ReplyToId = replyToId;
+      finalCtx.ReplyToBody = replyToBody;
+      finalCtx.ReplyToSender = replyToSender;
+      finalCtx.ReplyToIsQuote = replyToIsQuote;
+    }
+    const isSlashCommand = typeof finalCtx.CommandBody === "string" ? finalCtx.CommandBody.trim().startsWith("/") : typeof finalCtx.RawBody === "string" ? finalCtx.RawBody.trim().startsWith("/") : false;
+    if (!isSlashCommand) {
+      let agentBody = resolveAgentBodyBase(finalCtx);
+      if (replyToIsQuote && replyToBody && replyToBody !== QQ_QUOTE_BODY_UNAVAILABLE_TEXT) {
+        agentBody = buildQuotedAgentBody({
+          baseBody: agentBody,
+          replyToBody
         });
-      } catch (err) {
-        logger.warn(`failed to record inbound session: ${String(err)}`);
+      }
+      finalCtx.BodyForAgent = appendCronHiddenPrompt(agentBody);
+    }
+    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;
@@ -9711,7 +11262,7 @@ async function dispatchToAgent(params) {
     const tableMode = textApi?.resolveMarkdownTableMode?.({
       cfg,
       channel: "qqbot",
-      accountId: route.accountId ?? accountId
+      accountId: outboundAccountId
     });
     const resolvedTableMode = tableMode ?? "bullets";
     const chunkText = (text) => {
@@ -9726,90 +11277,124 @@ 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;
       bufferedC2CMarkdownMediaSeen.add(next);
       bufferedC2CMarkdownMediaUrls.push(next);
     };
-    const flushBufferedC2CMarkdownReply = async () => {
-      if (!useC2CMarkdownTransport || bufferedC2CMarkdownTexts.length === 0 && bufferedC2CMarkdownMediaUrls.length === 0) {
-        bufferedC2CMarkdownTexts = [];
-        bufferedC2CMarkdownMediaUrls = [];
-        bufferedC2CMarkdownMediaSeen.clear();
+    const sendC2CMarkdownTransportPayload = async (params2) => {
+      if (shouldSuppressVisibleReplies()) {
         return;
       }
-      const combinedText = bufferedC2CMarkdownTexts.join("\n\n").trim();
-      const combinedMediaUrls = [...bufferedC2CMarkdownMediaUrls];
-      bufferedC2CMarkdownTexts = [];
-      bufferedC2CMarkdownMediaUrls = [];
-      bufferedC2CMarkdownMediaSeen.clear();
-      const normalizedCombinedText = normalizeQQBotRenderedMarkdown(combinedText);
-      const { markdownImageUrls, mediaQueue } = splitQQBotMarkdownTransportMediaUrls(combinedMediaUrls);
+      const normalizedText = normalizeQQBotRenderedMarkdown(params2.text);
+      const { markdownImageUrls, mediaQueue } = splitQQBotMarkdownTransportMediaUrls(params2.mediaUrls);
       const finalMarkdownText = await normalizeQQBotMarkdownImages({
-        text: normalizedCombinedText,
+        text: normalizedText,
         appendImageUrls: markdownImageUrls
       });
+      if (shouldSuppressVisibleReplies()) {
+        return;
+      }
       const textReplyRefs = resolveQQBotTextReplyRefs({
         to: target.to,
-        text: finalMarkdownText || normalizedCombinedText,
+        text: finalMarkdownText || normalizedText,
         markdownSupport,
         c2cMarkdownDeliveryMode,
         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"} 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,
-        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} preview=${formatQQBotOutboundPreview(chunk)}`
-          );
-          const result = await qqbotOutbound.sendText({
-            cfg: { channels: { qqbot: qqCfg } },
-            to: target.to,
-            text: chunk,
-            replyToId: textReplyRefs.replyToId,
-            replyEventId: textReplyRefs.replyEventId
-          });
-          if (result.error) {
-            logger.error(`send buffered QQ markdown reply failed: ${result.error}`);
-            markGroupMessageInterfaceBlocked(result.error);
-          } else {
-            logger.info(`sent buffered QQ markdown reply (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();
         }
       }
     };
+    const flushBufferedC2CMarkdownReply = async () => {
+      if (!useC2CMarkdownTransport || bufferedC2CMarkdownTexts.length === 0 && bufferedC2CMarkdownMediaUrls.length === 0) {
+        bufferedC2CMarkdownTexts = [];
+        bufferedC2CMarkdownMediaUrls = [];
+        bufferedC2CMarkdownMediaSeen.clear();
+        return;
+      }
+      if (shouldSuppressVisibleReplies()) {
+        bufferedC2CMarkdownTexts = [];
+        bufferedC2CMarkdownMediaUrls = [];
+        bufferedC2CMarkdownMediaSeen.clear();
+        return;
+      }
+      const combinedText = bufferedC2CMarkdownTexts.join("\n\n").trim();
+      const combinedMediaUrls = [...bufferedC2CMarkdownMediaUrls];
+      bufferedC2CMarkdownTexts = [];
+      bufferedC2CMarkdownMediaUrls = [];
+      bufferedC2CMarkdownMediaSeen.clear();
+      await sendC2CMarkdownTransportPayload({
+        text: combinedText,
+        mediaUrls: combinedMediaUrls,
+        phase: "buffered"
+      });
+    };
     const deliver = async (payload, info) => {
+      if (shouldSuppressVisibleReplies()) {
+        return;
+      }
       const typed = payload;
       const extractedTextMedia = extractQQBotReplyMedia({
         text: typed?.text ?? "",
@@ -9840,12 +11425,28 @@ async function dispatchToAgent(params) {
       const suppressText = deliveryDecision.suppressText || suppressEchoText;
       const textToSend = suppressText ? "" : cleanedText;
       if (useC2CMarkdownTransport) {
-        if (textToSend) {
-          bufferedC2CMarkdownTexts = appendQQBotBufferedText(bufferedC2CMarkdownTexts, textToSend);
+        const shouldBufferFinalOnlyPayload = replyFinalOnly && (!info?.kind || info.kind === "final");
+        const shouldBufferStructuredMarkdownPayload = !replyFinalOnly && c2cMarkdownChunkStrategy === "markdown-block" && info?.kind !== "tool" && looksLikeStructuredMarkdown(textToSend);
+        if (shouldBufferFinalOnlyPayload || shouldBufferStructuredMarkdownPayload) {
+          if (textToSend) {
+            bufferedC2CMarkdownTexts = appendQQBotBufferedText(bufferedC2CMarkdownTexts, textToSend);
+          }
+          for (const url of mediaQueue) {
+            bufferC2CMarkdownMedia(url);
+          }
+          return;
         }
-        for (const url of mediaQueue) {
-          bufferC2CMarkdownMedia(url);
+        if (hasBufferedC2CMarkdownReply()) {
+          await flushBufferedC2CMarkdownReply();
+          if (shouldSuppressVisibleReplies()) {
+            return;
+          }
         }
+        await sendC2CMarkdownTransportPayload({
+          text: textToSend,
+          mediaUrls: mediaQueue,
+          phase: "immediate"
+        });
         return;
       }
       if (textToSend) {
@@ -9860,12 +11461,16 @@ 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,
             text: chunk,
             replyToId: textReplyRefs.replyToId,
-            replyEventId: textReplyRefs.replyEventId
+            replyEventId: textReplyRefs.replyEventId,
+            accountId: outboundAccountId
           });
           if (result.error) {
             logger.error(`sendText failed: ${result.error}`);
@@ -9875,24 +11480,54 @@ async function dispatchToAgent(params) {
           }
         }
       }
+      if (shouldSuppressVisibleReplies()) {
+        return;
+      }
       await sendQQBotMediaWithFallback({
         qqCfg,
         to: target.to,
         mediaQueue,
         replyToId: inbound.messageId,
         replyEventId: inbound.eventId,
+        accountId: outboundAccountId,
         logger,
         onDelivered: () => {
           markReplyDelivered();
         },
         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,
@@ -9907,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,
@@ -9936,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();
@@ -9945,14 +11585,15 @@ 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 } },
         to: target.to,
         text: noReplyFallback,
         replyToId: inbound.messageId,
-        replyEventId: inbound.eventId
+        replyEventId: inbound.eventId,
+        accountId: outboundAccountId
       });
       if (fallbackResult.error) {
         logger.error(`sendText no-reply fallback failed: ${fallbackResult.error}`);
@@ -10018,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 });
@@ -10037,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)`);
   }
@@ -10050,26 +11712,59 @@ 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",
     accountId,
     peer: { kind: target.peerKind, id: target.peerId }
   });
-  const queueKey = buildSessionDispatchQueueKey(route);
-  if (sessionDispatchQueue.has(queueKey)) {
-    logger.info(`session busy; queueing inbound dispatch sessionKey=${route.sessionKey}`);
+  const effectiveSessionKey = resolveQQBotEffectiveSessionKey({
+    inbound: resolvedInbound,
+    route,
+    accountId
+  });
+  const resolvedRoute = effectiveSessionKey === route.sessionKey ? route : {
+    ...route,
+    mainSessionKey: route.mainSessionKey?.trim() || route.sessionKey,
+    effectiveSessionKey
+  };
+  const queueKey = buildSessionDispatchQueueKey(resolvedRoute);
+  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,
       logger,
-      route
+      route: resolvedRoute
     })
   );
 }
@@ -10092,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);
@@ -10121,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 {
@@ -10132,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;
@@ -10139,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;
@@ -10153,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();
@@ -10174,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: {
@@ -10209,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: {
@@ -10221,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: {
@@ -10233,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);
           }
@@ -10244,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: {
@@ -10259,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;
           }
@@ -10287,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");
         });
@@ -10308,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) {
@@ -10335,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);
@@ -10372,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 = {
@@ -10381,7 +12113,7 @@ var qqbotPlugin = {
     ...meta
   },
   capabilities: {
-    chatTypes: ["direct", "channel"],
+    chatTypes: ["direct", "group", "channel"],
     media: true,
     reactions: false,
     threads: false,
@@ -10450,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,
@@ -10465,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" },
@@ -10495,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,
@@ -10510,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" },
@@ -10661,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);
         }
       }
@@ -10697,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,
@@ -10712,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" },
@@ -10742,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,
@@ -10757,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" },