@openclaw-china/qqbot 2026.3.16 → 2026.3.19

package/dist/index.js

@@ -4228,6 +4228,11 @@ var displayAliasesSchema = external_exports.record(
 ).optional();
 var QQBotC2CMarkdownDeliveryModeSchema = external_exports.enum(["passive", "proactive-table-only", "proactive-all"]).optional().default("proactive-table-only");
 var QQBotC2CMarkdownChunkStrategySchema = external_exports.enum(["markdown-block", "length"]).optional().default("markdown-block");
+var QQBotTypingHeartbeatModeSchema = external_exports.enum(["none", "idle", "always"]).optional().default("idle");
+var DEFAULT_QQBOT_TYPING_HEARTBEAT_MODE = "idle";
+var DEFAULT_QQBOT_TYPING_HEARTBEAT_INTERVAL_MS = 5e3;
+var DEFAULT_QQBOT_TYPING_INPUT_SECONDS = 60;
+var DEFAULT_QQBOT_C2C_MARKDOWN_SAFE_CHUNK_BYTE_LIMIT = 1200;
 var QQBotAccountSchema = external_exports.object({
   name: external_exports.string().optional(),
   enabled: external_exports.boolean().optional(),
@@ -4243,6 +4248,14 @@ var QQBotAccountSchema = external_exports.object({
   markdownSupport: external_exports.boolean().optional().default(true),
   c2cMarkdownDeliveryMode: QQBotC2CMarkdownDeliveryModeSchema,
   c2cMarkdownChunkStrategy: QQBotC2CMarkdownChunkStrategySchema,
+  c2cMarkdownSafeChunkByteLimit: external_exports.number().int().positive().optional(),
+  typingHeartbeatMode: QQBotTypingHeartbeatModeSchema,
+  typingHeartbeatIntervalMs: external_exports.number().int().positive().optional().default(
+    DEFAULT_QQBOT_TYPING_HEARTBEAT_INTERVAL_MS
+  ),
+  typingInputSeconds: external_exports.number().int().positive().optional().default(
+    DEFAULT_QQBOT_TYPING_INPUT_SECONDS
+  ),
   dmPolicy: external_exports.enum(["open", "pairing", "allowlist"]).optional().default("open"),
   groupPolicy: external_exports.enum(["open", "allowlist", "disabled"]).optional().default("open"),
   requireMention: external_exports.boolean().optional().default(true),
@@ -4292,6 +4305,19 @@ function resolveInboundMediaKeepDays(config) {
 function resolveQQBotAutoSendLocalPathMedia(config) {
   return config?.autoSendLocalPathMedia ?? true;
 }
+function resolveQQBotC2CMarkdownSafeChunkByteLimit(config) {
+  const value = config?.c2cMarkdownSafeChunkByteLimit;
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
+}
+function resolveQQBotTypingHeartbeatMode(config) {
+  return config?.typingHeartbeatMode ?? DEFAULT_QQBOT_TYPING_HEARTBEAT_MODE;
+}
+function resolveQQBotTypingHeartbeatIntervalMs(config) {
+  return config?.typingHeartbeatIntervalMs ?? DEFAULT_QQBOT_TYPING_HEARTBEAT_INTERVAL_MS;
+}
+function resolveQQBotTypingInputSeconds(config) {
+  return config?.typingInputSeconds ?? DEFAULT_QQBOT_TYPING_INPUT_SECONDS;
+}
 function resolveInboundMediaTempDir() {
   return DEFAULT_INBOUND_MEDIA_TEMP_DIR;
 }
@@ -6548,6 +6574,7 @@ var CHANNEL_ORDER = [
   "wecom",
   "wecom-app",
   "wecom-kf",
+  "wechat-mp",
   "feishu-china"
 ];
 var CHANNEL_DISPLAY_LABELS = {
@@ -6556,6 +6583,7 @@ var CHANNEL_DISPLAY_LABELS = {
   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",
+  "wechat-mp": "WeChat MP\uFF08\u5FAE\u4FE1\u516C\u4F17\u53F7\uFF09",
   qqbot: "QQBot\uFF08QQ \u673A\u5668\u4EBA\uFF09"
 };
 var CHANNEL_GUIDE_LINKS = {
@@ -6564,6 +6592,7 @@ var CHANNEL_GUIDE_LINKS = {
   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",
+  "wechat-mp": `${GUIDES_BASE}/wechat-mp/configuration.md`,
   qqbot: `${GUIDES_BASE}/qqbot/configuration.md`
 };
 var CHINA_CLI_STATE_KEY = /* @__PURE__ */ Symbol.for("@openclaw-china/china-cli-state");
@@ -6773,7 +6802,9 @@ function isChannelConfigured(cfg, channelId) {
     case "wecom-app":
       return hasTokenPair(channelCfg);
     case "wecom-kf":
-      return hasNonEmptyString(channelCfg.corpId) && hasNonEmptyString(channelCfg.corpSecret) && hasNonEmptyString(channelCfg.token) && hasNonEmptyString(channelCfg.encodingAESKey);
+      return hasNonEmptyString(channelCfg.corpId) && hasNonEmptyString(channelCfg.token) && hasNonEmptyString(channelCfg.encodingAESKey);
+    case "wechat-mp":
+      return hasNonEmptyString(channelCfg.appId) && hasNonEmptyString(channelCfg.token);
     default:
       return false;
   }
@@ -7034,6 +7065,15 @@ 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");
+  Ve(
+    [
+      "\u5411\u5BFC\u987A\u5E8F\uFF1AwebhookPath / token / encodingAESKey / corpId / open_kfid / corpSecret",
+      "\u57FA\u7840\u5FC5\u586B\uFF1AcorpId / token / encodingAESKey / open_kfid",
+      "corpSecret \u4F1A\u4F5C\u4E3A\u6700\u540E\u4E00\u4E2A\u53C2\u6570\u8BE2\u95EE\uFF1B\u9996\u6B21\u63A5\u5165\u53EF\u5148\u7559\u7A7A\uFF0C\u5F85\u56DE\u8C03 URL \u6821\u9A8C\u901A\u8FC7\u5E76\u70B9\u51FB\u201C\u5F00\u59CB\u4F7F\u7528\u201D\u540E\u518D\u8865",
+      "webhookPath \u9ED8\u8BA4\u503C\uFF1A/wecom-kf"
+    ].join("\n"),
+    "\u53C2\u6570\u8BF4\u660E"
+  );
   const webhookPath = await prompter.askText({
     label: "Webhook \u8DEF\u5F84\uFF08\u9ED8\u8BA4 /wecom-kf\uFF09",
     defaultValue: toTrimmedString2(existing.webhookPath) ?? "/wecom-kf",
@@ -7054,19 +7094,14 @@ async function configureWecomKf(prompter, cfg) {
     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),
+  const corpSecret = await prompter.askSecret({
+    label: "\u5FAE\u4FE1\u5BA2\u670D Secret\uFF08\u6700\u540E\u586B\u5199\uFF1B\u9996\u6B21\u63A5\u5165\u53EF\u5148\u7559\u7A7A\uFF09",
+    existingValue: toTrimmedString2(existing.corpSecret),
     required: false
   });
   return mergeChannelConfig(cfg, "wecom-kf", {
@@ -7074,8 +7109,72 @@ async function configureWecomKf(prompter, cfg) {
     token,
     encodingAESKey,
     corpId,
-    corpSecret,
     openKfId,
+    corpSecret: corpSecret || void 0
+  });
+}
+async function configureWechatMp(prompter, cfg) {
+  section("\u914D\u7F6E WeChat MP\uFF08\u5FAE\u4FE1\u516C\u4F17\u53F7\uFF09");
+  showGuideLink("wechat-mp");
+  const existing = getChannelConfig(cfg, "wechat-mp");
+  const webhookPath = await prompter.askText({
+    label: "Webhook \u8DEF\u5F84\uFF08\u9ED8\u8BA4 /wechat-mp\uFF09",
+    defaultValue: toTrimmedString2(existing.webhookPath) ?? "/wechat-mp",
+    required: true
+  });
+  const appId = await prompter.askText({
+    label: "\u516C\u4F17\u53F7 appId",
+    defaultValue: toTrimmedString2(existing.appId),
+    required: true
+  });
+  const appSecret = await prompter.askSecret({
+    label: "\u516C\u4F17\u53F7 appSecret\uFF08\u4E3B\u52A8\u53D1\u9001\u9700\u8981\uFF09",
+    existingValue: toTrimmedString2(existing.appSecret),
+    required: false
+  });
+  const token = await prompter.askSecret({
+    label: "\u670D\u52A1\u5668\u914D\u7F6E token",
+    existingValue: toTrimmedString2(existing.token),
+    required: true
+  });
+  const messageMode = await prompter.askSelect(
+    "\u6D88\u606F\u52A0\u89E3\u5BC6\u6A21\u5F0F",
+    [
+      { value: "plain", label: "plain\uFF08\u660E\u6587\uFF09" },
+      { value: "safe", label: "safe\uFF08\u5B89\u5168\u6A21\u5F0F\uFF09" },
+      { value: "compat", label: "compat\uFF08\u517C\u5BB9\u6A21\u5F0F\uFF09" }
+    ],
+    toTrimmedString2(existing.messageMode) ?? "safe"
+  );
+  let encodingAESKey = toTrimmedString2(existing.encodingAESKey);
+  if (messageMode !== "plain") {
+    encodingAESKey = await prompter.askSecret({
+      label: "EncodingAESKey\uFF08safe/compat \u5FC5\u586B\uFF09",
+      existingValue: encodingAESKey,
+      required: true
+    });
+  }
+  const replyMode = await prompter.askSelect(
+    "\u56DE\u590D\u6A21\u5F0F",
+    [
+      { value: "passive", label: "passive\uFF085 \u79D2\u5185\u88AB\u52A8\u56DE\u590D\uFF09" },
+      { value: "active", label: "active\uFF08\u5BA2\u670D\u6D88\u606F\u4E3B\u52A8\u53D1\u9001\uFF09" }
+    ],
+    toTrimmedString2(existing.replyMode) ?? "passive"
+  );
+  const welcomeText = await prompter.askText({
+    label: "\u6B22\u8FCE\u8BED\uFF08\u53EF\u9009\uFF09",
+    defaultValue: toTrimmedString2(existing.welcomeText),
+    required: false
+  });
+  return mergeChannelConfig(cfg, "wechat-mp", {
+    webhookPath,
+    appId,
+    appSecret: appSecret || void 0,
+    token,
+    encodingAESKey: messageMode === "plain" ? void 0 : encodingAESKey,
+    messageMode,
+    replyMode,
     welcomeText: welcomeText || void 0
   });
 }
@@ -7137,6 +7236,8 @@ async function configureSingleChannel(channel, prompter, cfg) {
       return configureWecomApp(prompter, cfg);
     case "wecom-kf":
       return configureWecomKf(prompter, cfg);
+    case "wechat-mp":
+      return configureWechatMp(prompter, cfg);
     case "qqbot":
       return configureQQBot(prompter, cfg);
     default:
@@ -7278,6 +7379,7 @@ var SUPPORTED_CHANNELS = [
   "wecom",
   "wecom-app",
   "wecom-kf",
+  "wechat-mp",
   "qqbot"
 ];
 var CHINA_INSTALL_HINT_SHOWN_KEY = /* @__PURE__ */ Symbol.for("@openclaw-china/china-install-hint-shown");
@@ -9623,6 +9725,37 @@ function startLongTaskNoticeTimer(params) {
     }
   };
 }
+function startQQBotTypingHeartbeat(params) {
+  const { intervalMs, renew, shouldRenew } = params;
+  let stopped = false;
+  let timer = null;
+  let renewalInFlight = false;
+  const clear = () => {
+    if (!timer) return;
+    clearInterval(timer);
+    timer = null;
+  };
+  const stop = () => {
+    if (stopped) return;
+    stopped = true;
+    clear();
+  };
+  if (intervalMs > 0) {
+    timer = setInterval(() => {
+      if (stopped || renewalInFlight) return;
+      if (shouldRenew && !shouldRenew()) return;
+      renewalInFlight = true;
+      void renew().catch(() => void 0).finally(() => {
+        renewalInFlight = false;
+      });
+    }, intervalMs);
+    timer.unref?.();
+  }
+  return {
+    stop,
+    dispose: stop
+  };
+}
 function isHttpUrl3(value) {
   return /^https?:\/\//i.test(value);
 }
@@ -10085,7 +10218,7 @@ function extractLocalMediaFromText(params) {
   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 BARE_LOCAL_MEDIA_PATH_RE = /`?((?:\/(?:tmp|var|private|Users|home|root)\/[^\s`'",)]+|\/mnt\/[A-Za-z]\/[^\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)) {
@@ -10194,6 +10327,10 @@ var MARKDOWN_INLINE_STRUCTURE_RE = /(?:\*\*[^*\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;
+var QQBOT_MARKDOWN_SOFT_LIMIT_THRESHOLD = 128;
+var QQBOT_MARKDOWN_SOFT_LIMIT_HEADROOM_MIN = 16;
+var QQBOT_MARKDOWN_SOFT_LIMIT_HEADROOM_MAX = 320;
+var QQBOT_MARKDOWN_SOFT_LIMIT_HEADROOM_RATIO = 0.18;
 function extractFinalBlocks(text) {
   const matches = Array.from(text.matchAll(FINAL_BLOCK_RE));
   if (matches.length === 0) return void 0;
@@ -10333,6 +10470,72 @@ function appendQQBotBufferedText(bufferedTexts, nextText) {
   }
   return [...bufferedTexts, normalized];
 }
+function resolveQQBotLastNonEmptyLine(text) {
+  return text.split("\n").map((line) => line.trimEnd()).reverse().find((line) => line.trim().length > 0);
+}
+function resolveQQBotFirstNonEmptyLine(text) {
+  return text.split("\n").map((line) => line.trimStart()).find((line) => line.trim().length > 0);
+}
+function resolveQQBotTrailingMarkdownTableColumnCount(text) {
+  const lines = text.split("\n");
+  for (let index = Math.max(0, lines.length - 2); index >= 0; index -= 1) {
+    if (!isQQBotMarkdownTableStart(lines, index)) {
+      continue;
+    }
+    const trailingLines = lines.slice(index + 2).filter((line) => line.trim().length > 0);
+    if (trailingLines.length === 0 || trailingLines.every((line) => line.includes("|"))) {
+      return parseQQBotMarkdownTableRowCells(lines[index] ?? "").length;
+    }
+  }
+  return void 0;
+}
+function mergeQQBotBufferedTextSegments(current, next) {
+  const currentTrimmed = current.trimEnd();
+  const nextTrimmed = next.trimStart();
+  if (!currentTrimmed) return nextTrimmed;
+  if (!nextTrimmed) return currentTrimmed;
+  if (currentTrimmed === nextTrimmed || currentTrimmed.includes(nextTrimmed)) {
+    return currentTrimmed;
+  }
+  if (nextTrimmed.includes(currentTrimmed)) {
+    return nextTrimmed;
+  }
+  const lastLine = resolveQQBotLastNonEmptyLine(currentTrimmed) ?? "";
+  const firstLine = resolveQQBotFirstNonEmptyLine(nextTrimmed) ?? "";
+  const trailingTableColumnCount = resolveQQBotTrailingMarkdownTableColumnCount(currentTrimmed);
+  const lastLineLooksLikeTable = lastLine.includes("|");
+  const firstLineLooksLikeTable = firstLine.startsWith("|");
+  const firstLineContainsTableCell = firstLine.includes("|");
+  const expectedPipeCount = typeof trailingTableColumnCount === "number" && trailingTableColumnCount > 0 ? trailingTableColumnCount + 1 : void 0;
+  const lastLinePipeCount = (lastLine.match(/\|/g) ?? []).length;
+  const firstLinePipeCount = (firstLine.match(/\|/g) ?? []).length;
+  const sameRowJoiner = typeof expectedPipeCount === "number" && lastLinePipeCount + firstLinePipeCount < expectedPipeCount ? " | " : " ";
+  const lastLineEndsInsideTableRow = Boolean(
+    trailingTableColumnCount && lastLineLooksLikeTable && (!lastLine.trimEnd().endsWith("|") || typeof expectedPipeCount === "number" && lastLinePipeCount < expectedPipeCount)
+  );
+  if (lastLineEndsInsideTableRow && nextTrimmed.includes("|")) {
+    return `${currentTrimmed}${sameRowJoiner}${nextTrimmed}`;
+  }
+  if (firstLineLooksLikeTable) {
+    if (lastLineLooksLikeTable || hasQQBotMarkdownTable(currentTrimmed)) {
+      return `${currentTrimmed}
+${nextTrimmed}`;
+    }
+  }
+  if (trailingTableColumnCount && firstLineContainsTableCell) {
+    return `${currentTrimmed}${sameRowJoiner}${nextTrimmed}`;
+  }
+  return joinQQBotMarkdownPieces([currentTrimmed, nextTrimmed]);
+}
+function combineQQBotBufferedText(bufferedTexts) {
+  return bufferedTexts.reduce((combined, segment) => {
+    const normalized = segment.trim();
+    if (!normalized) {
+      return combined;
+    }
+    return mergeQQBotBufferedTextSegments(combined, normalized);
+  }, "");
+}
 function normalizeQQBotRenderedMarkdown(text) {
   if (!text.trim()) return "";
   let next = text.trim();
@@ -10552,6 +10755,25 @@ function parseQQBotMarkdownBlocks(text) {
 function hasQQBotBoundaryGuard(text) {
   return MARKDOWN_BOUNDARY_GUARD_RE.test(text);
 }
+function measureQQBotUtf8Length(text) {
+  return Buffer.byteLength(text, "utf8");
+}
+function findQQBotIndexWithinUtf8Limit(text, limit) {
+  if (limit <= 0 || !text) {
+    return 0;
+  }
+  let totalBytes = 0;
+  let index = 0;
+  for (const char of text) {
+    const charBytes = measureQQBotUtf8Length(char);
+    if (totalBytes + charBytes > limit) {
+      break;
+    }
+    totalBytes += charBytes;
+    index += char.length;
+  }
+  return index;
+}
 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, "");
@@ -10560,13 +10782,14 @@ function isQQBotSafeMarkdownBoundary(text, index) {
   return !hasQQBotBoundaryGuard(leftEdge) && !hasQQBotBoundaryGuard(rightEdge);
 }
 function findQQBotRegexBoundary(text, limit, pattern) {
-  const scopedText = text.slice(0, Math.min(limit + 1, text.length));
+  const scopedIndex = findQQBotIndexWithinUtf8Limit(text, limit);
+  const scopedText = text.slice(0, scopedIndex);
   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)) {
+    if (boundary > 0 && measureQQBotUtf8Length(text.slice(0, boundary)) <= limit && isQQBotSafeMarkdownBoundary(text, boundary)) {
       lastBoundary = boundary;
     }
     match = regex.exec(scopedText);
@@ -10574,13 +10797,14 @@ function findQQBotRegexBoundary(text, limit, pattern) {
   return lastBoundary;
 }
 function findQQBotFallbackBoundary(text, limit) {
-  const minIndex = Math.max(1, limit - 120);
-  for (let index = limit; index >= minIndex; index -= 1) {
+  const maxIndex = findQQBotIndexWithinUtf8Limit(text, limit);
+  const minIndex = Math.max(1, maxIndex - 120);
+  for (let index = maxIndex; index >= minIndex; index -= 1) {
     if (isQQBotSafeMarkdownBoundary(text, index)) {
       return index;
     }
   }
-  return limit;
+  return maxIndex;
 }
 function findQQBotSafeSplitIndex(text, limit) {
   const boundaryPatterns = [
@@ -10599,14 +10823,15 @@ function findQQBotSafeSplitIndex(text, limit) {
   return findQQBotFallbackBoundary(text, limit);
 }
 function splitQQBotHardText(text, limit) {
-  if (limit <= 0 || text.length <= limit) {
+  if (limit <= 0 || measureQQBotUtf8Length(text) <= limit) {
     return [text];
   }
   const chunks = [];
   let remaining = text;
-  while (remaining.length > limit) {
-    chunks.push(remaining.slice(0, limit));
-    remaining = remaining.slice(limit);
+  while (measureQQBotUtf8Length(remaining) > limit) {
+    const nextIndex = Math.max(1, findQQBotIndexWithinUtf8Limit(remaining, limit));
+    chunks.push(remaining.slice(0, nextIndex));
+    remaining = remaining.slice(nextIndex);
   }
   if (remaining) {
     chunks.push(remaining);
@@ -10614,14 +10839,14 @@ function splitQQBotHardText(text, limit) {
   return chunks;
 }
 function splitQQBotTextSafely(text, limit, options) {
-  if (limit <= 0 || text.length <= limit) {
+  if (limit <= 0 || measureQQBotUtf8Length(text) <= limit) {
     return [text];
   }
   const trimLeading = options?.trimLeading ?? true;
   const trimTrailing = options?.trimTrailing ?? true;
   const chunks = [];
   let remaining = text;
-  while (remaining.length > limit) {
+  while (measureQQBotUtf8Length(remaining) > limit) {
     const splitIndex = findQQBotSafeSplitIndex(remaining, limit);
     let nextChunk = remaining.slice(0, splitIndex);
     let nextRemaining = remaining.slice(splitIndex);
@@ -10632,7 +10857,8 @@ function splitQQBotTextSafely(text, limit, options) {
       nextRemaining = nextRemaining.trimStart();
     }
     if (!nextChunk) {
-      const hardChunk = remaining.slice(0, limit);
+      const hardChunkIndex = Math.max(1, findQQBotIndexWithinUtf8Limit(remaining, limit));
+      const hardChunk = remaining.slice(0, hardChunkIndex);
       chunks.push(hardChunk);
       remaining = remaining.slice(hardChunk.length);
       continue;
@@ -10647,7 +10873,7 @@ function splitQQBotTextSafely(text, limit, options) {
   return chunks;
 }
 function splitQQBotMarkdownLineBlock(text, limit) {
-  if (limit <= 0 || text.length <= limit) {
+  if (limit <= 0 || measureQQBotUtf8Length(text) <= limit) {
     return [text];
   }
   const lines = text.split("\n");
@@ -10666,12 +10892,12 @@ function splitQQBotMarkdownLineBlock(text, limit) {
   for (const line of lines) {
     const candidate = currentLines.length > 0 ? `${currentLines.join("\n")}
 ${line}` : line;
-    if (candidate.length <= limit) {
+    if (measureQQBotUtf8Length(candidate) <= limit) {
       currentLines.push(line);
       continue;
     }
     flushCurrent();
-    if (line.length <= limit) {
+    if (measureQQBotUtf8Length(line) <= limit) {
       currentLines.push(line);
       continue;
     }
@@ -10687,16 +10913,133 @@ ${line}` : line;
   flushCurrent();
   return chunks;
 }
+function parseQQBotMarkdownTableRowCells(row, columnCount) {
+  const trimmed = row.trim();
+  const inner = trimmed.replace(/^\|\s*/, "").replace(/\s*\|$/, "");
+  const cells = inner.split("|").map((cell) => cell.trim());
+  if (typeof columnCount !== "number" || !Number.isFinite(columnCount) || columnCount <= 0) {
+    return cells;
+  }
+  if (cells.length >= columnCount) {
+    return cells.slice(0, columnCount);
+  }
+  return [...cells, ...Array.from({ length: columnCount - cells.length }, () => "")];
+}
+function renderQQBotMarkdownTableRow(cells) {
+  return `| ${cells.join(" | ")} |`;
+}
+function splitQQBotMarkdownTableRowByCells(params) {
+  const { row, columnCount, limit } = params;
+  const normalizedCells = parseQQBotMarkdownTableRowCells(row, columnCount);
+  const normalizedRow = renderQQBotMarkdownTableRow(normalizedCells);
+  if (measureQQBotUtf8Length(normalizedRow) <= limit) {
+    return [normalizedRow];
+  }
+  const anchorColumnCount = Math.min(
+    Math.max(1, params.anchorColumnCount ?? 2),
+    columnCount
+  );
+  const anchorCells = normalizedCells.map(
+    (cell, index) => index < anchorColumnCount ? cell : ""
+  );
+  const chunks = [];
+  let currentCells = [...anchorCells];
+  let hasContent = false;
+  const flushCurrent = () => {
+    if (!hasContent) {
+      return;
+    }
+    chunks.push(renderQQBotMarkdownTableRow(currentCells));
+    currentCells = [...anchorCells];
+    hasContent = false;
+  };
+  for (let index = anchorColumnCount; index < columnCount; index += 1) {
+    const cell = normalizedCells[index] ?? "";
+    if (!cell) {
+      continue;
+    }
+    const candidateCells = [...currentCells];
+    candidateCells[index] = cell;
+    if (measureQQBotUtf8Length(renderQQBotMarkdownTableRow(candidateCells)) <= limit) {
+      currentCells[index] = cell;
+      hasContent = true;
+      continue;
+    }
+    if (hasContent) {
+      flushCurrent();
+      const nextCandidateCells = [...currentCells];
+      nextCandidateCells[index] = cell;
+      if (measureQQBotUtf8Length(renderQQBotMarkdownTableRow(nextCandidateCells)) <= limit) {
+        currentCells[index] = cell;
+        hasContent = true;
+        continue;
+      }
+    }
+    const emptyRowBytes = measureQQBotUtf8Length(renderQQBotMarkdownTableRow(currentCells));
+    const availableCellBytes = Math.max(1, limit - emptyRowBytes);
+    for (const cellPiece of splitQQBotTextSafely(cell, availableCellBytes, {
+      trimLeading: false,
+      trimTrailing: false
+    })) {
+      const pieceCells = [...anchorCells];
+      pieceCells[index] = cellPiece;
+      chunks.push(renderQQBotMarkdownTableRow(pieceCells));
+    }
+    currentCells = [...anchorCells];
+    hasContent = false;
+  }
+  flushCurrent();
+  return chunks.length > 0 ? chunks : splitQQBotTextSafely(normalizedRow, limit);
+}
+function resolveQQBotMarkdownTableBlockLimit(params) {
+  const { header, separator, rows, limit } = params;
+  if (limit <= 512) {
+    return limit;
+  }
+  const columnCount = parseQQBotMarkdownTableRowCells(header).length;
+  if (columnCount < 8) {
+    return limit;
+  }
+  const tablePrefixBytes = measureQQBotUtf8Length(`${header}
+${separator}`);
+  const extraColumnCount = Math.max(0, columnCount - 7);
+  const columnPenalty = Math.min(240, extraColumnCount * 55);
+  const headerPenalty = Math.min(120, Math.floor(tablePrefixBytes * 0.25));
+  const reducedLimit = limit - columnPenalty - headerPenalty;
+  const minTableLimit = Math.max(tablePrefixBytes + 64, Math.floor(limit * 0.45));
+  const maxSingleRowRequirement = Math.min(
+    limit,
+    rows.reduce((max, row) => {
+      const normalizedRow = renderQQBotMarkdownTableRow(
+        parseQQBotMarkdownTableRowCells(row, columnCount)
+      );
+      return Math.max(max, measureQQBotUtf8Length(`${header}
+${separator}
+${normalizedRow}`));
+    }, tablePrefixBytes)
+  );
+  return Math.min(
+    limit,
+    Math.max(maxSingleRowRequirement, minTableLimit, Math.min(limit, reducedLimit))
+  );
+}
 function splitQQBotMarkdownTableBlock(text, limit) {
-  if (limit <= 0 || text.length <= limit) {
+  if (limit <= 0 || measureQQBotUtf8Length(text) <= limit) {
     return [text];
   }
   const lines = text.split("\n");
   const header = lines[0] ?? "";
   const separator = lines[1] ?? "";
   const rows = lines.slice(2);
+  const packingLimit = resolveQQBotMarkdownTableBlockLimit({
+    header,
+    separator,
+    rows,
+    limit
+  });
   const tablePrefix = `${header}
 ${separator}`;
+  const columnCount = parseQQBotMarkdownTableRowCells(header).length;
   const chunks = [];
   let currentRows = [];
   const flushCurrent = () => {
@@ -10712,20 +11055,21 @@ ${currentRows.join("\n")}`);
 ${currentRows.join("\n")}
 ${row}` : `${tablePrefix}
 ${row}`;
-    if (candidate.length <= limit) {
+    if (measureQQBotUtf8Length(candidate) <= packingLimit) {
       currentRows.push(row);
       continue;
     }
     flushCurrent();
-    if (`${tablePrefix}
-${row}`.length <= limit) {
+    if (measureQQBotUtf8Length(`${tablePrefix}
+${row}`) <= 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
+    const maxRowLength = Math.max(16, limit - measureQQBotUtf8Length(tablePrefix) - 1);
+    for (const rowPiece of splitQQBotMarkdownTableRowByCells({
+      row,
+      columnCount,
+      limit: maxRowLength
     })) {
       chunks.push(`${tablePrefix}
 ${rowPiece}`);
@@ -10735,7 +11079,7 @@ ${rowPiece}`);
   return chunks.length > 0 ? chunks : [text];
 }
 function splitQQBotMarkdownCodeFence(text, limit) {
-  if (limit <= 0 || text.length <= limit) {
+  if (limit <= 0 || measureQQBotUtf8Length(text) <= limit) {
     return [text];
   }
   const lines = text.split("\n");
@@ -10744,7 +11088,7 @@ function splitQQBotMarkdownCodeFence(text, limit) {
   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 fixedOverhead = measureQQBotUtf8Length(openingLine) + measureQQBotUtf8Length(closingLine) + 2;
   const availableLineLength = Math.max(1, limit - fixedOverhead);
   const chunks = [];
   let currentCodeLines = [];
@@ -10764,14 +11108,14 @@ ${codeLine}
 ${closingLine}` : `${openingLine}
 ${codeLine}
 ${closingLine}`;
-    if (candidate.length <= limit) {
+    if (measureQQBotUtf8Length(candidate) <= limit) {
       currentCodeLines.push(codeLine);
       continue;
     }
     flushCurrent();
-    if (`${openingLine}
+    if (measureQQBotUtf8Length(`${openingLine}
 ${codeLine}
-${closingLine}`.length <= limit) {
+${closingLine}`) <= limit) {
       currentCodeLines.push(codeLine);
       continue;
     }
@@ -10785,7 +11129,7 @@ ${closingLine}`);
   return chunks.length > 0 ? chunks : [text];
 }
 function splitQQBotMarkdownBlock(block, limit) {
-  if (limit <= 0 || block.text.length <= limit) {
+  if (limit <= 0 || measureQQBotUtf8Length(block.text) <= limit) {
     return [block.text];
   }
   switch (block.kind) {
@@ -10806,11 +11150,93 @@ function splitQQBotMarkdownBlock(block, limit) {
       return [block.text];
   }
 }
-function chunkQQBotStructuredMarkdown(text, limit) {
+function resolveQQBotStructuredMarkdownSoftLimit(limit, safeChunkByteLimit) {
+  if (limit <= QQBOT_MARKDOWN_SOFT_LIMIT_THRESHOLD) {
+    return limit;
+  }
+  const configuredSafeLimit = typeof safeChunkByteLimit === "number" && Number.isFinite(safeChunkByteLimit) && safeChunkByteLimit > 0 ? Math.floor(safeChunkByteLimit) : void 0;
+  if (configuredSafeLimit) {
+    return Math.min(limit, configuredSafeLimit);
+  }
+  const reservedLength = Math.min(
+    QQBOT_MARKDOWN_SOFT_LIMIT_HEADROOM_MAX,
+    Math.max(
+      QQBOT_MARKDOWN_SOFT_LIMIT_HEADROOM_MIN,
+      Math.floor(limit * QQBOT_MARKDOWN_SOFT_LIMIT_HEADROOM_RATIO)
+    )
+  );
+  const softLimit = limit - reservedLength;
+  const boundedSoftLimit = Math.min(
+    softLimit > 0 ? softLimit : limit,
+    DEFAULT_QQBOT_C2C_MARKDOWN_SAFE_CHUNK_BYTE_LIMIT
+  );
+  return boundedSoftLimit > 0 ? boundedSoftLimit : limit;
+}
+function maybePrefixQQBotContinuationPiece(params) {
+  const prefix = params.prefix?.trim();
+  if (!prefix) {
+    return params.piece;
+  }
+  const prefixedPiece = joinQQBotMarkdownPieces([prefix, params.piece]);
+  return measureQQBotUtf8Length(prefixedPiece) <= params.limit ? prefixedPiece : params.piece;
+}
+function resolveQQBotMarkdownLeadPiece(blocks, index, limit) {
+  const block = blocks[index];
+  if (!block) {
+    return void 0;
+  }
+  if (block.kind === "heading") {
+    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([block.text, firstBodyPiece]);
+        if (measureQQBotUtf8Length(pairedText) <= limit) {
+          return pairedText;
+        }
+      }
+    }
+  }
+  return splitQQBotMarkdownBlock(block, limit).map((piece) => piece.trim()).find(Boolean);
+}
+function shouldQQBotCarryThematicBreakToNextBlock(params) {
+  const block = params.blocks[params.index];
+  if (!block || block.kind !== "thematic-break") {
+    return false;
+  }
+  if (params.currentPieces.length === 0) {
+    return true;
+  }
+  const withBreak = joinQQBotMarkdownPieces([...params.currentPieces, block.text]);
+  if (measureQQBotUtf8Length(withBreak) > params.limit) {
+    return true;
+  }
+  const nextLeadPiece = resolveQQBotMarkdownLeadPiece(
+    params.blocks,
+    params.index + 1,
+    params.limit
+  );
+  if (!nextLeadPiece) {
+    return false;
+  }
+  const prefixedLeadPiece = joinQQBotMarkdownPieces([block.text, nextLeadPiece]);
+  if (measureQQBotUtf8Length(prefixedLeadPiece) > params.limit) {
+    return false;
+  }
+  const sectionCandidate = joinQQBotMarkdownPieces([
+    ...params.currentPieces,
+    block.text,
+    nextLeadPiece
+  ]);
+  return measureQQBotUtf8Length(sectionCandidate) > params.limit;
+}
+function chunkQQBotStructuredMarkdown(text, limit, safeChunkByteLimit) {
   const blocks = parseQQBotMarkdownBlocks(text);
   if (blocks.length === 0 || limit <= 0) {
     return [text.trim()];
   }
+  const chunkLimit = resolveQQBotStructuredMarkdownSoftLimit(limit, safeChunkByteLimit);
   const chunks = [];
   let currentPieces = [];
   let pendingPrefixPieces = [];
@@ -10828,14 +11254,14 @@ function chunkQQBotStructuredMarkdown(text, limit) {
     if (!piece) {
       return;
     }
-    const pieces = piece.length > limit ? splitQQBotTextSafely(piece, limit) : [piece];
+    const pieces = measureQQBotUtf8Length(piece) > chunkLimit ? splitQQBotTextSafely(piece, chunkLimit) : [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) {
+      if (currentPieces.length === 0 || measureQQBotUtf8Length(candidate) <= chunkLimit) {
         currentPieces.push(normalizedPiece);
         continue;
       }
@@ -10857,9 +11283,19 @@ function chunkQQBotStructuredMarkdown(text, limit) {
       continue;
     }
     if (block.kind === "thematic-break") {
+      if (shouldQQBotCarryThematicBreakToNextBlock({
+        blocks,
+        index,
+        currentPieces,
+        limit: chunkLimit
+      })) {
+        flushCurrent();
+        pendingPrefixPieces.push(block.text);
+        continue;
+      }
       if (currentPieces.length > 0) {
         const candidate = joinQQBotMarkdownPieces([...currentPieces, block.text]);
-        if (candidate.length <= limit) {
+        if (measureQQBotUtf8Length(candidate) <= chunkLimit) {
           currentPieces.push(block.text);
           continue;
         }
@@ -10872,7 +11308,7 @@ function chunkQQBotStructuredMarkdown(text, limit) {
       const headingText = consumePendingPrefix(block.text);
       const nextBlock = blocks[index + 1];
       if (nextBlock && nextBlock.kind !== "thematic-break") {
-        const nextPieces = splitQQBotMarkdownBlock(nextBlock, limit);
+        const nextPieces = splitQQBotMarkdownBlock(nextBlock, chunkLimit);
         const firstBodyPiece = nextPieces[0];
         if (firstBodyPiece) {
           const pairedText = joinQQBotMarkdownPieces([headingText, firstBodyPiece]);
@@ -10881,19 +11317,33 @@ function chunkQQBotStructuredMarkdown(text, limit) {
             headingText,
             firstBodyPiece
           ]);
-          if (pairedText.length <= limit && (currentPieces.length === 0 || pairedCandidate.length <= limit)) {
+          if (measureQQBotUtf8Length(pairedText) <= chunkLimit && (currentPieces.length === 0 || measureQQBotUtf8Length(pairedCandidate) <= chunkLimit)) {
             currentPieces.push(headingText, firstBodyPiece);
             for (let pieceIndex = 1; pieceIndex < nextPieces.length; pieceIndex += 1) {
-              appendPiece(nextPieces[pieceIndex] ?? "");
+              const nextPiece = nextPieces[pieceIndex] ?? "";
+              appendPiece(
+                nextBlock.kind === "table" ? maybePrefixQQBotContinuationPiece({
+                  prefix: headingText,
+                  piece: nextPiece,
+                  limit: chunkLimit
+                }) : nextPiece
+              );
             }
             index += 1;
             continue;
           }
-          if (currentPieces.length > 0 && pairedText.length <= limit) {
+          if (currentPieces.length > 0 && measureQQBotUtf8Length(pairedText) <= chunkLimit) {
             flushCurrent();
             currentPieces.push(headingText, firstBodyPiece);
             for (let pieceIndex = 1; pieceIndex < nextPieces.length; pieceIndex += 1) {
-              appendPiece(nextPieces[pieceIndex] ?? "");
+              const nextPiece = nextPieces[pieceIndex] ?? "";
+              appendPiece(
+                nextBlock.kind === "table" ? maybePrefixQQBotContinuationPiece({
+                  prefix: headingText,
+                  piece: nextPiece,
+                  limit: chunkLimit
+                }) : nextPiece
+              );
             }
             index += 1;
             continue;
@@ -10904,16 +11354,29 @@ function chunkQQBotStructuredMarkdown(text, limit) {
       continue;
     }
     const blockText = consumePendingPrefix(block.text);
-    for (const piece of splitQQBotMarkdownBlock({ ...block, text: blockText }, limit)) {
+    for (const piece of splitQQBotMarkdownBlock({ ...block, text: blockText }, chunkLimit)) {
       appendPiece(piece);
     }
   }
   if (pendingPrefixPieces.length > 0 && currentPieces.length > 0) {
     const trailingCandidate = joinQQBotMarkdownPieces([...currentPieces, ...pendingPrefixPieces]);
-    if (trailingCandidate.length <= limit) {
+    if (measureQQBotUtf8Length(trailingCandidate) <= chunkLimit) {
       currentPieces.push(...pendingPrefixPieces);
+      pendingPrefixPieces = [];
     }
   }
+  if (pendingPrefixPieces.length > 0 && chunks.length > 0) {
+    const trailingPrefix = joinQQBotMarkdownPieces(pendingPrefixPieces);
+    const lastChunk = chunks[chunks.length - 1] ?? "";
+    const trailingCandidate = joinQQBotMarkdownPieces([lastChunk, trailingPrefix]);
+    if (measureQQBotUtf8Length(trailingCandidate) <= chunkLimit) {
+      chunks[chunks.length - 1] = trailingCandidate;
+      pendingPrefixPieces = [];
+    }
+  }
+  if (pendingPrefixPieces.length > 0) {
+    currentPieces.push(joinQQBotMarkdownPieces(pendingPrefixPieces));
+  }
   flushCurrent();
   return chunks.length > 0 ? chunks : [text.trim()];
 }
@@ -10940,7 +11403,7 @@ function chunkC2CMarkdownText(params) {
   if (params.limit <= 0 || !looksLikeStructuredMarkdown(normalized)) {
     return params.fallbackChunkText ? params.fallbackChunkText(normalized) : [normalized];
   }
-  return chunkQQBotStructuredMarkdown(normalized, params.limit);
+  return chunkQQBotStructuredMarkdown(normalized, params.limit, params.safeChunkByteLimit);
 }
 async function sendQQBotMediaWithFallback(params) {
   const { qqCfg, to, mediaQueue, replyToId, replyEventId, accountId, logger, onDelivered, onError } = params;
@@ -11029,6 +11492,9 @@ async function dispatchToAgent(params) {
   };
   const target = resolveChatTarget(inbound);
   const outboundAccountId = route.accountId ?? accountId;
+  const typingHeartbeatMode = resolveQQBotTypingHeartbeatMode(qqCfg);
+  const typingHeartbeatIntervalMs = resolveQQBotTypingHeartbeatIntervalMs(qqCfg);
+  const typingInputSeconds = resolveQQBotTypingInputSeconds(qqCfg);
   let typingRefIdx;
   if (inbound.c2cOpenid && !isFastAbortCommand && !shouldSuppressVisibleReplies()) {
     const typing = await qqbotOutbound.sendTyping({
@@ -11036,7 +11502,7 @@ async function dispatchToAgent(params) {
       to: `user:${inbound.c2cOpenid}`,
       replyToId: inbound.messageId,
       replyEventId: inbound.eventId,
-      inputSecond: 60,
+      inputSecond: typingInputSeconds,
       accountId: outboundAccountId
     });
     if (typing.error) {
@@ -11052,10 +11518,15 @@ async function dispatchToAgent(params) {
   }
   let replyDelivered = false;
   let groupMessageInterfaceBlocked = false;
+  let lastVisibleOutboundAt = Date.now();
+  let typingHeartbeat = null;
   const markReplyDelivered = () => {
     replyDelivered = true;
     longTaskNotice.markReplyDelivered();
   };
+  const markVisibleOutboundStarted = () => {
+    lastVisibleOutboundAt = Date.now();
+  };
   const markGroupMessageInterfaceBlocked = (error) => {
     if (!isQQBotGroupMessageInterfaceBlocked(error)) return;
     if (!groupMessageInterfaceBlocked) {
@@ -11063,11 +11534,40 @@ async function dispatchToAgent(params) {
     }
     groupMessageInterfaceBlocked = true;
   };
+  if (inbound.c2cOpenid && typingHeartbeatMode !== "none" && !isFastAbortCommand && !shouldSuppressVisibleReplies()) {
+    typingHeartbeat = startQQBotTypingHeartbeat({
+      intervalMs: typingHeartbeatIntervalMs,
+      shouldRenew: () => {
+        if (shouldSuppressVisibleReplies()) {
+          return false;
+        }
+        if (typingHeartbeatMode === "always") {
+          return true;
+        }
+        return Date.now() - lastVisibleOutboundAt >= typingHeartbeatIntervalMs;
+      },
+      renew: async () => {
+        try {
+          const typing = await qqbotOutbound.sendTyping({
+            cfg: { channels: { qqbot: qqCfg } },
+            to: `user:${inbound.c2cOpenid}`,
+            replyToId: inbound.messageId,
+            replyEventId: inbound.eventId,
+            inputSecond: typingInputSeconds,
+            accountId: outboundAccountId
+          });
+          void typing;
+        } catch {
+        }
+      }
+    });
+  }
   const longTaskNotice = startLongTaskNoticeTimer({
     delayMs: qqCfg.longTaskNoticeDelayMs ?? DEFAULT_LONG_TASK_NOTICE_DELAY_MS,
     logger,
     sendNotice: async () => {
       if (groupMessageInterfaceBlocked || isFastAbortCommand || shouldSuppressVisibleReplies()) return;
+      markVisibleOutboundStarted();
       const result = await qqbotOutbound.sendText({
         cfg: { channels: { qqbot: qqCfg } },
         to: target.to,
@@ -11080,7 +11580,7 @@ async function dispatchToAgent(params) {
         logger.warn(`send long-task notice failed: ${result.error}`);
         markGroupMessageInterfaceBlocked(result.error);
       } else {
-        replyDelivered = true;
+        markReplyDelivered();
       }
     }
   });
@@ -11104,6 +11604,7 @@ async function dispatchToAgent(params) {
       if (shouldSuppressVisibleReplies()) {
         return;
       }
+      markVisibleOutboundStarted();
       const fallback = await qqbotOutbound.sendText({
         cfg: { channels: { qqbot: qqCfg } },
         to: target.to,
@@ -11116,7 +11617,7 @@ async function dispatchToAgent(params) {
         logger.error(`sendText ASR fallback failed: ${fallback.error}`);
         markGroupMessageInterfaceBlocked(fallback.error);
       } else {
-        replyDelivered = true;
+        markReplyDelivered();
       }
       return;
     }
@@ -11278,6 +11779,7 @@ async function dispatchToAgent(params) {
     const markdownSupport = qqCfg.markdownSupport ?? true;
     const c2cMarkdownDeliveryMode = qqCfg.c2cMarkdownDeliveryMode ?? "proactive-table-only";
     const c2cMarkdownChunkStrategy = qqCfg.c2cMarkdownChunkStrategy ?? "markdown-block";
+    const c2cMarkdownSafeChunkByteLimit = resolveQQBotC2CMarkdownSafeChunkByteLimit(qqCfg);
     const isC2CTarget = isQQBotC2CTarget(target.to);
     const useC2CMarkdownTransport = markdownSupport && isC2CTarget;
     let bufferedC2CMarkdownTexts = [];
@@ -11315,13 +11817,17 @@ async function dispatchToAgent(params) {
         text: finalMarkdownText,
         limit,
         strategy: c2cMarkdownChunkStrategy,
+        safeChunkByteLimit: c2cMarkdownSafeChunkByteLimit,
         fallbackChunkText: chunkText
       }) : [];
       const deliveryLabel = textReplyRefs.forceProactive ? "c2c-markdown-proactive" : "c2c-markdown-passive";
       logger.info(
-        `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}`
+        `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} safeChunkByteLimit=${String(c2cMarkdownSafeChunkByteLimit ?? "auto")}`
       );
       if (!shouldSuppressVisibleReplies()) {
+        if (mediaQueue.length > 0) {
+          markVisibleOutboundStarted();
+        }
         await sendQQBotMediaWithFallback({
           qqCfg,
           to: target.to,
@@ -11350,6 +11856,7 @@ async function dispatchToAgent(params) {
         logger.info(
           `delivery=${deliveryLabel} segment=1/1 chunk=${chunkIndex + 1}/${textChunks.length} phase=${params2.phase} preview=${formatQQBotOutboundPreview(chunk)}`
         );
+        markVisibleOutboundStarted();
         const result = await qqbotOutbound.sendText({
           cfg: { channels: { qqbot: qqCfg } },
           to: target.to,
@@ -11380,7 +11887,7 @@ async function dispatchToAgent(params) {
         bufferedC2CMarkdownMediaSeen.clear();
         return;
       }
-      const combinedText = bufferedC2CMarkdownTexts.join("\n\n").trim();
+      const combinedText = combineQQBotBufferedText(bufferedC2CMarkdownTexts);
       const combinedMediaUrls = [...bufferedC2CMarkdownMediaUrls];
       bufferedC2CMarkdownTexts = [];
       bufferedC2CMarkdownMediaUrls = [];
@@ -11426,7 +11933,7 @@ async function dispatchToAgent(params) {
       const textToSend = suppressText ? "" : cleanedText;
       if (useC2CMarkdownTransport) {
         const shouldBufferFinalOnlyPayload = replyFinalOnly && (!info?.kind || info.kind === "final");
-        const shouldBufferStructuredMarkdownPayload = !replyFinalOnly && c2cMarkdownChunkStrategy === "markdown-block" && info?.kind !== "tool" && looksLikeStructuredMarkdown(textToSend);
+        const shouldBufferStructuredMarkdownPayload = !replyFinalOnly && c2cMarkdownChunkStrategy === "markdown-block" && info?.kind !== "tool" && (hasBufferedC2CMarkdownReply() || looksLikeStructuredMarkdown(textToSend));
         if (shouldBufferFinalOnlyPayload || shouldBufferStructuredMarkdownPayload) {
           if (textToSend) {
             bufferedC2CMarkdownTexts = appendQQBotBufferedText(bufferedC2CMarkdownTexts, textToSend);
@@ -11464,6 +11971,7 @@ async function dispatchToAgent(params) {
           if (shouldSuppressVisibleReplies()) {
             return;
           }
+          markVisibleOutboundStarted();
           const result = await qqbotOutbound.sendText({
             cfg: { channels: { qqbot: qqCfg } },
             to: target.to,
@@ -11483,6 +11991,9 @@ async function dispatchToAgent(params) {
       if (shouldSuppressVisibleReplies()) {
         return;
       }
+      if (mediaQueue.length > 0) {
+        markVisibleOutboundStarted();
+      }
       await sendQQBotMediaWithFallback({
         qqCfg,
         to: target.to,
@@ -11587,6 +12098,7 @@ async function dispatchToAgent(params) {
     });
     if (noReplyFallback && !groupMessageInterfaceBlocked && !isFastAbortCommand && !shouldSuppressVisibleReplies()) {
       logger.info("no visible reply generated for group mention; sending fallback text");
+      markVisibleOutboundStarted();
       const fallbackResult = await qqbotOutbound.sendText({
         cfg: { channels: { qqbot: qqCfg } },
         to: target.to,
@@ -11603,6 +12115,7 @@ async function dispatchToAgent(params) {
       }
     }
   } finally {
+    typingHeartbeat?.dispose();
     longTaskNotice.dispose();
     try {
       await pruneInboundMediaDir({
@@ -12205,6 +12718,7 @@ var qqbotPlugin = {
           type: "string",
           enum: ["markdown-block", "length"]
         },
+        c2cMarkdownSafeChunkByteLimit: { type: "integer", minimum: 1 },
         dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
         groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
         requireMention: { type: "boolean" },
@@ -12258,6 +12772,7 @@ var qqbotPlugin = {
                 type: "string",
                 enum: ["markdown-block", "length"]
               },
+              c2cMarkdownSafeChunkByteLimit: { type: "integer", minimum: 1 },
               dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
               groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
               requireMention: { type: "boolean" },
@@ -12470,6 +12985,7 @@ var plugin = {
         type: "string",
         enum: ["markdown-block", "length"]
       },
+      c2cMarkdownSafeChunkByteLimit: { type: "integer", minimum: 1 },
       dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
       groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
       requireMention: { type: "boolean" },
@@ -12523,6 +13039,7 @@ var plugin = {
               type: "string",
               enum: ["markdown-block", "length"]
             },
+            c2cMarkdownSafeChunkByteLimit: { type: "integer", minimum: 1 },
             dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
             groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
             requireMention: { type: "boolean" },