@openclaw-china/qqbot 2026.3.10 → 2026.3.12

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';
@@ -14,6 +14,7 @@ import 'util';
 import { createRequire } from 'module';
 import { execFileSync } from 'child_process';
 import WebSocket from 'ws';
+import { Buffer as Buffer$1 } from 'buffer';
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -650,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
@@ -767,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() {
@@ -4222,6 +4223,7 @@ var optionalCoercedString = 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 QQBotAccountSchema = external_exports.object({
   name: external_exports.string().optional(),
   enabled: external_exports.boolean().optional(),
@@ -4234,6 +4236,7 @@ var QQBotAccountSchema = external_exports.object({
     secretKey: optionalCoercedString
   }).optional(),
   markdownSupport: external_exports.boolean().optional().default(true),
+  c2cMarkdownDeliveryMode: QQBotC2CMarkdownDeliveryModeSchema,
   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),
@@ -4873,7 +4876,7 @@ function extractMediaFromText(text, options = {}) {
   const {
     removeFromText = true,
     checkExists = false,
-    existsSync: existsSync6,
+    existsSync: existsSync7,
     parseMediaLines = false,
     parseMarkdownImages = true,
     parseHtmlImages = true,
@@ -4888,7 +4891,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);
@@ -7255,9 +7258,11 @@ function showChinaInstallHint(api) {
 var API_BASE = "https://api.sgroup.qq.com";
 var TOKEN_URL = "https://bots.qq.com/app/getAppAccessToken";
 var MSG_SEQ_BASE = 1e6;
+var MAX_DUPLICATE_MSG_SEQ_RETRIES = 5;
 var tokenCacheMap = /* @__PURE__ */ new Map();
 var tokenPromiseMap = /* @__PURE__ */ new Map();
 var msgSeqMap = /* @__PURE__ */ new Map();
+var fallbackMsgSeq = 0;
 function toTrimmedString3(value) {
   if (value === void 0 || value === null) return void 0;
   const next = String(value).trim();
@@ -7277,7 +7282,10 @@ function sanitizeUploadFileName(fileName) {
   return normalized || "file";
 }
 function nextMsgSeq(sequenceKey) {
-  if (!sequenceKey) return MSG_SEQ_BASE + 1;
+  if (!sequenceKey) {
+    fallbackMsgSeq += 1;
+    return MSG_SEQ_BASE + fallbackMsgSeq;
+  }
   const current = msgSeqMap.get(sequenceKey) ?? 0;
   const next = current + 1;
   msgSeqMap.set(sequenceKey, next);
@@ -7289,6 +7297,46 @@ function nextMsgSeq(sequenceKey) {
   }
   return MSG_SEQ_BASE + next;
 }
+function resolveMsgSeqKey(messageId, eventId) {
+  if (messageId) return `msg:${messageId}`;
+  if (eventId) return `event:${eventId}`;
+  return void 0;
+}
+function isDuplicateMsgSeqError(err) {
+  if (!(err instanceof HttpError) || err.status !== 400) {
+    return false;
+  }
+  const body = err.body?.trim();
+  if (!body) {
+    return false;
+  }
+  try {
+    const parsed = JSON.parse(body);
+    if (parsed.code === 40054005 || parsed.err_code === 40054005) {
+      return true;
+    }
+    const message = typeof parsed.message === "string" ? parsed.message.toLowerCase() : "";
+    return message.includes("msgseq") && (message.includes("\u53BB\u91CD") || message.includes("duplicate"));
+  } catch {
+    const lowered = body.toLowerCase();
+    return lowered.includes("msgseq") && (lowered.includes("\u53BB\u91CD") || lowered.includes("duplicate"));
+  }
+}
+async function postPassiveMessage(params) {
+  let lastError;
+  for (let attempt = 0; attempt <= MAX_DUPLICATE_MSG_SEQ_RETRIES; attempt += 1) {
+    const msgSeq = nextMsgSeq(params.sequenceKey);
+    try {
+      return await apiPost(params.accessToken, params.path, params.buildBody(msgSeq), params.options);
+    } catch (err) {
+      lastError = err;
+      if (!isDuplicateMsgSeqError(err) || attempt === MAX_DUPLICATE_MSG_SEQ_RETRIES) {
+        throw err;
+      }
+    }
+  }
+  throw lastError;
+}
 function clearTokenCache(appId) {
   const normalizedAppId = toTrimmedString3(appId);
   if (normalizedAppId) {
@@ -7332,8 +7380,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: {
@@ -7342,8 +7390,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: {
@@ -7357,16 +7405,11 @@ async function getGatewayUrl(accessToken) {
   return data.url;
 }
 function buildMessageBody(params) {
-  const msgSeq = nextMsgSeq(params.messageId ?? params.eventId);
-  const body = params.markdown ? {
-    markdown: { content: params.content },
-    msg_type: 2,
-    msg_seq: msgSeq
-  } : {
+  const body = buildTextMessageBody({
     content: params.content,
-    msg_type: 0,
-    msg_seq: msgSeq
-  };
+    markdown: params.markdown
+  });
+  body.msg_seq = params.msgSeq;
   if (params.messageId) {
     body.msg_id = params.messageId;
   } else if (params.eventId) {
@@ -7374,22 +7417,63 @@ function buildMessageBody(params) {
   }
   return body;
 }
+function buildTextMessageBody(params) {
+  return params.markdown ? {
+    markdown: { content: params.content },
+    msg_type: 2
+  } : {
+    content: params.content,
+    msg_type: 0
+  };
+}
+function buildProactiveMessageBody(params) {
+  if (!params.content.trim()) {
+    throw new Error("QQBot proactive message content is empty");
+  }
+  return buildTextMessageBody(params);
+}
 async function sendC2CMessage(params) {
-  const body = buildMessageBody({
+  return postPassiveMessage({
+    accessToken: params.accessToken,
+    path: `/v2/users/${params.openid}/messages`,
+    sequenceKey: resolveMsgSeqKey(params.messageId, params.eventId),
+    options: { timeout: 15e3 },
+    buildBody: (msgSeq) => buildMessageBody({
+      content: params.content,
+      messageId: params.messageId,
+      eventId: params.eventId,
+      markdown: params.markdown,
+      msgSeq
+    })
+  });
+}
+async function sendGroupMessage(params) {
+  return postPassiveMessage({
+    accessToken: params.accessToken,
+    path: `/v2/groups/${params.groupOpenid}/messages`,
+    sequenceKey: resolveMsgSeqKey(params.messageId, params.eventId),
+    options: { timeout: 15e3 },
+    buildBody: (msgSeq) => buildMessageBody({
+      content: params.content,
+      messageId: params.messageId,
+      eventId: params.eventId,
+      markdown: params.markdown,
+      msgSeq
+    })
+  });
+}
+async function sendProactiveC2CMessage(params) {
+  const body = buildProactiveMessageBody({
     content: params.content,
-    messageId: params.messageId,
-    eventId: params.eventId,
     markdown: params.markdown
   });
   return apiPost(params.accessToken, `/v2/users/${params.openid}/messages`, body, {
     timeout: 15e3
   });
 }
-async function sendGroupMessage(params) {
-  const body = buildMessageBody({
+async function sendProactiveGroupMessage(params) {
+  const body = buildProactiveMessageBody({
     content: params.content,
-    messageId: params.messageId,
-    eventId: params.eventId,
     markdown: params.markdown
   });
   return apiPost(params.accessToken, `/v2/groups/${params.groupOpenid}/messages`, body, {
@@ -7406,11 +7490,12 @@ async function sendChannelMessage(params) {
   });
 }
 async function sendC2CInputNotify(params) {
-  const msgSeq = nextMsgSeq(params.messageId ?? params.eventId);
-  await apiPost(
-    params.accessToken,
-    `/v2/users/${params.openid}/messages`,
-    {
+  const response = await postPassiveMessage({
+    accessToken: params.accessToken,
+    path: `/v2/users/${params.openid}/messages`,
+    sequenceKey: resolveMsgSeqKey(params.messageId, params.eventId),
+    options: { timeout: 15e3 },
+    buildBody: (msgSeq) => ({
       msg_type: 6,
       input_notify: {
         input_type: 1,
@@ -7418,9 +7503,10 @@ async function sendC2CInputNotify(params) {
       },
       msg_seq: msgSeq,
       ...params.messageId ? { msg_id: params.messageId } : params.eventId ? { event_id: params.eventId } : {}
-    },
-    { timeout: 15e3 }
-  );
+    })
+  });
+  const refIdx = response.ext_info?.ref_idx?.trim();
+  return refIdx ? { refIdx } : {};
 }
 async function uploadC2CMedia(params) {
   const body = {
@@ -7461,34 +7547,261 @@ async function uploadGroupMedia(params) {
   });
 }
 async function sendC2CMediaMessage(params) {
-  const msgSeq = nextMsgSeq(params.messageId ?? params.eventId);
-  return apiPost(
-    params.accessToken,
-    `/v2/users/${params.openid}/messages`,
-    {
+  return postPassiveMessage({
+    accessToken: params.accessToken,
+    path: `/v2/users/${params.openid}/messages`,
+    sequenceKey: resolveMsgSeqKey(params.messageId, params.eventId),
+    options: { timeout: 15e3 },
+    buildBody: (msgSeq) => ({
       msg_type: 7,
       media: { file_info: params.fileInfo },
       msg_seq: msgSeq,
       ...params.content ? { content: params.content } : {},
       ...params.messageId ? { msg_id: params.messageId } : params.eventId ? { event_id: params.eventId } : {}
-    },
-    { timeout: 15e3 }
-  );
+    })
+  });
 }
 async function sendGroupMediaMessage(params) {
-  const msgSeq = nextMsgSeq(params.messageId ?? params.eventId);
-  return apiPost(
-    params.accessToken,
-    `/v2/groups/${params.groupOpenid}/messages`,
-    {
+  return postPassiveMessage({
+    accessToken: params.accessToken,
+    path: `/v2/groups/${params.groupOpenid}/messages`,
+    sequenceKey: resolveMsgSeqKey(params.messageId, params.eventId),
+    options: { timeout: 15e3 },
+    buildBody: (msgSeq) => ({
       msg_type: 7,
       media: { file_info: params.fileInfo },
       msg_seq: msgSeq,
       ...params.content ? { content: params.content } : {},
       ...params.messageId ? { msg_id: params.messageId } : params.eventId ? { event_id: params.eventId } : {}
-    },
-    { timeout: 15e3 }
-  );
+    })
+  });
+}
+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) {
@@ -7645,7 +7958,7 @@ async function sendFileQQBot(params) {
     }
   }
   try {
-    return await sendC2CMediaMessage({
+    const result = await sendC2CMediaMessage({
       accessToken,
       openid: target.id,
       fileInfo,
@@ -7653,6 +7966,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}`);
@@ -7741,6 +8060,14 @@ function logEventIdFallback(params) {
   }
   console.info(detail);
 }
+function logQQBotOutboundDispatch(params) {
+  const accountLabel = params.accountId?.trim() || DEFAULT_ACCOUNT_ID;
+  const textLength = typeof params.text === "string" ? params.text.length : 0;
+  const mediaLabel = params.mediaUrl ? ` media=${shortId(params.mediaUrl)}` : "";
+  console.info(
+    `[qqbot] outbound action=${params.action} api=${params.api} accountId=${accountLabel} target=${params.targetKind}:${shortId(params.targetId)} markdown=${params.markdown ? "yes" : "no"} replyToId=${params.replyToId ? "yes" : "no"} replyEventId=${params.replyEventId ? "yes" : "no"} textLen=${textLength}${mediaLabel}`
+  );
+}
 function shouldRetryWithEventId(err) {
   const status = err instanceof HttpError ? err.status : void 0;
   let body = "";
@@ -7761,6 +8088,94 @@ 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 };
+  }
+  if (params.replyEventId) {
+    return { eventId: params.replyEventId };
+  }
+  return {};
+}
 var qqbotOutbound = {
   deliveryMode: "direct",
   textChunkLimit: 1500,
@@ -7778,13 +8193,42 @@ var qqbotOutbound = {
     const groupMarkdown = false;
     try {
       if (target.kind === "group") {
+        if (!replyToId && !replyEventId) {
+          logQQBotOutboundDispatch({
+            action: "text",
+            api: "sendProactiveGroupMessage",
+            accountId,
+            targetKind: target.kind,
+            targetId: target.id,
+            markdown,
+            text
+          });
+          const result3 = await sendProactiveGroupMessage({
+            accessToken,
+            groupOpenid: target.id,
+            content: text,
+            markdown
+          });
+          return { channel: "qqbot", messageId: result3.id, timestamp: result3.timestamp };
+        }
         let result2;
         try {
+          logQQBotOutboundDispatch({
+            action: "text",
+            api: "sendGroupMessage",
+            accountId,
+            targetKind: target.kind,
+            targetId: target.id,
+            markdown: groupMarkdown,
+            replyToId,
+            replyEventId,
+            text
+          });
           result2 = await sendGroupMessage({
             accessToken,
             groupOpenid: target.id,
             content: text,
-            messageId: replyToId,
+            ...buildPassiveReplyRefs({ replyToId, replyEventId }),
             markdown: groupMarkdown
           });
         } catch (err) {
@@ -7835,6 +8279,15 @@ var qqbotOutbound = {
         return { channel: "qqbot", messageId: result2.id, timestamp: result2.timestamp };
       }
       if (target.kind === "channel") {
+        logQQBotOutboundDispatch({
+          action: "text",
+          api: "sendChannelMessage",
+          accountId,
+          targetKind: target.kind,
+          targetId: target.id,
+          replyToId,
+          text
+        });
         const result2 = await sendChannelMessage({
           accessToken,
           channelId: target.id,
@@ -7843,13 +8296,49 @@ var qqbotOutbound = {
         });
         return { channel: "qqbot", messageId: result2.id, timestamp: result2.timestamp };
       }
+      if (!replyToId && !replyEventId) {
+        logQQBotOutboundDispatch({
+          action: "text",
+          api: "sendProactiveC2CMessage",
+          accountId,
+          targetKind: target.kind,
+          targetId: target.id,
+          markdown,
+          text
+        });
+        const result2 = await sendProactiveC2CMessage({
+          accessToken,
+          openid: target.id,
+          content: text,
+          markdown
+        });
+        const refIdx2 = resolveResponseRefIdx(result2);
+        recordOutboundC2CRefIndex({ refIdx: refIdx2, accountId, text });
+        return {
+          channel: "qqbot",
+          messageId: result2.id,
+          timestamp: result2.timestamp,
+          ...refIdx2 ? { refIdx: refIdx2 } : {}
+        };
+      }
       let result;
       try {
+        logQQBotOutboundDispatch({
+          action: "text",
+          api: "sendC2CMessage",
+          accountId,
+          targetKind: target.kind,
+          targetId: target.id,
+          markdown,
+          replyToId,
+          replyEventId,
+          text
+        });
         result = await sendC2CMessage({
           accessToken,
           openid: target.id,
           content: text,
-          messageId: replyToId,
+          ...buildPassiveReplyRefs({ replyToId, replyEventId }),
           markdown
         });
       } catch (err) {
@@ -7897,7 +8386,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 };
@@ -7927,6 +8423,17 @@ ${mediaUrl}` : mediaUrl;
     try {
       let result;
       try {
+        logQQBotOutboundDispatch({
+          action: "media",
+          api: "sendFileQQBot",
+          accountId,
+          targetKind: target.kind,
+          targetId: target.id,
+          replyToId,
+          replyEventId,
+          text: sendTextAsFollowup ? void 0 : trimmedText,
+          mediaUrl
+        });
         result = await sendFileQQBot({
           cfg: qqCfg,
           target: { kind: target.kind, id: target.id },
@@ -7995,7 +8502,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 };
@@ -8014,8 +8535,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,
@@ -8037,7 +8559,7 @@ ${mediaUrl}` : mediaUrl;
           reason: summarizeError(err)
         });
         try {
-          await sendC2CInputNotify({
+          typingResult = await sendC2CInputNotify({
             accessToken,
             openid: target.id,
             eventId: replyEventId,
@@ -8066,7 +8588,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 };
@@ -8076,13 +8601,301 @@ ${mediaUrl}` : mediaUrl;
 
 // src/logger.ts
 createLogger("qqbot");
-var DEFAULT_KNOWN_TARGETS_PATH = join(homedir(), ".openclaw", "data", "qqbot", "known-targets.json");
+var DEFAULT_QQBOT_MARKDOWN_IMAGE_SIZE = {
+  width: 512,
+  height: 512
+};
+var MARKDOWN_IMAGE_RE2 = /!\[([^\]]*)\]\(([^)\n]+)\)/g;
+var BARE_HTTP_IMAGE_URL_RE = /(?<![(\["'<])(https?:\/\/[^\s)"'<>]+\.(?:png|jpe?g|gif|webp)(?:\?[^\s)"'<>]*)?)/gi;
+var FENCED_CODE_BLOCK_RE = /(^|\n)(`{3,}|~{3,})[^\n]*\n[\s\S]*?\n\2(?=\n|$)/g;
+function parsePngSize(buffer) {
+  if (buffer.length < 24) return null;
+  if (buffer[0] !== 137 || buffer[1] !== 80 || buffer[2] !== 78 || buffer[3] !== 71) {
+    return null;
+  }
+  return {
+    width: buffer.readUInt32BE(16),
+    height: buffer.readUInt32BE(20)
+  };
+}
+function parseJpegSize(buffer) {
+  if (buffer.length < 4 || buffer[0] !== 255 || buffer[1] !== 216) {
+    return null;
+  }
+  let offset = 2;
+  while (offset < buffer.length - 9) {
+    if (buffer[offset] !== 255) {
+      offset += 1;
+      continue;
+    }
+    const marker = buffer[offset + 1];
+    if (marker === 192 || marker === 194) {
+      return {
+        height: buffer.readUInt16BE(offset + 5),
+        width: buffer.readUInt16BE(offset + 7)
+      };
+    }
+    if (offset + 3 >= buffer.length) {
+      break;
+    }
+    const blockLength = buffer.readUInt16BE(offset + 2);
+    offset += 2 + blockLength;
+  }
+  return null;
+}
+function parseGifSize(buffer) {
+  if (buffer.length < 10) return null;
+  const signature = buffer.toString("ascii", 0, 6);
+  if (signature !== "GIF87a" && signature !== "GIF89a") {
+    return null;
+  }
+  return {
+    width: buffer.readUInt16LE(6),
+    height: buffer.readUInt16LE(8)
+  };
+}
+function parseWebpSize(buffer) {
+  if (buffer.length < 30) return null;
+  if (buffer.toString("ascii", 0, 4) !== "RIFF" || buffer.toString("ascii", 8, 12) !== "WEBP") {
+    return null;
+  }
+  const chunkType = buffer.toString("ascii", 12, 16);
+  if (chunkType === "VP8 " && buffer[23] === 157 && buffer[24] === 1 && buffer[25] === 42) {
+    return {
+      width: buffer.readUInt16LE(26) & 16383,
+      height: buffer.readUInt16LE(28) & 16383
+    };
+  }
+  if (chunkType === "VP8L" && buffer[20] === 47) {
+    const bits = buffer.readUInt32LE(21);
+    return {
+      width: (bits & 16383) + 1,
+      height: (bits >> 14 & 16383) + 1
+    };
+  }
+  if (chunkType === "VP8X") {
+    return {
+      width: (buffer[24] | buffer[25] << 8 | buffer[26] << 16) + 1,
+      height: (buffer[27] | buffer[28] << 8 | buffer[29] << 16) + 1
+    };
+  }
+  return null;
+}
+function parseImageSize(buffer) {
+  return parsePngSize(buffer) ?? parseJpegSize(buffer) ?? parseGifSize(buffer) ?? parseWebpSize(buffer);
+}
+function normalizeImageSize(size) {
+  if (!size) return null;
+  if (!Number.isFinite(size.width) || !Number.isFinite(size.height)) return null;
+  if (size.width <= 0 || size.height <= 0) return null;
+  return {
+    width: Math.round(size.width),
+    height: Math.round(size.height)
+  };
+}
+function splitMarkdownImageDestination(rawDestination) {
+  let next = rawDestination.trim();
+  const whitespaceIndex = next.search(/\s/);
+  if (whitespaceIndex >= 0) {
+    next = next.slice(0, whitespaceIndex);
+  }
+  if (next.startsWith("<") && next.endsWith(">")) {
+    next = next.slice(1, -1).trim();
+  }
+  return next;
+}
+function splitFencedCodeBlocks(text) {
+  const segments = [];
+  const re = new RegExp(FENCED_CODE_BLOCK_RE.source, FENCED_CODE_BLOCK_RE.flags);
+  let lastIndex = 0;
+  let match;
+  while ((match = re.exec(text)) !== null) {
+    const leading = match[1] ?? "";
+    const codeStart = match.index + leading.length;
+    if (codeStart > lastIndex) {
+      segments.push({ kind: "text", value: text.slice(lastIndex, codeStart) });
+    }
+    segments.push({ kind: "code", value: text.slice(codeStart, re.lastIndex) });
+    lastIndex = re.lastIndex;
+  }
+  if (lastIndex < text.length) {
+    segments.push({ kind: "text", value: text.slice(lastIndex) });
+  }
+  return segments;
+}
+async function replaceAsync(input2, pattern, replacer) {
+  const re = new RegExp(pattern.source, pattern.flags);
+  let result = "";
+  let lastIndex = 0;
+  let match;
+  while ((match = re.exec(input2)) !== null) {
+    result += input2.slice(lastIndex, match.index);
+    result += await replacer(match);
+    lastIndex = match.index + match[0].length;
+    if (match[0].length === 0) {
+      re.lastIndex += 1;
+    }
+  }
+  result += input2.slice(lastIndex);
+  return result;
+}
+async function getResolvedImageSize(params) {
+  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);
+  cache2.set(url, pending);
+  return pending;
+}
+async function normalizeTextSegment(params) {
+  const { text, seenImageUrls, imageSizeCache, resolveImageSize } = params;
+  const withMarkdownImages = await replaceAsync(text, MARKDOWN_IMAGE_RE2, async (match) => {
+    const fullMatch = match[0];
+    const destination = splitMarkdownImageDestination(match[2] ?? "");
+    if (!isQQBotHttpImageUrl(destination)) {
+      return fullMatch;
+    }
+    seenImageUrls.add(destination);
+    if (hasQQBotMarkdownImageSize(fullMatch)) {
+      return fullMatch;
+    }
+    const size = await getResolvedImageSize({
+      url: destination,
+      cache: imageSizeCache,
+      resolveImageSize
+    });
+    return formatQQBotMarkdownImage(destination, size);
+  });
+  return replaceAsync(withMarkdownImages, BARE_HTTP_IMAGE_URL_RE, async (match) => {
+    const url = match[1] ?? match[0];
+    if (!isQQBotHttpImageUrl(url)) {
+      return match[0];
+    }
+    seenImageUrls.add(url);
+    const size = await getResolvedImageSize({
+      url,
+      cache: imageSizeCache,
+      resolveImageSize
+    });
+    return formatQQBotMarkdownImage(url, size);
+  });
+}
+function isQQBotHttpImageUrl(url) {
+  const trimmed = url.trim();
+  if (!/^https?:\/\//i.test(trimmed)) {
+    return false;
+  }
+  try {
+    const parsed = new URL(trimmed);
+    return /\.(?:png|jpe?g|gif|webp)$/i.test(parsed.pathname);
+  } catch {
+    return /\.(?:png|jpe?g|gif|webp)(?:\?[^\s)"'<>]*)?$/i.test(trimmed);
+  }
+}
+async function getQQBotHttpImageSize(url, timeoutMs = 5e3) {
+  if (!isQQBotHttpImageUrl(url)) {
+    return null;
+  }
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        Range: "bytes=0-65535",
+        "User-Agent": "OpenClaw-QQBot-ImageSize/1.0"
+      }
+    });
+    if (!(response.ok || response.status === 206)) {
+      return null;
+    }
+    const buffer = Buffer$1.from(await response.arrayBuffer());
+    return normalizeImageSize(parseImageSize(buffer));
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+function formatQQBotMarkdownImage(url, size) {
+  const resolved = normalizeImageSize(size) ?? DEFAULT_QQBOT_MARKDOWN_IMAGE_SIZE;
+  return `![#${resolved.width}px #${resolved.height}px](${url})`;
+}
+function hasQQBotMarkdownImageSize(markdownImage) {
+  return /!\[#\d+px\s+#\d+px\]\([^)]+\)/.test(markdownImage);
+}
+async function normalizeQQBotMarkdownImages(params) {
+  const text = params.text ?? "";
+  const appendImageUrls = params.appendImageUrls ?? [];
+  const resolveImageSize = params.resolveImageSize ?? ((url) => getQQBotHttpImageSize(url, params.timeoutMs));
+  const imageSizeCache = /* @__PURE__ */ new Map();
+  const seenImageUrls = /* @__PURE__ */ new Set();
+  const segments = splitFencedCodeBlocks(text);
+  const normalizedSegments = [];
+  for (const segment of segments) {
+    if (segment.kind === "code") {
+      normalizedSegments.push(segment.value);
+      continue;
+    }
+    normalizedSegments.push(
+      await normalizeTextSegment({
+        text: segment.value,
+        seenImageUrls,
+        imageSizeCache,
+        resolveImageSize
+      })
+    );
+  }
+  const appendedImages = [];
+  for (const rawUrl of appendImageUrls) {
+    const url = rawUrl.trim();
+    if (!isQQBotHttpImageUrl(url) || seenImageUrls.has(url)) {
+      continue;
+    }
+    seenImageUrls.add(url);
+    const size = await getResolvedImageSize({
+      url,
+      cache: imageSizeCache,
+      resolveImageSize
+    });
+    appendedImages.push(formatQQBotMarkdownImage(url, size));
+  }
+  const body = normalizedSegments.join("").trim();
+  if (appendedImages.length === 0) {
+    return body;
+  }
+  if (!body) {
+    return appendedImages.join("\n");
+  }
+  return `${body}
+
+${appendedImages.join("\n")}`;
+}
+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;
@@ -8118,6 +8931,7 @@ function parseKnownTargets(raw, filePath) {
 }
 function readKnownTargets(options) {
   const filePath = resolveKnownTargetsFilePath(options);
+  migrateLegacyKnownTargets(filePath);
   if (!existsSync(filePath)) {
     return [];
   }
@@ -8129,6 +8943,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 });
@@ -8261,6 +9076,65 @@ function getQQBotRuntime() {
   }
   return runtime;
 }
+var sessionDispatchQueue = /* @__PURE__ */ new Map();
+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}:${resolveQQBotRouteSessionKey(route)}`;
+}
+function normalizeQQBotSessionKeyPart(value) {
+  const trimmed = value.trim();
+  return trimmed ? trimmed.toLowerCase() : "unknown";
+}
+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}`;
+  }
+  const qqAgentRouteMatch = trimmedRouteSessionKey.match(/^(agent:[^:]+:qqbot:)(?:direct|dm):.+$/i);
+  if (qqAgentRouteMatch?.[1]) {
+    return `${qqAgentRouteMatch[1]}dm:${normalizedAccountId}:${normalizedSenderId}`;
+  }
+  return `${trimmedRouteSessionKey}:dm:${normalizedAccountId}:${normalizedSenderId}`;
+}
+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;
+}
+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);
+  try {
+    return await run;
+  } finally {
+    if (sessionDispatchQueue.get(queueKey) === cleanup) {
+      sessionDispatchQueue.delete(queueKey);
+    }
+  }
+}
 function toString(value) {
   if (typeof value === "string" && value.trim()) return value;
   return void 0;
@@ -8311,6 +9185,33 @@ function parseTextWithAttachments(payload) {
     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);
 }
@@ -8320,6 +9221,7 @@ 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;
@@ -8354,7 +9256,7 @@ function startLongTaskNoticeTimer(params) {
     }
   };
 }
-function isHttpUrl2(value) {
+function isHttpUrl3(value) {
   return /^https?:\/\//i.test(value);
 }
 function isImageAttachment(att) {
@@ -8427,7 +9329,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,
@@ -8456,7 +9358,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 {
@@ -8527,6 +9429,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;
@@ -8548,6 +9518,7 @@ 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();
@@ -8564,6 +9535,7 @@ function parseC2CMessage(data, fallbackEventId) {
     messageId: id,
     eventId,
     timestamp,
+    ...refIndices,
     mentionedBot: false
   };
 }
@@ -8677,6 +9649,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()}`;
@@ -8728,24 +9716,58 @@ function resolveKnownQQBotTargetFromInbound(params) {
 }
 function extractLocalMediaFromText(params) {
   const { text, logger } = params;
-  const result = extractMediaFromText(text, {
-    removeFromText: true,
-    checkExists: true,
-    existsSync: (p) => {
-      const exists = fs3.existsSync(p);
-      if (!exists) {
-        logger?.warn?.(`[media] local file not found: ${p}`);
-      }
-      return exists;
-    },
-    parseMediaLines: false,
-    parseMarkdownImages: true,
-    parseHtmlImages: false,
-    parseBarePaths: true,
-    parseMarkdownLinks: true
+  const mediaUrls = [];
+  const seenMedia = /* @__PURE__ */ new Set();
+  let nextText = text;
+  const MARKDOWN_LINKED_IMAGE_RE2 = /\[!\[([^\]]*)\]\(([^)]+)\)\]\(([^)]+)\)/g;
+  const MARKDOWN_IMAGE_RE3 = /!\[([^\]]*)\]\(([^)]+)\)/g;
+  const MARKDOWN_LINK_RE2 = /\[([^\]]*)\]\(([^)]+)\)/g;
+  const BARE_LOCAL_MEDIA_PATH_RE = /`?((?:\/(?:tmp|var|private|Users|home|root)\/[^\s`'",)]+|[A-Za-z]:[\\/][^\s`'",)]+)\.(?:png|jpg|jpeg|gif|bmp|webp|svg|ico|mp3|wav|ogg|m4a|amr|flac|aac|wma|mp4|mov|avi|mkv|webm|flv|wmv|m4v))`?/gi;
+  const collectLocalRichMedia = (rawValue, allowedTypes) => {
+    const candidate = stripTitleFromUrl(rawValue.trim());
+    if (!candidate || !isLocalReference(candidate)) {
+      return void 0;
+    }
+    if (!fs3.existsSync(candidate)) {
+      logger?.warn?.(`[media] local file not found: ${candidate}`);
+      return void 0;
+    }
+    const mediaType = detectMediaType(candidate);
+    if (mediaType === "file") {
+      return void 0;
+    }
+    if (allowedTypes && !allowedTypes.has(mediaType)) {
+      return void 0;
+    }
+    if (seenMedia.has(candidate)) {
+      return candidate;
+    }
+    seenMedia.add(candidate);
+    mediaUrls.push(candidate);
+    return candidate;
+  };
+  nextText = nextText.replace(MARKDOWN_LINKED_IMAGE_RE2, (fullMatch, _alt, rawPath) => {
+    return collectLocalRichMedia(rawPath) ? "" : fullMatch;
   });
-  const mediaUrls = result.all.filter((m) => m.isLocal && typeof m.localPath === "string").filter((m) => m.type !== "file").map((m) => m.localPath);
-  return { text: result.text, mediaUrls };
+  nextText = nextText.replace(MARKDOWN_IMAGE_RE3, (fullMatch, _alt, rawPath) => {
+    return collectLocalRichMedia(rawPath) ? "" : fullMatch;
+  });
+  nextText = nextText.replace(MARKDOWN_LINK_RE2, (fullMatch, _label, rawPath) => {
+    const mediaPath = collectLocalRichMedia(rawPath, /* @__PURE__ */ new Set(["audio", "video"]));
+    if (!mediaPath) {
+      return fullMatch;
+    }
+    return "";
+  });
+  nextText = nextText.replace(BARE_LOCAL_MEDIA_PATH_RE, (fullMatch, rawPath) => {
+    return collectLocalRichMedia(rawPath) ? "" : fullMatch;
+  });
+  nextText = nextText.replace(/[ \t]+\n/g, "\n");
+  nextText = nextText.replace(/\n{3,}/g, "\n\n");
+  return {
+    text: nextText.trim(),
+    mediaUrls
+  };
 }
 function extractMediaLinesFromText(params) {
   const { text, logger } = params;
@@ -8798,6 +9820,9 @@ var FILE_PLACEHOLDER_RE = /\[文件:\s*[^\]\n]+\]/g;
 var DIRECTIVE_TAG_RE = /\[\[\s*(?:reply_to_current|reply_to\s*:[^\]]+|audio_as_voice|tts(?::text)?|\/tts(?::text)?)\s*\]\]/gi;
 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 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) {
   const matches = Array.from(text.matchAll(FINAL_BLOCK_RE));
   if (matches.length === 0) return void 0;
@@ -8822,6 +9847,14 @@ function sanitizeQQBotOutboundText(rawText) {
   if (/^NO_REPLY$/i.test(next)) return "";
   return next;
 }
+function formatQQBotOutboundPreview(text, maxLength = 240) {
+  const normalized = text.replace(/\r\n/g, "\n").trim();
+  if (!normalized) {
+    return '""';
+  }
+  const preview = normalized.length > maxLength ? `${normalized.slice(0, Math.max(0, maxLength - 3))}...` : normalized;
+  return JSON.stringify(preview);
+}
 function shouldSuppressQQBotTextWhenMediaPresent(rawText, sanitizedText) {
   const raw = rawText.trim();
   if (!raw) return false;
@@ -8854,8 +9887,113 @@ function evaluateReplyFinalOnlyDelivery(params) {
   }
   return { skipDelivery: true, suppressText: false };
 }
+function isQQBotC2CTarget(to) {
+  const trimmed = to.trim();
+  const raw = trimmed.startsWith("qqbot:") ? trimmed.slice("qqbot:".length) : trimmed;
+  return !raw.startsWith("group:") && !raw.startsWith("channel:");
+}
+function splitQQBotMarkdownTransportMediaUrls(mediaUrls) {
+  const markdownImageUrls = [];
+  const mediaQueue = [];
+  const seenMarkdownImages = /* @__PURE__ */ new Set();
+  const seenMedia = /* @__PURE__ */ new Set();
+  for (const rawUrl of mediaUrls) {
+    const next = rawUrl.trim();
+    if (!next) continue;
+    if (isQQBotHttpImageUrl(next)) {
+      if (seenMarkdownImages.has(next)) continue;
+      seenMarkdownImages.add(next);
+      markdownImageUrls.push(next);
+      continue;
+    }
+    if (seenMedia.has(next)) continue;
+    seenMedia.add(next);
+    mediaQueue.push(next);
+  }
+  return { markdownImageUrls, mediaQueue };
+}
+function hasQQBotMarkdownTable(text) {
+  const lines = text.replace(/\r\n/g, "\n").split("\n");
+  for (let index = 0; index < lines.length - 1; index += 1) {
+    const header = lines[index]?.trim() ?? "";
+    const separator = lines[index + 1]?.trim() ?? "";
+    if (!header.includes("|") || !MARKDOWN_TABLE_SEPARATOR_RE.test(separator)) {
+      continue;
+    }
+    const headerColumns = header.split("|").filter((column) => column.trim()).length;
+    const separatorColumns = separator.split("|").filter((column) => column.trim()).length;
+    if (headerColumns >= 2 && separatorColumns >= 2) {
+      return true;
+    }
+  }
+  return false;
+}
+function resolveQQBotTextReplyRefs(params) {
+  const mode = params.c2cMarkdownDeliveryMode ?? "proactive-table-only";
+  const forceProactive = params.markdownSupport && isQQBotC2CTarget(params.to) && (mode === "proactive-all" || mode === "proactive-table-only" && hasQQBotMarkdownTable(params.text));
+  if (!forceProactive) {
+    return {
+      forceProactive: false,
+      replyToId: params.replyToId,
+      replyEventId: params.replyEventId
+    };
+  }
+  return {
+    forceProactive: true,
+    replyToId: void 0,
+    replyEventId: void 0
+  };
+}
+function appendQQBotBufferedText(bufferedTexts, nextText) {
+  const normalized = nextText.trim();
+  if (!normalized) return bufferedTexts;
+  if (bufferedTexts.length === 0) return [normalized];
+  const currentCombined = bufferedTexts.join("\n\n");
+  if (currentCombined === normalized || currentCombined.includes(normalized)) {
+    return bufferedTexts;
+  }
+  if (normalized.includes(currentCombined)) {
+    return [normalized];
+  }
+  const last = bufferedTexts[bufferedTexts.length - 1];
+  if (last === normalized) {
+    return bufferedTexts;
+  }
+  return [...bufferedTexts, normalized];
+}
+function normalizeQQBotRenderedMarkdown(text) {
+  if (!text.trim()) return "";
+  let next = text.trim();
+  let changed = false;
+  next = next.replace(
+    EXPLICIT_MARKDOWN_FENCE_RE,
+    (block, leadingLineBreak, _fence, inner) => {
+      const normalizedInner = inner.trim();
+      if (!normalizedInner) {
+        return block;
+      }
+      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();
+}
 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;
   for (const mediaUrl of mediaQueue) {
     const result = await outbound.sendMedia({
@@ -8863,7 +10001,8 @@ async function sendQQBotMediaWithFallback(params) {
       to,
       mediaUrl,
       replyToId,
-      replyEventId
+      replyEventId,
+      accountId
     });
     if (result.error) {
       logger.error(`sendMedia failed: ${result.error}`);
@@ -8877,7 +10016,8 @@ async function sendQQBotMediaWithFallback(params) {
         to,
         text: fallback,
         replyToId,
-        replyEventId
+        replyEventId,
+        accountId
       });
       if (fallbackResult.error) {
         logger.error(`sendText fallback failed: ${fallbackResult.error}`);
@@ -8920,32 +10060,27 @@ function buildInboundContext(params) {
   };
 }
 async function dispatchToAgent(params) {
-  const { inbound, cfg, qqCfg, accountId, logger } = params;
+  const { inbound, cfg, qqCfg, accountId, logger, route } = params;
   const runtime2 = getQQBotRuntime();
-  const routing = runtime2.channel?.routing?.resolveAgentRoute;
-  if (!routing) {
-    logger.warn("routing API not available");
-    return;
-  }
+  const routeSessionKey = resolveQQBotRouteSessionKey(route);
   const target = resolveChatTarget(inbound);
+  const outboundAccountId = route.accountId ?? accountId;
+  let typingRefIdx;
   if (inbound.c2cOpenid) {
     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 route = routing({
-    cfg,
-    channel: "qqbot",
-    accountId,
-    peer: { kind: target.peerKind, id: target.peerId }
-  });
   const replyApi = runtime2.channel?.reply;
   if (!replyApi) {
     logger.warn("reply API not available");
@@ -8974,7 +10109,8 @@ async function dispatchToAgent(params) {
         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}`);
@@ -8994,7 +10130,7 @@ 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,
@@ -9006,7 +10142,8 @@ async function dispatchToAgent(params) {
         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}`);
@@ -9021,6 +10158,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
@@ -9046,40 +10216,48 @@ 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;
+    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
+        });
       }
+      finalCtx.BodyForAgent = appendCronHiddenPrompt(agentBody);
     }
     if (storePath && sessionApi?.recordInboundSession) {
       try {
-        const mainSessionKeyRaw = route?.mainSessionKey;
-        const mainSessionKey = typeof mainSessionKeyRaw === "string" && mainSessionKeyRaw.trim() ? mainSessionKeyRaw : void 0;
+        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: finalCtx.OriginatingTo ?? finalCtx.To ?? `user:${inbound.senderId}`,
-          accountId: route.accountId ?? accountId
+          to: stableTo,
+          accountId: outboundAccountId
         } : void 0;
-        const recordSessionKey = typeof finalCtx.SessionKey === "string" && finalCtx.SessionKey.trim() ? finalCtx.SessionKey : route.sessionKey;
+        const recordSessionKey = typeof finalCtx.SessionKey === "string" && finalCtx.SessionKey.trim() ? finalCtx.SessionKey : routeSessionKey;
         await sessionApi.recordInboundSession({
           storePath,
           sessionKey: recordSessionKey,
@@ -9103,7 +10281,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) => {
@@ -9116,6 +10294,100 @@ async function dispatchToAgent(params) {
       return [text];
     };
     const replyFinalOnly = qqCfg.replyFinalOnly ?? false;
+    const markdownSupport = qqCfg.markdownSupport ?? true;
+    const c2cMarkdownDeliveryMode = qqCfg.c2cMarkdownDeliveryMode ?? "proactive-table-only";
+    const useC2CMarkdownTransport = markdownSupport && isQQBotC2CTarget(target.to);
+    let bufferedC2CMarkdownTexts = [];
+    let bufferedC2CMarkdownMediaUrls = [];
+    const bufferedC2CMarkdownMediaSeen = /* @__PURE__ */ new Set();
+    const bufferC2CMarkdownMedia = (url) => {
+      const next = url?.trim();
+      if (!next || bufferedC2CMarkdownMediaSeen.has(next)) return;
+      bufferedC2CMarkdownMediaSeen.add(next);
+      bufferedC2CMarkdownMediaUrls.push(next);
+    };
+    const sendC2CMarkdownTransportPayload = async (params2) => {
+      const normalizedText = normalizeQQBotRenderedMarkdown(params2.text);
+      const { markdownImageUrls, mediaQueue } = splitQQBotMarkdownTransportMediaUrls(params2.mediaUrls);
+      const finalMarkdownText = await normalizeQQBotMarkdownImages({
+        text: normalizedText,
+        appendImageUrls: markdownImageUrls
+      });
+      const textReplyRefs = resolveQQBotTextReplyRefs({
+        to: target.to,
+        text: finalMarkdownText || normalizedText,
+        markdownSupport,
+        c2cMarkdownDeliveryMode,
+        replyToId: inbound.messageId,
+        replyEventId: inbound.eventId
+      });
+      const textSegments = finalMarkdownText ? [finalMarkdownText] : [];
+      const deliveryLabel = textReplyRefs.forceProactive ? "c2c-markdown-proactive" : "c2c-markdown-passive";
+      logger.info(
+        `delivery=${deliveryLabel} to=${target.to} segments=${textSegments.length} media=${mediaQueue.length} replyToId=${textReplyRefs.replyToId ? "yes" : "no"} replyEventId=${textReplyRefs.replyEventId ? "yes" : "no"} phase=${params2.phase} tableMode=${String(resolvedTableMode)} chunkMode=${String(chunkMode ?? "default")}`
+      );
+      await sendQQBotMediaWithFallback({
+        qqCfg,
+        to: target.to,
+        mediaQueue,
+        replyToId: textReplyRefs.replyToId,
+        replyEventId: textReplyRefs.replyEventId,
+        accountId: outboundAccountId,
+        logger,
+        onDelivered: () => {
+          markReplyDelivered();
+        },
+        onError: (error) => {
+          markGroupMessageInterfaceBlocked(error);
+        }
+      });
+      if (!finalMarkdownText) {
+        return;
+      }
+      for (let segmentIndex = 0; segmentIndex < textSegments.length; segmentIndex += 1) {
+        const segment = textSegments[segmentIndex] ?? "";
+        const chunks = chunkText(segment);
+        for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex += 1) {
+          const chunk = chunks[chunkIndex] ?? "";
+          logger.info(
+            `delivery=${deliveryLabel} segment=${segmentIndex + 1}/${textSegments.length} chunk=${chunkIndex + 1}/${chunks.length} phase=${params2.phase} preview=${formatQQBotOutboundPreview(chunk)}`
+          );
+          const result = await qqbotOutbound.sendText({
+            cfg: { channels: { qqbot: qqCfg } },
+            to: target.to,
+            text: chunk,
+            replyToId: textReplyRefs.replyToId,
+            replyEventId: textReplyRefs.replyEventId,
+            accountId: outboundAccountId
+          });
+          if (result.error) {
+            logger.error(`send QQ markdown reply failed: ${result.error}`);
+            markGroupMessageInterfaceBlocked(result.error);
+          } else {
+            logger.info(`sent QQ markdown reply (phase=${params2.phase}, len=${chunk.length})`);
+            markReplyDelivered();
+          }
+        }
+      }
+    };
+    const flushBufferedC2CMarkdownReply = async () => {
+      if (!useC2CMarkdownTransport || bufferedC2CMarkdownTexts.length === 0 && bufferedC2CMarkdownMediaUrls.length === 0) {
+        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) => {
       const typed = payload;
       const extractedTextMedia = extractQQBotReplyMedia({
@@ -9146,16 +10418,43 @@ async function dispatchToAgent(params) {
       const suppressEchoText = mediaQueue.length > 0 && shouldSuppressQQBotTextWhenMediaPresent(extractedTextMedia.text, cleanedText);
       const suppressText = deliveryDecision.suppressText || suppressEchoText;
       const textToSend = suppressText ? "" : cleanedText;
+      if (useC2CMarkdownTransport) {
+        const shouldBufferFinalOnlyPayload = replyFinalOnly && (!info?.kind || info.kind === "final");
+        if (shouldBufferFinalOnlyPayload) {
+          if (textToSend) {
+            bufferedC2CMarkdownTexts = appendQQBotBufferedText(bufferedC2CMarkdownTexts, textToSend);
+          }
+          for (const url of mediaQueue) {
+            bufferC2CMarkdownMedia(url);
+          }
+          return;
+        }
+        await sendC2CMarkdownTransportPayload({
+          text: textToSend,
+          mediaUrls: mediaQueue,
+          phase: "immediate"
+        });
+        return;
+      }
       if (textToSend) {
         const converted = textApi?.convertMarkdownTables ? textApi.convertMarkdownTables(textToSend, resolvedTableMode) : textToSend;
+        const textReplyRefs = resolveQQBotTextReplyRefs({
+          to: target.to,
+          text: converted,
+          markdownSupport,
+          c2cMarkdownDeliveryMode,
+          replyToId: inbound.messageId,
+          replyEventId: inbound.eventId
+        });
         const chunks = chunkText(converted);
         for (const chunk of chunks) {
           const result = await qqbotOutbound.sendText({
             cfg: { channels: { qqbot: qqCfg } },
             to: target.to,
             text: chunk,
-            replyToId: inbound.messageId,
-            replyEventId: inbound.eventId
+            replyToId: textReplyRefs.replyToId,
+            replyEventId: textReplyRefs.replyEventId,
+            accountId: outboundAccountId
           });
           if (result.error) {
             logger.error(`sendText failed: ${result.error}`);
@@ -9171,6 +10470,7 @@ async function dispatchToAgent(params) {
         mediaQueue,
         replyToId: inbound.messageId,
         replyEventId: inbound.eventId,
+        accountId: outboundAccountId,
         logger,
         onDelivered: () => {
           markReplyDelivered();
@@ -9199,6 +10499,7 @@ async function dispatchToAgent(params) {
           }
         }
       });
+      await flushBufferedC2CMarkdownReply();
     } else {
       const dispatcherResult = replyApi.createReplyDispatcherWithTyping ? replyApi.createReplyDispatcherWithTyping({
         deliver,
@@ -9228,6 +10529,7 @@ async function dispatchToAgent(params) {
         replyOptions: dispatcherResult.replyOptions
       });
       dispatcherResult.markDispatchIdle?.();
+      await flushBufferedC2CMarkdownReply();
     }
     const noReplyFallback = resolveQQBotNoReplyFallback({
       inbound,
@@ -9240,7 +10542,8 @@ async function dispatchToAgent(params) {
         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}`);
@@ -9332,13 +10635,44 @@ async function handleQQBotDispatch(params) {
   if (!content && attachmentCount === 0) {
     return;
   }
-  await dispatchToAgent({
-    inbound: { ...inbound, content },
+  const runtime2 = getQQBotRuntime();
+  const routing = runtime2.channel?.routing?.resolveAgentRoute;
+  if (!routing) {
+    logger.warn("routing API not available");
+    return;
+  }
+  const target = resolveChatTarget(inbound);
+  const route = routing({
     cfg: params.cfg,
-    qqCfg,
+    channel: "qqbot",
     accountId,
-    logger
+    peer: { kind: target.peerKind, id: target.peerId }
+  });
+  const effectiveSessionKey = resolveQQBotEffectiveSessionKey({
+    inbound,
+    route,
+    accountId
   });
+  const resolvedRoute = effectiveSessionKey === route.sessionKey ? route : {
+    ...route,
+    mainSessionKey: route.mainSessionKey?.trim() || route.sessionKey,
+    effectiveSessionKey
+  };
+  const queueKey = buildSessionDispatchQueueKey(resolvedRoute);
+  if (sessionDispatchQueue.has(queueKey)) {
+    logger.info(`session busy; queueing inbound dispatch sessionKey=${resolveQQBotRouteSessionKey(resolvedRoute)}`);
+  }
+  await runSerializedSessionDispatch(
+    queueKey,
+    async () => dispatchToAgent({
+      inbound: { ...inbound, content },
+      cfg: params.cfg,
+      qqCfg,
+      accountId,
+      logger,
+      route: resolvedRoute
+    })
+  );
 }
 
 // src/monitor.ts
@@ -9638,7 +10972,8 @@ function resolveQQBotAccount(params) {
     enabled,
     configured,
     appId: credentials?.appId,
-    markdownSupport: merged.markdownSupport ?? true
+    markdownSupport: merged.markdownSupport ?? true,
+    c2cMarkdownDeliveryMode: merged.c2cMarkdownDeliveryMode ?? "proactive-table-only"
   };
 }
 var qqbotPlugin = {
@@ -9647,7 +10982,7 @@ var qqbotPlugin = {
     ...meta
   },
   capabilities: {
-    chatTypes: ["direct", "channel"],
+    chatTypes: ["direct", "group", "channel"],
     media: true,
     reactions: false,
     threads: false,
@@ -9727,6 +11062,10 @@ var qqbotPlugin = {
           }
         },
         markdownSupport: { type: "boolean" },
+        c2cMarkdownDeliveryMode: {
+          type: "string",
+          enum: ["passive", "proactive-table-only", "proactive-all"]
+        },
         dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
         groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
         requireMention: { type: "boolean" },
@@ -9768,6 +11107,10 @@ var qqbotPlugin = {
                 }
               },
               markdownSupport: { type: "boolean" },
+              c2cMarkdownDeliveryMode: {
+                type: "string",
+                enum: ["passive", "proactive-table-only", "proactive-all"]
+              },
               dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
               groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
               requireMention: { type: "boolean" },
@@ -9966,6 +11309,10 @@ var plugin = {
         }
       },
       markdownSupport: { type: "boolean" },
+      c2cMarkdownDeliveryMode: {
+        type: "string",
+        enum: ["passive", "proactive-table-only", "proactive-all"]
+      },
       dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
       groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
       requireMention: { type: "boolean" },
@@ -10007,6 +11354,10 @@ var plugin = {
               }
             },
             markdownSupport: { type: "boolean" },
+            c2cMarkdownDeliveryMode: {
+              type: "string",
+              enum: ["passive", "proactive-table-only", "proactive-all"]
+            },
             dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
             groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
             requireMention: { type: "boolean" },